git.oblomov.eu Git - wine/blob - dlls/dbghelp/symbol.c

   1 /*
   2  * File symbol.c - management of symbols (lexical tree)
   3  *
   4  * Copyright (C) 1993, Eric Youngdale.
   5  *               2004, Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24
  25 #include "config.h"
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <limits.h>
  31 #include <sys/types.h>
  32 #include <assert.h>
  33 #ifdef HAVE_REGEX_H
  34 # include <regex.h>
  35 #endif
  36
  37 #include "wine/debug.h"
  38 #include "dbghelp_private.h"
  39 #include "winnls.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  42 WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt);
  43
  44 inline static int cmp_addr(ULONG64 a1, ULONG64 a2)
  45 {
  46     if (a1 > a2) return 1;
  47     if (a1 < a2) return -1;
  48     return 0;
  49 }
  50
  51 inline static int cmp_sorttab_addr(const struct module* module, int idx, ULONG64 addr)
  52 {
  53     ULONG64     ref;
  54
  55     symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &ref);
  56     return cmp_addr(ref, addr);
  57 }
  58
  59 int symt_cmp_addr(const void* p1, const void* p2)
  60 {
  61     const struct symt*  sym1 = *(const struct symt* const *)p1;
  62     const struct symt*  sym2 = *(const struct symt* const *)p2;
  63     ULONG64     a1, a2;
  64
  65     symt_get_info(sym1, TI_GET_ADDRESS, &a1);
  66     symt_get_info(sym2, TI_GET_ADDRESS, &a2);
  67     return cmp_addr(a1, a2);
  68 }
  69
  70 static inline void re_append(char** mask, unsigned* len, char ch)
  71 {
  72     *mask = HeapReAlloc(GetProcessHeap(), 0, *mask, ++(*len));
  73     (*mask)[*len - 2] = ch;
  74 }
  75
  76 /* transforms a dbghelp's regular expression into a POSIX one
  77  * Here are the valid dbghelp reg ex characters:
  78  *      *       0 or more characters
  79  *      ?       a single character
  80  *      []      list
  81  *      #       0 or more of preceding char
  82  *      +       1 or more of preceding char
  83  *      escapes \ on #, ?, [, ], *, +. don't work on -
  84  */
  85 static void compile_regex(const char* str, int numchar, regex_t* re, BOOL _case)
  86 {
  87     char*       mask = HeapAlloc(GetProcessHeap(), 0, 1);
  88     unsigned    len = 1;
  89     BOOL        in_escape = FALSE;
  90     unsigned    flags = REG_NOSUB;
  91
  92     re_append(&mask, &len, '^');
  93
  94     while (*str && numchar--)
  95     {
  96         /* FIXME: this shouldn't be valid on '-' */
  97         if (in_escape)
  98         {
  99             re_append(&mask, &len, '\\');
 100             re_append(&mask, &len, *str);
 101             in_escape = FALSE;
 102         }
 103         else switch (*str)
 104         {
 105         case '\\': in_escape = TRUE; break;
 106         case '*':  re_append(&mask, &len, '.'); re_append(&mask, &len, '*'); break;
 107         case '?':  re_append(&mask, &len, '.'); break;
 108         case '#':  re_append(&mask, &len, '*'); break;
 109         /* escape some valid characters in dbghelp reg exp:s */
 110         case '$':  re_append(&mask, &len, '\\'); re_append(&mask, &len, '$'); break;
 111         /* +, [, ], - are the same in dbghelp & POSIX, use them as any other char */
 112         default:   re_append(&mask, &len, *str); break;
 113         }
 114         str++;
 115     }
 116     if (in_escape)
 117     {
 118         re_append(&mask, &len, '\\');
 119         re_append(&mask, &len, '\\');
 120     }
 121     re_append(&mask, &len, '$');
 122     mask[len - 1] = '\0';
 123     if (_case) flags |= REG_ICASE;
 124     if (regcomp(re, mask, flags)) FIXME("Couldn't compile %s\n", mask);
 125     HeapFree(GetProcessHeap(), 0, mask);
 126 }
 127
 128 struct symt_compiland* symt_new_compiland(struct module* module, unsigned src_idx)
 129 {
 130     struct symt_compiland*    sym;
 131
 132     TRACE_(dbghelp_symt)("Adding compiland symbol %s:%s\n",
 133                          module->module.ModuleName, source_get(module, src_idx));
 134     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 135     {
 136         sym->symt.tag = SymTagCompiland;
 137         sym->source   = src_idx;
 138         vector_init(&sym->vchildren, sizeof(struct symt*), 32);
 139     }
 140     return sym;
 141 }
 142
 143 struct symt_public* symt_new_public(struct module* module,
 144                                     struct symt_compiland* compiland,
 145                                     const char* name,
 146                                     unsigned long address, unsigned size,
 147                                     BOOL in_code, BOOL is_func)
 148 {
 149     struct symt_public* sym;
 150     struct symt**       p;
 151
 152     TRACE_(dbghelp_symt)("Adding public symbol %s:%s @%lx\n",
 153                          module->module.ModuleName, name, address);
 154     if ((dbghelp_options & SYMOPT_AUTO_PUBLICS) &&
 155         symt_find_nearest(module, address) != -1)
 156         return NULL;
 157     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 158     {
 159         sym->symt.tag      = SymTagPublicSymbol;
 160         sym->hash_elt.name = pool_strdup(&module->pool, name);
 161         hash_table_add(&module->ht_symbols, &sym->hash_elt);
 162         module->sortlist_valid = FALSE;
 163         sym->container     = compiland ? &compiland->symt : NULL;
 164         sym->address       = address;
 165         sym->size          = size;
 166         sym->in_code       = in_code;
 167         sym->is_function   = is_func;
 168         if (compiland)
 169         {
 170             p = vector_add(&compiland->vchildren, &module->pool);
 171             *p = &sym->symt;
 172         }
 173     }
 174     return sym;
 175 }
 176
 177 struct symt_data* symt_new_global_variable(struct module* module,
 178                                            struct symt_compiland* compiland,
 179                                            const char* name, unsigned is_static,
 180                                            unsigned long addr, unsigned long size,
 181                                            struct symt* type)
 182 {
 183     struct symt_data*   sym;
 184     struct symt**       p;
 185     DWORD64             tsz;
 186
 187     TRACE_(dbghelp_symt)("Adding global symbol %s:%s @%lx %p\n",
 188                          module->module.ModuleName, name, addr, type);
 189     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 190     {
 191         sym->symt.tag      = SymTagData;
 192         sym->hash_elt.name = pool_strdup(&module->pool, name);
 193         hash_table_add(&module->ht_symbols, &sym->hash_elt);
 194         module->sortlist_valid = FALSE;
 195         sym->kind          = is_static ? DataIsFileStatic : DataIsGlobal;
 196         sym->container     = compiland ? &compiland->symt : NULL;
 197         sym->type          = type;
 198         sym->u.address     = addr;
 199         if (type && size && symt_get_info(type, TI_GET_LENGTH, &tsz))
 200         {
 201             if (tsz != size)
 202                 FIXME("Size mismatch for %s.%s between type (%s) and src (%lu)\n",
 203                       module->module.ModuleName, name,
 204                       wine_dbgstr_longlong(tsz), size);
 205         }
 206         if (compiland)
 207         {
 208             p = vector_add(&compiland->vchildren, &module->pool);
 209             *p = &sym->symt;
 210         }
 211     }
 212     return sym;
 213 }
 214
 215 struct symt_function* symt_new_function(struct module* module,
 216                                         struct symt_compiland* compiland,
 217                                         const char* name,
 218                                         unsigned long addr, unsigned long size,
 219                                         struct symt* sig_type)
 220 {
 221     struct symt_function*       sym;
 222     struct symt**               p;
 223
 224     TRACE_(dbghelp_symt)("Adding global function %s:%s @%lx-%lx\n",
 225                          module->module.ModuleName, name, addr, addr + size - 1);
 226
 227     assert(!sig_type || sig_type->tag == SymTagFunctionType);
 228     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 229     {
 230         sym->symt.tag  = SymTagFunction;
 231         sym->hash_elt.name = pool_strdup(&module->pool, name);
 232         hash_table_add(&module->ht_symbols, &sym->hash_elt);
 233         module->sortlist_valid = FALSE;
 234         sym->container = &compiland->symt;
 235         sym->address   = addr;
 236         sym->type      = sig_type;
 237         sym->size      = size;
 238         vector_init(&sym->vlines,  sizeof(struct line_info), 64);
 239         vector_init(&sym->vchildren, sizeof(struct symt*), 8);
 240         if (compiland)
 241         {
 242             p = vector_add(&compiland->vchildren, &module->pool);
 243             *p = &sym->symt;
 244         }
 245     }
 246     return sym;
 247 }
 248
 249 void symt_add_func_line(struct module* module, struct symt_function* func,
 250                         unsigned source_idx, int line_num, unsigned long offset)
 251 {
 252     struct line_info*   dli;
 253     BOOL                last_matches = FALSE;
 254
 255     if (func == NULL || !(dbghelp_options & SYMOPT_LOAD_LINES)) return;
 256
 257     TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n",
 258                          func, func->hash_elt.name, offset,
 259                          source_get(module, source_idx), line_num);
 260
 261     assert(func->symt.tag == SymTagFunction);
 262
 263     dli = NULL;
 264     while ((dli = vector_iter_down(&func->vlines, dli)))
 265     {
 266         if (dli->is_source_file)
 267         {
 268             last_matches = (source_idx == dli->u.source_file);
 269             break;
 270         }
 271     }
 272
 273     if (!last_matches)
 274     {
 275         /* we shouldn't have line changes on first line of function */
 276         dli = vector_add(&func->vlines, &module->pool);
 277         dli->is_source_file = 1;
 278         dli->is_first       = dli->is_last = 0;
 279         dli->line_number    = 0;
 280         dli->u.source_file  = source_idx;
 281     }
 282     dli = vector_add(&func->vlines, &module->pool);
 283     dli->is_source_file = 0;
 284     dli->is_first       = dli->is_last = 0;
 285     dli->line_number    = line_num;
 286     dli->u.pc_offset    = func->address + offset;
 287 }
 288
 289 /******************************************************************
 290  *             symt_add_func_local
 291  *
 292  * Adds a new local/parameter to a given function:
 293  * In any cases, dt tells whether it's a local variable or a parameter
 294  * If regno it's not 0:
 295  *      - then variable is stored in a register
 296  *      - otherwise, value is referenced by register + offset
 297  * Otherwise, the variable is stored on the stack:
 298  *      - offset is then the offset from the frame register
 299  */
 300 struct symt_data* symt_add_func_local(struct module* module,
 301                                       struct symt_function* func,
 302                                       enum DataKind dt,
 303                                       int regno, BOOL regrel, long offset,
 304                                       struct symt_block* block,
 305                                       struct symt* type, const char* name)
 306 {
 307     struct symt_data*   locsym;
 308     struct symt**       p;
 309
 310     TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n",
 311                          module->module.ModuleName, func->hash_elt.name,
 312                          name, type);
 313
 314     assert(func);
 315     assert(func->symt.tag == SymTagFunction);
 316     assert(dt == DataIsParam || dt == DataIsLocal);
 317
 318     locsym = pool_alloc(&module->pool, sizeof(*locsym));
 319     locsym->symt.tag      = SymTagData;
 320     locsym->hash_elt.name = pool_strdup(&module->pool, name);
 321     locsym->hash_elt.next = NULL;
 322     locsym->kind          = dt;
 323     locsym->container     = &block->symt;
 324     locsym->type          = type;
 325     locsym->u.s.reg_id    = regno;
 326     locsym->u.s.reg_rel   = regrel ? TRUE : FALSE;
 327     locsym->u.s.offset    = offset * 8;
 328     locsym->u.s.length    = 0;
 329     if (block)
 330         p = vector_add(&block->vchildren, &module->pool);
 331     else
 332         p = vector_add(&func->vchildren, &module->pool);
 333     *p = &locsym->symt;
 334     return locsym;
 335 }
 336
 337
 338 struct symt_block* symt_open_func_block(struct module* module,
 339                                         struct symt_function* func,
 340                                         struct symt_block* parent_block,
 341                                         unsigned pc, unsigned len)
 342 {
 343     struct symt_block*  block;
 344     struct symt**       p;
 345
 346     assert(func);
 347     assert(func->symt.tag == SymTagFunction);
 348
 349     assert(!parent_block || parent_block->symt.tag == SymTagBlock);
 350     block = pool_alloc(&module->pool, sizeof(*block));
 351     block->symt.tag = SymTagBlock;
 352     block->address  = func->address + pc;
 353     block->size     = len;
 354     block->container = parent_block ? &parent_block->symt : &func->symt;
 355     vector_init(&block->vchildren, sizeof(struct symt*), 4);
 356     if (parent_block)
 357         p = vector_add(&parent_block->vchildren, &module->pool);
 358     else
 359         p = vector_add(&func->vchildren, &module->pool);
 360     *p = &block->symt;
 361
 362     return block;
 363 }
 364
 365 struct symt_block* symt_close_func_block(struct module* module,
 366                                          struct symt_function* func,
 367                                          struct symt_block* block, unsigned pc)
 368 {
 369     assert(func);
 370     assert(func->symt.tag == SymTagFunction);
 371
 372     if (pc) block->size = func->address + pc - block->address;
 373     return (block->container->tag == SymTagBlock) ?
 374         GET_ENTRY(block->container, struct symt_block, symt) : NULL;
 375 }
 376
 377 struct symt_function_point* symt_add_function_point(struct module* module,
 378                                                     struct symt_function* func,
 379                                                     enum SymTagEnum point,
 380                                                     unsigned offset, const char* name)
 381 {
 382     struct symt_function_point* sym;
 383     struct symt**               p;
 384
 385     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 386     {
 387         sym->symt.tag = point;
 388         sym->parent   = func;
 389         sym->offset   = offset;
 390         sym->name     = name ? pool_strdup(&module->pool, name) : NULL;
 391         p = vector_add(&func->vchildren, &module->pool);
 392         *p = &sym->symt;
 393     }
 394     return sym;
 395 }
 396
 397 BOOL symt_normalize_function(struct module* module, struct symt_function* func)
 398 {
 399     unsigned            len;
 400     struct line_info*   dli;
 401
 402     assert(func);
 403     /* We aren't adding any more locals or line numbers to this function.
 404      * Free any spare memory that we might have allocated.
 405      */
 406     assert(func->symt.tag == SymTagFunction);
 407
 408 /* EPP     vector_pool_normalize(&func->vlines,    &module->pool); */
 409 /* EPP     vector_pool_normalize(&func->vchildren, &module->pool); */
 410
 411     len = vector_length(&func->vlines);
 412     if (len--)
 413     {
 414         dli = vector_at(&func->vlines,   0);  dli->is_first = 1;
 415         dli = vector_at(&func->vlines, len);  dli->is_last  = 1;
 416     }
 417     return TRUE;
 418 }
 419
 420 struct symt_thunk* symt_new_thunk(struct module* module,
 421                                   struct symt_compiland* compiland,
 422                                   const char* name, THUNK_ORDINAL ord,
 423                                   unsigned long addr, unsigned long size)
 424 {
 425     struct symt_thunk*  sym;
 426
 427     TRACE_(dbghelp_symt)("Adding global thunk %s:%s @%lx-%lx\n",
 428                          module->module.ModuleName, name, addr, addr + size - 1);
 429
 430     if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
 431     {
 432         sym->symt.tag  = SymTagThunk;
 433         sym->hash_elt.name = pool_strdup(&module->pool, name);
 434         hash_table_add(&module->ht_symbols, &sym->hash_elt);
 435         module->sortlist_valid = FALSE;
 436         sym->container = &compiland->symt;
 437         sym->address   = addr;
 438         sym->size      = size;
 439         sym->ordinal   = ord;
 440         if (compiland)
 441         {
 442             struct symt**       p;
 443             p = vector_add(&compiland->vchildren, &module->pool);
 444             *p = &sym->symt;
 445         }
 446     }
 447     return sym;
 448 }
 449
 450 /* expect sym_info->MaxNameLen to be set before being called */
 451 static void symt_fill_sym_info(const struct module_pair* pair,
 452                                const struct symt* sym, SYMBOL_INFO* sym_info)
 453 {
 454     const char* name;
 455     DWORD64 size;
 456
 457     if (!symt_get_info(sym, TI_GET_TYPE, &sym_info->TypeIndex))
 458         sym_info->TypeIndex = 0;
 459     sym_info->info = (DWORD)sym;
 460     sym_info->Reserved[0] = sym_info->Reserved[1] = 0;
 461     if (!symt_get_info(sym, TI_GET_LENGTH, &size) &&
 462         (!sym_info->TypeIndex ||
 463          !symt_get_info((struct symt*)sym_info->TypeIndex, TI_GET_LENGTH, &size)))
 464         size = 0;
 465     sym_info->Size = (DWORD)size;
 466     sym_info->ModBase = pair->requested->module.BaseOfImage;
 467     sym_info->Flags = 0;
 468     sym_info->Value = 0;
 469
 470     switch (sym->tag)
 471     {
 472     case SymTagData:
 473         {
 474             const struct symt_data*  data = (const struct symt_data*)sym;
 475             switch (data->kind)
 476             {
 477             case DataIsParam:
 478                 sym_info->Flags |= SYMFLAG_PARAMETER;
 479                 /* fall through */
 480             case DataIsLocal:
 481                 if (!data->u.s.reg_rel)
 482                 {
 483                     sym_info->Flags |= SYMFLAG_REGISTER;
 484                     sym_info->Register = data->u.s.reg_id;
 485                     sym_info->Address = 0;
 486                 }
 487                 else
 488                 {
 489                     sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_REGREL;
 490                     /* FIXME: it's i386 dependent !!! */
 491                     sym_info->Register = data->u.s.reg_id ? data->u.s.reg_id : CV_REG_EBP;
 492                     sym_info->Address = data->u.s.offset / 8;
 493                 }
 494                 break;
 495             case DataIsGlobal:
 496             case DataIsFileStatic:
 497                 symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
 498                 sym_info->Register = 0;
 499                 break;
 500             case DataIsConstant:
 501                 sym_info->Flags |= SYMFLAG_VALUEPRESENT;
 502                 switch (data->u.value.n1.n2.vt)
 503                 {
 504                 case VT_I4:  sym_info->Value = (ULONG)data->u.value.n1.n2.n3.lVal; break;
 505                 case VT_I2:  sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.iVal; break;
 506                 case VT_I1:  sym_info->Value = (ULONG)(long)data->u.value.n1.n2.n3.cVal; break;
 507                 case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break;
 508                 case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break;
 509                 case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break;
 510                 default:
 511                     FIXME("Unsupported variant type (%u)\n", data->u.value.n1.n2.vt);
 512                 }
 513                 break;
 514             default:
 515                 FIXME("Unhandled kind (%u) in sym data\n", data->kind);
 516             }
 517         }
 518         break;
 519     case SymTagPublicSymbol:
 520         sym_info->Flags |= SYMFLAG_EXPORT;
 521         symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
 522         break;
 523     case SymTagFunction:
 524         sym_info->Flags |= SYMFLAG_FUNCTION;
 525         symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
 526         break;
 527     case SymTagThunk:
 528         sym_info->Flags |= SYMFLAG_THUNK;
 529         symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
 530         break;
 531     default:
 532         symt_get_info(sym, TI_GET_ADDRESS, &sym_info->Address);
 533         sym_info->Register = 0;
 534         break;
 535     }
 536     sym_info->Scope = 0; /* FIXME */
 537     sym_info->Tag = sym->tag;
 538     name = symt_get_name(sym);
 539     if (sym_info->MaxNameLen)
 540     {
 541         if (sym->tag != SymTagPublicSymbol || !(dbghelp_options & SYMOPT_UNDNAME) ||
 542             (sym_info->NameLen = UnDecorateSymbolName(name, sym_info->Name,
 543                                                       sym_info->MaxNameLen, UNDNAME_COMPLETE) == 0))
 544         {
 545             sym_info->NameLen = min(strlen(name), sym_info->MaxNameLen - 1);
 546             memcpy(sym_info->Name, name, sym_info->NameLen);
 547             sym_info->Name[sym_info->NameLen] = '\0';
 548         }
 549     }
 550     TRACE_(dbghelp_symt)("%p => %s %lu %s\n",
 551                          sym, sym_info->Name, sym_info->Size,
 552                          wine_dbgstr_longlong(sym_info->Address));
 553 }
 554
 555 struct sym_enum
 556 {
 557     PSYM_ENUMERATESYMBOLS_CALLBACK      cb;
 558     PVOID                               user;
 559     SYMBOL_INFO*                        sym_info;
 560     DWORD                               index;
 561     DWORD                               tag;
 562     DWORD64                             addr;
 563     char                                buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
 564 };
 565
 566 static BOOL send_symbol(const struct sym_enum* se, struct module_pair* pair,
 567                         const struct symt* sym)
 568 {
 569     symt_fill_sym_info(pair, sym, se->sym_info);
 570     if (se->index && se->sym_info->info != se->index) return FALSE;
 571     if (se->tag && se->sym_info->Tag != se->tag) return FALSE;
 572     if (se->addr && !(se->addr >= se->sym_info->Address && se->addr < se->sym_info->Address + se->sym_info->Size)) return FALSE;
 573     return !se->cb(se->sym_info, se->sym_info->Size, se->user);
 574 }
 575
 576 static BOOL symt_enum_module(struct module_pair* pair, regex_t* regex,
 577                              const struct sym_enum* se)
 578 {
 579     void*                       ptr;
 580     struct symt_ht*             sym = NULL;
 581     struct hash_table_iter      hti;
 582
 583     hash_table_iter_init(&pair->effective->ht_symbols, &hti, NULL);
 584     while ((ptr = hash_table_iter_up(&hti)))
 585     {
 586         sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
 587         if (sym->hash_elt.name &&
 588             regexec(regex, sym->hash_elt.name, 0, NULL, 0) == 0)
 589         {
 590             se->sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
 591             se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO);
 592             if (send_symbol(se, pair, &sym->symt)) return TRUE;
 593         }
 594     }
 595     return FALSE;
 596 }
 597
 598 /***********************************************************************
 599  *              resort_symbols
 600  *
 601  * Rebuild sorted list of symbols for a module.
 602  */
 603 static BOOL resort_symbols(struct module* module)
 604 {
 605     int                         nsym;
 606     void*                       ptr;
 607     struct symt_ht*             sym;
 608     struct hash_table_iter      hti;
 609
 610     if (!module_compute_num_syms(module)) return FALSE;
 611
 612     if (module->addr_sorttab)
 613         module->addr_sorttab = HeapReAlloc(GetProcessHeap(), 0,
 614                                            module->addr_sorttab,
 615                                            module->module.NumSyms * sizeof(struct symt_ht*));
 616     else
 617         module->addr_sorttab = HeapAlloc(GetProcessHeap(), 0,
 618                                          module->module.NumSyms * sizeof(struct symt_ht*));
 619     if (!module->addr_sorttab) return FALSE;
 620
 621     nsym = 0;
 622     hash_table_iter_init(&module->ht_symbols, &hti, NULL);
 623     while ((ptr = hash_table_iter_up(&hti)))
 624     {
 625         sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
 626         assert(sym);
 627         module->addr_sorttab[nsym++] = sym;
 628     }
 629
 630     qsort(module->addr_sorttab, nsym, sizeof(struct symt_ht*), symt_cmp_addr);
 631     return module->sortlist_valid = TRUE;
 632 }
 633
 634 /* assume addr is in module */
 635 int symt_find_nearest(struct module* module, DWORD addr)
 636 {
 637     int         mid, high, low;
 638     ULONG64     ref_addr, ref_size;
 639
 640     if (!module->sortlist_valid || !module->addr_sorttab)
 641     {
 642         if (!resort_symbols(module)) return -1;
 643     }
 644
 645     /*
 646      * Binary search to find closest symbol.
 647      */
 648     low = 0;
 649     high = module->module.NumSyms;
 650
 651     symt_get_info(&module->addr_sorttab[0]->symt, TI_GET_ADDRESS, &ref_addr);
 652     if (addr < ref_addr) return -1;
 653     if (high)
 654     {
 655         symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_ADDRESS, &ref_addr);
 656         if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size)
 657             ref_size = 0x1000; /* arbitrary value */
 658         if (addr >= ref_addr + ref_size) return -1;
 659     }
 660
 661     while (high > low + 1)
 662     {
 663         mid = (high + low) / 2;
 664         if (cmp_sorttab_addr(module, mid, addr) < 0)
 665             low = mid;
 666         else
 667             high = mid;
 668     }
 669     if (low != high && high != module->module.NumSyms &&
 670         cmp_sorttab_addr(module, high, addr) <= 0)
 671         low = high;
 672
 673     /* If found symbol is a public symbol, check if there are any other entries that
 674      * might also have the same address, but would get better information
 675      */
 676     if (module->addr_sorttab[low]->symt.tag == SymTagPublicSymbol)
 677     {
 678         symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr);
 679         if (low > 0 &&
 680             module->addr_sorttab[low - 1]->symt.tag != SymTagPublicSymbol &&
 681             !cmp_sorttab_addr(module, low - 1, ref_addr))
 682             low--;
 683         else if (low < module->module.NumSyms - 1 &&
 684                  module->addr_sorttab[low + 1]->symt.tag != SymTagPublicSymbol &&
 685                  !cmp_sorttab_addr(module, low + 1, ref_addr))
 686             low++;
 687     }
 688     /* finally check that we fit into the found symbol */
 689     symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr);
 690     if (addr < ref_addr) return -1;
 691     if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size)
 692         ref_size = 0x1000; /* arbitrary value */
 693     if (addr >= ref_addr + ref_size) return -1;
 694
 695     return low;
 696 }
 697
 698 static BOOL symt_enum_locals_helper(struct process* pcs, struct module_pair* pair,
 699                                     regex_t* preg, const struct sym_enum* se,
 700                                     struct vector* v)
 701 {
 702     struct symt**       plsym = NULL;
 703     struct symt*        lsym = NULL;
 704     DWORD               pc = pcs->ctx_frame.InstructionOffset;
 705
 706     while ((plsym = vector_iter_up(v, plsym)))
 707     {
 708         lsym = *plsym;
 709         switch (lsym->tag)
 710         {
 711         case SymTagBlock:
 712             {
 713                 struct symt_block*  block = (struct symt_block*)lsym;
 714                 if (pc < block->address || block->address + block->size <= pc)
 715                     continue;
 716                 if (!symt_enum_locals_helper(pcs, pair, preg, se, &block->vchildren))
 717                     return FALSE;
 718             }
 719             break;
 720         case SymTagData:
 721             if (regexec(preg, symt_get_name(lsym), 0, NULL, 0) == 0)
 722             {
 723                 if (send_symbol(se, pair, lsym)) return FALSE;
 724             }
 725             break;
 726         case SymTagLabel:
 727         case SymTagFuncDebugStart:
 728         case SymTagFuncDebugEnd:
 729             break;
 730         default:
 731             FIXME("Unknown type: %u (%x)\n", lsym->tag, lsym->tag);
 732             assert(0);
 733         }
 734     }
 735     return TRUE;
 736 }
 737
 738 static BOOL symt_enum_locals(struct process* pcs, const char* mask,
 739                              const struct sym_enum* se)
 740 {
 741     struct module_pair  pair;
 742     struct symt_ht*     sym;
 743     DWORD               pc = pcs->ctx_frame.InstructionOffset;
 744     int                 idx;
 745
 746     se->sym_info->SizeOfStruct = sizeof(*se->sym_info);
 747     se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO);
 748
 749     pair.requested = module_find_by_addr(pcs, pc, DMT_UNKNOWN);
 750     if (!module_get_debug(pcs, &pair)) return FALSE;
 751     if ((idx = symt_find_nearest(pair.effective, pc)) == -1) return FALSE;
 752
 753     sym = pair.effective->addr_sorttab[idx];
 754     if (sym->symt.tag == SymTagFunction)
 755     {
 756         BOOL            ret;
 757         regex_t         preg;
 758
 759         compile_regex(mask ? mask : "*", -1, &preg,
 760                       dbghelp_options & SYMOPT_CASE_INSENSITIVE);
 761         ret = symt_enum_locals_helper(pcs, &pair, &preg, se,
 762                                       &((struct symt_function*)sym)->vchildren);
 763         regfree(&preg);
 764         return ret;
 765
 766     }
 767     return send_symbol(se, &pair, &sym->symt);
 768 }
 769
 770 /******************************************************************
 771  *              copy_symbolW
 772  *
 773  * Helper for transforming an ANSI symbol info into an UNICODE one.
 774  * Assume that MaxNameLen is the same for both version (A & W).
 775  */
 776 static void copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si)
 777 {
 778     siw->SizeOfStruct = si->SizeOfStruct;
 779     siw->TypeIndex = si->TypeIndex;
 780     siw->Reserved[0] = si->Reserved[0];
 781     siw->Reserved[1] = si->Reserved[1];
 782     siw->Index = si->info; /* FIXME: see dbghelp.h */
 783     siw->Size = si->Size;
 784     siw->ModBase = si->ModBase;
 785     siw->Flags = si->Flags;
 786     siw->Value = si->Value;
 787     siw->Address = si->Address;
 788     siw->Register = si->Register;
 789     siw->Scope = si->Scope;
 790     siw->Tag = si->Tag;
 791     siw->NameLen = si->NameLen;
 792     siw->MaxNameLen = si->MaxNameLen;
 793     MultiByteToWideChar(CP_ACP, 0, si->Name, -1, siw->Name, siw->MaxNameLen);
 794 }
 795
 796 /******************************************************************
 797  *              sym_enum
 798  *
 799  * Core routine for most of the enumeration of symbols
 800  */
 801 static BOOL sym_enum(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask,
 802                      const struct sym_enum* se)
 803 {
 804     struct process*     pcs = process_find_by_handle(hProcess);
 805     struct module_pair  pair;
 806     const char*         bang;
 807     regex_t             mod_regex, sym_regex;
 808
 809     if (BaseOfDll == 0)
 810     {
 811         /* do local variables ? */
 812         if (!Mask || !(bang = strchr(Mask, '!')))
 813             return symt_enum_locals(pcs, Mask, se);
 814
 815         if (bang == Mask) return FALSE;
 816
 817         compile_regex(Mask, bang - Mask, &mod_regex, TRUE);
 818         compile_regex(bang + 1, -1, &sym_regex,
 819                       dbghelp_options & SYMOPT_CASE_INSENSITIVE);
 820
 821         for (pair.requested = pcs->lmodules; pair.requested; pair.requested = pair.requested->next)
 822         {
 823             if (pair.requested->type == DMT_PE && module_get_debug(pcs, &pair))
 824             {
 825                 if (regexec(&mod_regex, pair.requested->module.ModuleName, 0, NULL, 0) == 0 &&
 826                     symt_enum_module(&pair, &sym_regex, se))
 827                     break;
 828             }
 829         }
 830         /* not found in PE modules, retry on the ELF ones
 831          */
 832         if (!pair.requested && (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES))
 833         {
 834             for (pair.requested = pcs->lmodules; pair.requested; pair.requested = pair.requested->next)
 835             {
 836                 if (pair.requested->type == DMT_ELF &&
 837                     !module_get_containee(pcs, pair.requested) &&
 838                     module_get_debug(pcs, &pair))
 839                 {
 840                     if (regexec(&mod_regex, pair.requested->module.ModuleName, 0, NULL, 0) == 0 &&
 841                         symt_enum_module(&pair, &sym_regex, se))
 842                     break;
 843                 }
 844             }
 845         }
 846         regfree(&mod_regex);
 847         regfree(&sym_regex);
 848         return TRUE;
 849     }
 850     pair.requested = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 851     if (!module_get_debug(pcs, &pair))
 852         return FALSE;
 853
 854     /* we always ignore module name from Mask when BaseOfDll is defined */
 855     if (Mask && (bang = strchr(Mask, '!')))
 856     {
 857         if (bang == Mask) return FALSE;
 858         Mask = bang + 1;
 859     }
 860
 861     compile_regex(Mask ? Mask : "*", -1, &sym_regex,
 862                   dbghelp_options & SYMOPT_CASE_INSENSITIVE);
 863     symt_enum_module(&pair, &sym_regex, se);
 864     regfree(&sym_regex);
 865
 866     return TRUE;
 867 }
 868
 869 /******************************************************************
 870  *              SymEnumSymbols (DBGHELP.@)
 871  *
 872  * cases BaseOfDll = 0
 873  *      !foo fails always (despite what MSDN states)
 874  *      RE1!RE2 looks up all modules matching RE1, and in all these modules, lookup RE2
 875  *      no ! in Mask, lookup in local Context
 876  * cases BaseOfDll != 0
 877  *      !foo fails always (despite what MSDN states)
 878  *      RE1!RE2 gets RE2 from BaseOfDll (whatever RE1 is)
 879  */
 880 BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask,
 881                            PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
 882                            PVOID UserContext)
 883 {
 884     struct sym_enum     se;
 885
 886     TRACE("(%p %s %s %p %p)\n",
 887           hProcess, wine_dbgstr_longlong(BaseOfDll), debugstr_a(Mask),
 888           EnumSymbolsCallback, UserContext);
 889
 890     se.cb = EnumSymbolsCallback;
 891     se.user = UserContext;
 892     se.index = 0;
 893     se.tag = 0;
 894     se.addr = 0;
 895     se.sym_info = (PSYMBOL_INFO)se.buffer;
 896
 897     return sym_enum(hProcess, BaseOfDll, Mask, &se);
 898 }
 899
 900 struct sym_enumW
 901 {
 902     PSYM_ENUMERATESYMBOLS_CALLBACKW     cb;
 903     void*                               ctx;
 904     PSYMBOL_INFOW                       sym_info;
 905     char                                buffer[sizeof(SYMBOL_INFOW) + MAX_SYM_NAME];
 906
 907 };
 908
 909 static BOOL CALLBACK sym_enumW(PSYMBOL_INFO si, ULONG size, PVOID ctx)
 910 {
 911     struct sym_enumW*   sew = ctx;
 912
 913     copy_symbolW(sew->sym_info, si);
 914
 915     return (sew->cb)(sew->sym_info, size, sew->ctx);
 916 }
 917
 918 /******************************************************************
 919  *              SymEnumSymbolsW (DBGHELP.@)
 920  *
 921  */
 922 BOOL WINAPI SymEnumSymbolsW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask,
 923                             PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
 924                             PVOID UserContext)
 925 {
 926     struct sym_enumW    sew;
 927     BOOL                ret = FALSE;
 928     char*               maskA = NULL;
 929
 930     sew.ctx = UserContext;
 931     sew.cb = EnumSymbolsCallback;
 932     sew.sym_info = (PSYMBOL_INFOW)sew.buffer;
 933
 934     if (Mask)
 935     {
 936         unsigned len = WideCharToMultiByte(CP_ACP, 0, Mask, -1, NULL, 0, NULL, NULL);
 937         maskA = HeapAlloc(GetProcessHeap(), 0, len);
 938         if (!maskA) return FALSE;
 939         WideCharToMultiByte(CP_ACP, 0, Mask, -1, maskA, len, NULL, NULL);
 940     }
 941     ret = SymEnumSymbols(hProcess, BaseOfDll, maskA, sym_enumW, &sew);
 942     HeapFree(GetProcessHeap(), 0, maskA);
 943
 944     return ret;
 945 }
 946
 947 struct sym_enumerate
 948 {
 949     void*                       ctx;
 950     PSYM_ENUMSYMBOLS_CALLBACK   cb;
 951 };
 952
 953 static BOOL CALLBACK sym_enumerate_cb(PSYMBOL_INFO syminfo, ULONG size, void* ctx)
 954 {
 955     struct sym_enumerate*       se = (struct sym_enumerate*)ctx;
 956     return (se->cb)(syminfo->Name, syminfo->Address, syminfo->Size, se->ctx);
 957 }
 958
 959 /***********************************************************************
 960  *              SymEnumerateSymbols (DBGHELP.@)
 961  */
 962 BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll,
 963                                 PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
 964                                 PVOID UserContext)
 965 {
 966     struct sym_enumerate        se;
 967
 968     se.ctx = UserContext;
 969     se.cb  = EnumSymbolsCallback;
 970
 971     return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb, &se);
 972 }
 973
 974 /******************************************************************
 975  *              SymFromAddr (DBGHELP.@)
 976  *
 977  */
 978 BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address,
 979                         DWORD64* Displacement, PSYMBOL_INFO Symbol)
 980 {
 981     struct process*     pcs = process_find_by_handle(hProcess);
 982     struct module_pair  pair;
 983     struct symt_ht*     sym;
 984     int                 idx;
 985
 986     if (!pcs) return FALSE;
 987     pair.requested = module_find_by_addr(pcs, Address, DMT_UNKNOWN);
 988     if (!module_get_debug(pcs, &pair)) return FALSE;
 989     if ((idx = symt_find_nearest(pair.effective, Address)) == -1) return FALSE;
 990
 991     sym = pair.effective->addr_sorttab[idx];
 992
 993     symt_fill_sym_info(&pair, &sym->symt, Symbol);
 994     *Displacement = Address - Symbol->Address;
 995     return TRUE;
 996 }
 997
 998 /******************************************************************
 999  *              SymFromAddrW (DBGHELP.@)
1000  *
1001  */
1002 BOOL WINAPI SymFromAddrW(HANDLE hProcess, DWORD64 Address,
1003                          DWORD64* Displacement, PSYMBOL_INFOW Symbol)
1004 {
1005     PSYMBOL_INFO        si;
1006     unsigned            len;
1007     BOOL                ret;
1008
1009     len = sizeof(*si) + Symbol->MaxNameLen * sizeof(WCHAR);
1010     si = HeapAlloc(GetProcessHeap(), 0, len);
1011     if (!si) return FALSE;
1012
1013     si->SizeOfStruct = sizeof(*si);
1014     si->MaxNameLen = Symbol->MaxNameLen;
1015     if ((ret = SymFromAddr(hProcess, Address, Displacement, si)))
1016     {
1017         copy_symbolW(Symbol, si);
1018     }
1019     HeapFree(GetProcessHeap(), 0, si);
1020     return ret;
1021 }
1022
1023 /******************************************************************
1024  *              SymGetSymFromAddr (DBGHELP.@)
1025  *
1026  */
1027 BOOL WINAPI SymGetSymFromAddr(HANDLE hProcess, DWORD Address,
1028                               PDWORD Displacement, PIMAGEHLP_SYMBOL Symbol)
1029 {
1030     char        buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1031     SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1032     size_t      len;
1033     DWORD64     Displacement64;
1034
1035     if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1036     si->SizeOfStruct = sizeof(*si);
1037     si->MaxNameLen = MAX_SYM_NAME;
1038     if (!SymFromAddr(hProcess, Address, &Displacement64, si))
1039         return FALSE;
1040
1041     if (Displacement)
1042         *Displacement = Displacement64;
1043     Symbol->Address = si->Address;
1044     Symbol->Size    = si->Size;
1045     Symbol->Flags   = si->Flags;
1046     len = min(Symbol->MaxNameLength, si->MaxNameLen);
1047     lstrcpynA(Symbol->Name, si->Name, len);
1048     return TRUE;
1049 }
1050
1051 /******************************************************************
1052  *              SymGetSymFromAddr64 (DBGHELP.@)
1053  *
1054  */
1055 BOOL WINAPI SymGetSymFromAddr64(HANDLE hProcess, DWORD64 Address,
1056                                 PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol)
1057 {
1058     char        buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1059     SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1060     size_t      len;
1061     DWORD64     Displacement64;
1062
1063     if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1064     si->SizeOfStruct = sizeof(*si);
1065     si->MaxNameLen = MAX_SYM_NAME;
1066     if (!SymFromAddr(hProcess, Address, &Displacement64, si))
1067         return FALSE;
1068
1069     if (Displacement)
1070         *Displacement = Displacement64;
1071     Symbol->Address = si->Address;
1072     Symbol->Size    = si->Size;
1073     Symbol->Flags   = si->Flags;
1074     len = min(Symbol->MaxNameLength, si->MaxNameLen);
1075     lstrcpynA(Symbol->Name, si->Name, len);
1076     return TRUE;
1077 }
1078
1079 static BOOL find_name(struct process* pcs, struct module* module, const char* name,
1080                       SYMBOL_INFO* symbol)
1081 {
1082     struct hash_table_iter      hti;
1083     void*                       ptr;
1084     struct symt_ht*             sym = NULL;
1085     struct module_pair          pair;
1086
1087     if (!(pair.requested = module)) return FALSE;
1088     if (!module_get_debug(pcs, &pair)) return FALSE;
1089
1090     hash_table_iter_init(&pair.effective->ht_symbols, &hti, name);
1091     while ((ptr = hash_table_iter_up(&hti)))
1092     {
1093         sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
1094
1095         if (!strcmp(sym->hash_elt.name, name))
1096         {
1097             symt_fill_sym_info(&pair, &sym->symt, symbol);
1098             return TRUE;
1099         }
1100     }
1101     return FALSE;
1102
1103 }
1104 /******************************************************************
1105  *              SymFromName (DBGHELP.@)
1106  *
1107  */
1108 BOOL WINAPI SymFromName(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol)
1109 {
1110     struct process*             pcs = process_find_by_handle(hProcess);
1111     struct module*              module;
1112     const char*                 name;
1113
1114     TRACE("(%p, %s, %p)\n", hProcess, Name, Symbol);
1115     if (!pcs) return FALSE;
1116     if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1117     name = strchr(Name, '!');
1118     if (name)
1119     {
1120         char    tmp[128];
1121         assert(name - Name < sizeof(tmp));
1122         memcpy(tmp, Name, name - Name);
1123         tmp[name - Name] = '\0';
1124         module = module_find_by_name(pcs, tmp, DMT_UNKNOWN);
1125         return find_name(pcs, module, name + 1, Symbol);
1126     }
1127     for (module = pcs->lmodules; module; module = module->next)
1128     {
1129         if (module->type == DMT_PE && find_name(pcs, module, Name, Symbol))
1130             return TRUE;
1131     }
1132     /* not found in PE modules, retry on the ELF ones
1133      */
1134     if (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES)
1135     {
1136         for (module = pcs->lmodules; module; module = module->next)
1137         {
1138             if (module->type == DMT_ELF && !module_get_containee(pcs, module) &&
1139                 find_name(pcs, module, Name, Symbol))
1140                 return TRUE;
1141         }
1142     }
1143     return FALSE;
1144 }
1145
1146 /***********************************************************************
1147  *              SymGetSymFromName (DBGHELP.@)
1148  */
1149 BOOL WINAPI SymGetSymFromName(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL Symbol)
1150 {
1151     char        buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1152     SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1153     size_t      len;
1154
1155     if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE;
1156     si->SizeOfStruct = sizeof(*si);
1157     si->MaxNameLen = MAX_SYM_NAME;
1158     if (!SymFromName(hProcess, Name, si)) return FALSE;
1159
1160     Symbol->Address = si->Address;
1161     Symbol->Size    = si->Size;
1162     Symbol->Flags   = si->Flags;
1163     len = min(Symbol->MaxNameLength, si->MaxNameLen);
1164     lstrcpynA(Symbol->Name, si->Name, len);
1165     return TRUE;
1166 }
1167
1168 /******************************************************************
1169  *              sym_fill_func_line_info
1170  *
1171  * fills information about a file
1172  */
1173 BOOL symt_fill_func_line_info(struct module* module, struct symt_function* func,
1174                               DWORD addr, IMAGEHLP_LINE* line)
1175 {
1176     struct line_info*   dli = NULL;
1177     BOOL                found = FALSE;
1178
1179     assert(func->symt.tag == SymTagFunction);
1180
1181     while ((dli = vector_iter_down(&func->vlines, dli)))
1182     {
1183         if (!dli->is_source_file)
1184         {
1185             if (found || dli->u.pc_offset > addr) continue;
1186             line->LineNumber = dli->line_number;
1187             line->Address    = dli->u.pc_offset;
1188             line->Key        = dli;
1189             found = TRUE;
1190             continue;
1191         }
1192         if (found)
1193         {
1194             line->FileName = (char*)source_get(module, dli->u.source_file);
1195             return TRUE;
1196         }
1197     }
1198     return FALSE;
1199 }
1200
1201 /***********************************************************************
1202  *              SymGetSymNext (DBGHELP.@)
1203  */
1204 BOOL WINAPI SymGetSymNext(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1205 {
1206     /* algo:
1207      * get module from Symbol.Address
1208      * get index in module.addr_sorttab of Symbol.Address
1209      * increment index
1210      * if out of module bounds, move to next module in process address space
1211      */
1212     FIXME("(%p, %p): stub\n", hProcess, Symbol);
1213     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1214     return FALSE;
1215 }
1216
1217 /***********************************************************************
1218  *              SymGetSymPrev (DBGHELP.@)
1219  */
1220
1221 BOOL WINAPI SymGetSymPrev(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol)
1222 {
1223     FIXME("(%p, %p): stub\n", hProcess, Symbol);
1224     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1225     return FALSE;
1226 }
1227
1228 /******************************************************************
1229  *              SymGetLineFromAddr (DBGHELP.@)
1230  *
1231  */
1232 BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr,
1233                                PDWORD pdwDisplacement, PIMAGEHLP_LINE Line)
1234 {
1235     struct process*     pcs = process_find_by_handle(hProcess);
1236     struct module_pair  pair;
1237     int                 idx;
1238
1239     TRACE("%p %08lx %p %p\n", hProcess, dwAddr, pdwDisplacement, Line);
1240
1241     if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1242
1243     if (!pcs) return FALSE;
1244     pair.requested = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1245     if (!module_get_debug(pcs, &pair)) return FALSE;
1246     if ((idx = symt_find_nearest(pair.effective, dwAddr)) == -1) return FALSE;
1247
1248     if (pair.effective->addr_sorttab[idx]->symt.tag != SymTagFunction) return FALSE;
1249     if (!symt_fill_func_line_info(pair.effective,
1250                                   (struct symt_function*)pair.effective->addr_sorttab[idx],
1251                                   dwAddr, Line)) return FALSE;
1252     *pdwDisplacement = dwAddr - Line->Address;
1253     return TRUE;
1254 }
1255
1256 /******************************************************************
1257  *              copy_line_64_from_32 (internal)
1258  *
1259  */
1260 static void copy_line_64_from_32(IMAGEHLP_LINE64* l64, const IMAGEHLP_LINE* l32)
1261
1262 {
1263     l64->Key = l32->Key;
1264     l64->LineNumber = l32->LineNumber;
1265     l64->FileName = l32->FileName;
1266     l64->Address = l32->Address;
1267 }
1268
1269 /******************************************************************
1270  *              copy_line_W64_from_32 (internal)
1271  *
1272  */
1273 static void copy_line_W64_from_32(struct process* pcs, IMAGEHLP_LINEW64* l64, const IMAGEHLP_LINE* l32)
1274 {
1275     unsigned len;
1276
1277     l64->Key = l32->Key;
1278     l64->LineNumber = l32->LineNumber;
1279     len = MultiByteToWideChar(CP_ACP, 0, l32->FileName, -1, NULL, 0);
1280     if ((l64->FileName = fetch_buffer(pcs, len * sizeof(WCHAR))))
1281         MultiByteToWideChar(CP_ACP, 0, l32->FileName, -1, l64->FileName, len);
1282     l64->Address = l32->Address;
1283 }
1284
1285 /******************************************************************
1286  *              copy_line_32_from_64 (internal)
1287  *
1288  */
1289 static void copy_line_32_from_64(IMAGEHLP_LINE* l32, const IMAGEHLP_LINE64* l64)
1290
1291 {
1292     l32->Key = l64->Key;
1293     l32->LineNumber = l64->LineNumber;
1294     l32->FileName = l64->FileName;
1295     l32->Address = l64->Address;
1296 }
1297
1298 /******************************************************************
1299  *              SymGetLineFromAddr64 (DBGHELP.@)
1300  *
1301  */
1302 BOOL WINAPI SymGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
1303                                  PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line)
1304 {
1305     IMAGEHLP_LINE       line32;
1306
1307     if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1308     if (!validate_addr64(dwAddr)) return FALSE;
1309     line32.SizeOfStruct = sizeof(line32);
1310     if (!SymGetLineFromAddr(hProcess, (DWORD)dwAddr, pdwDisplacement, &line32))
1311         return FALSE;
1312     copy_line_64_from_32(Line, &line32);
1313     return TRUE;
1314 }
1315
1316 /******************************************************************
1317  *              SymGetLineFromAddrW64 (DBGHELP.@)
1318  *
1319  */
1320 BOOL WINAPI SymGetLineFromAddrW64(HANDLE hProcess, DWORD64 dwAddr,
1321                                   PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line)
1322 {
1323     struct process*     pcs = process_find_by_handle(hProcess);
1324     IMAGEHLP_LINE       line32;
1325
1326     if (!pcs) return FALSE;
1327     if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1328     if (!validate_addr64(dwAddr)) return FALSE;
1329     line32.SizeOfStruct = sizeof(line32);
1330     if (!SymGetLineFromAddr(hProcess, (DWORD)dwAddr, pdwDisplacement, &line32))
1331         return FALSE;
1332     copy_line_W64_from_32(pcs, Line, &line32);
1333     return TRUE;
1334 }
1335
1336 /******************************************************************
1337  *              SymGetLinePrev (DBGHELP.@)
1338  *
1339  */
1340 BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line)
1341 {
1342     struct process*     pcs = process_find_by_handle(hProcess);
1343     struct module_pair  pair;
1344     struct line_info*   li;
1345     BOOL                in_search = FALSE;
1346
1347     TRACE("(%p %p)\n", hProcess, Line);
1348
1349     if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1350
1351     if (!pcs) return FALSE;
1352     pair.requested = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN);
1353     if (!module_get_debug(pcs, &pair)) return FALSE;
1354
1355     if (Line->Key == 0) return FALSE;
1356     li = (struct line_info*)Line->Key;
1357     /* things are a bit complicated because when we encounter a DLIT_SOURCEFILE
1358      * element we have to go back until we find the prev one to get the real
1359      * source file name for the DLIT_OFFSET element just before
1360      * the first DLIT_SOURCEFILE
1361      */
1362     while (!li->is_first)
1363     {
1364         li--;
1365         if (!li->is_source_file)
1366         {
1367             Line->LineNumber = li->line_number;
1368             Line->Address    = li->u.pc_offset;
1369             Line->Key        = li;
1370             if (!in_search) return TRUE;
1371         }
1372         else
1373         {
1374             if (in_search)
1375             {
1376                 Line->FileName = (char*)source_get(pair.effective, li->u.source_file);
1377                 return TRUE;
1378             }
1379             in_search = TRUE;
1380         }
1381     }
1382     SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1383     return FALSE;
1384 }
1385
1386 /******************************************************************
1387  *              SymGetLinePrev64 (DBGHELP.@)
1388  *
1389  */
1390 BOOL WINAPI SymGetLinePrev64(HANDLE hProcess, PIMAGEHLP_LINE64 Line)
1391 {
1392     IMAGEHLP_LINE       line32;
1393
1394     line32.SizeOfStruct = sizeof(line32);
1395     copy_line_32_from_64(&line32, Line);
1396     if (!SymGetLinePrev(hProcess, &line32)) return FALSE;
1397     copy_line_64_from_32(Line, &line32);
1398     return TRUE;
1399 }
1400
1401 BOOL symt_get_func_line_next(struct module* module, PIMAGEHLP_LINE line)
1402 {
1403     struct line_info*   li;
1404
1405     if (line->Key == 0) return FALSE;
1406     li = (struct line_info*)line->Key;
1407     while (!li->is_last)
1408     {
1409         li++;
1410         if (!li->is_source_file)
1411         {
1412             line->LineNumber = li->line_number;
1413             line->Address    = li->u.pc_offset;
1414             line->Key        = li;
1415             return TRUE;
1416         }
1417         line->FileName = (char*)source_get(module, li->u.source_file);
1418     }
1419     return FALSE;
1420 }
1421
1422 /******************************************************************
1423  *              SymGetLineNext (DBGHELP.@)
1424  *
1425  */
1426 BOOL WINAPI SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line)
1427 {
1428     struct process*     pcs = process_find_by_handle(hProcess);
1429     struct module_pair  pair;
1430
1431     TRACE("(%p %p)\n", hProcess, Line);
1432
1433     if (Line->SizeOfStruct < sizeof(*Line)) return FALSE;
1434     if (!pcs) return FALSE;
1435     pair.requested = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN);
1436     if (!module_get_debug(pcs, &pair)) return FALSE;
1437
1438     if (symt_get_func_line_next(pair.effective, Line)) return TRUE;
1439     SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */
1440     return FALSE;
1441 }
1442
1443 /******************************************************************
1444  *              SymGetLineNext64 (DBGHELP.@)
1445  *
1446  */
1447 BOOL WINAPI SymGetLineNext64(HANDLE hProcess, PIMAGEHLP_LINE64 Line)
1448 {
1449     IMAGEHLP_LINE       line32;
1450
1451     line32.SizeOfStruct = sizeof(line32);
1452     copy_line_32_from_64(&line32, Line);
1453     if (!SymGetLineNext(hProcess, &line32)) return FALSE;
1454     copy_line_64_from_32(Line, &line32);
1455     return TRUE;
1456 }
1457
1458 /***********************************************************************
1459  *              SymFunctionTableAccess (DBGHELP.@)
1460  */
1461 PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase)
1462 {
1463     WARN("(%p, 0x%08lx): stub\n", hProcess, AddrBase);
1464     return NULL;
1465 }
1466
1467 /***********************************************************************
1468  *              SymFunctionTableAccess64 (DBGHELP.@)
1469  */
1470 PVOID WINAPI SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase)
1471 {
1472     WARN("(%p, %s): stub\n", hProcess, wine_dbgstr_longlong(AddrBase));
1473     return NULL;
1474 }
1475
1476 /***********************************************************************
1477  *              SymUnDName (DBGHELP.@)
1478  */
1479 BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL sym, LPSTR UnDecName, DWORD UnDecNameLength)
1480 {
1481     TRACE("(%p %s %lu)\n", sym, UnDecName, UnDecNameLength);
1482     return UnDecorateSymbolName(sym->Name, UnDecName, UnDecNameLength,
1483                                 UNDNAME_COMPLETE) != 0;
1484 }
1485
1486 static void* und_alloc(size_t len) { return HeapAlloc(GetProcessHeap(), 0, len); }
1487 static void  und_free (void* ptr)  { HeapFree(GetProcessHeap(), 0, ptr); }
1488
1489 /***********************************************************************
1490  *              UnDecorateSymbolName (DBGHELP.@)
1491  */
1492 DWORD WINAPI UnDecorateSymbolName(LPCSTR DecoratedName, LPSTR UnDecoratedName,
1493                                   DWORD UndecoratedLength, DWORD Flags)
1494 {
1495     /* undocumented from msvcrt */
1496     static char* (*p_undname)(char*, const char*, int, void* (*)(size_t), void (*)(void*), unsigned short);
1497     static const WCHAR szMsvcrt[] = {'m','s','v','c','r','t','.','d','l','l',0};
1498
1499     TRACE("(%s, %p, %ld, 0x%08lx)\n",
1500           debugstr_a(DecoratedName), UnDecoratedName, UndecoratedLength, Flags);
1501
1502     if (!p_undname)
1503     {
1504         if (!hMsvcrt) hMsvcrt = LoadLibraryW(szMsvcrt);
1505         if (hMsvcrt) p_undname = (void*)GetProcAddress(hMsvcrt, "__unDName");
1506         if (!p_undname) return 0;
1507     }
1508
1509     if (!UnDecoratedName) return 0;
1510     if (!p_undname(UnDecoratedName, DecoratedName, UndecoratedLength,
1511                    und_alloc, und_free, Flags))
1512         return 0;
1513     return strlen(UnDecoratedName);
1514 }
1515
1516 /******************************************************************
1517  *              SymMatchString (DBGHELP.@)
1518  *
1519  */
1520 BOOL WINAPI SymMatchString(PCSTR string, PCSTR re, BOOL _case)
1521 {
1522     regex_t     preg;
1523     BOOL        ret;
1524
1525     TRACE("%s %s %c\n", string, re, _case ? 'Y' : 'N');
1526
1527     compile_regex(re, -1, &preg, _case);
1528     ret = regexec(&preg, string, 0, NULL, 0) == 0;
1529     regfree(&preg);
1530     return ret;
1531 }
1532
1533 /******************************************************************
1534  *              SymSearch (DBGHELP.@)
1535  */
1536 BOOL WINAPI SymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
1537                       DWORD SymTag, PCSTR Mask, DWORD64 Address,
1538                       PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
1539                       PVOID UserContext, DWORD Options)
1540 {
1541     struct sym_enum     se;
1542
1543     TRACE("(%p %s %lu %lu %s %s %p %p %lx)\n",
1544           hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, Mask,
1545           wine_dbgstr_longlong(Address), EnumSymbolsCallback,
1546           UserContext, Options);
1547
1548     if (Options != SYMSEARCH_GLOBALSONLY)
1549     {
1550         FIXME("Unsupported searching with options (%lx)\n", Options);
1551         SetLastError(ERROR_INVALID_PARAMETER);
1552         return FALSE;
1553     }
1554
1555     se.cb = EnumSymbolsCallback;
1556     se.user = UserContext;
1557     se.index = Index;
1558     se.tag = SymTag;
1559     se.addr = Address;
1560     se.sym_info = (PSYMBOL_INFO)se.buffer;
1561
1562     return sym_enum(hProcess, BaseOfDll, Mask, &se);
1563 }
1564
1565 /******************************************************************
1566  *              SymSearchW (DBGHELP.@)
1567  */
1568 BOOL WINAPI SymSearchW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
1569                        DWORD SymTag, PCWSTR Mask, DWORD64 Address,
1570                        PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
1571                        PVOID UserContext, DWORD Options)
1572 {
1573     struct sym_enumW    sew;
1574     BOOL                ret = FALSE;
1575     char*               maskA = NULL;
1576
1577     TRACE("(%p %s %lu %lu %s %s %p %p %lx)\n",
1578           hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, debugstr_w(Mask),
1579           wine_dbgstr_longlong(Address), EnumSymbolsCallback,
1580           UserContext, Options);
1581
1582     sew.ctx = UserContext;
1583     sew.cb = EnumSymbolsCallback;
1584     sew.sym_info = (PSYMBOL_INFOW)sew.buffer;
1585
1586     if (Mask)
1587     {
1588         unsigned len = WideCharToMultiByte(CP_ACP, 0, Mask, -1, NULL, 0, NULL, NULL);
1589         maskA = HeapAlloc(GetProcessHeap(), 0, len);
1590         if (!maskA) return FALSE;
1591         WideCharToMultiByte(CP_ACP, 0, Mask, -1, maskA, len, NULL, NULL);
1592     }
1593     ret = SymSearch(hProcess, BaseOfDll, Index, SymTag, maskA, Address,
1594                     sym_enumW, &sew, Options);
1595     HeapFree(GetProcessHeap(), 0, maskA);
1596
1597     return ret;
1598 }