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

   1 /*
   2  * File elf.c - processing of ELF files
   3  *
   4  * Copyright (C) 1996, Eric Youngdale.
   5  *               1999-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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <assert.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #ifdef HAVE_SYS_MMAN_H
  30 #include <sys/mman.h>
  31 #endif
  32 #ifdef HAVE_UNISTD_H
  33 # include <unistd.h>
  34 #endif
  35 #ifndef PATH_MAX
  36 #define PATH_MAX MAX_PATH
  37 #endif
  38
  39 #include "dbghelp_private.h"
  40
  41 #if defined(__svr4__) || defined(__sun)
  42 #define __ELF__
  43 #endif
  44
  45 #ifdef HAVE_ELF_H
  46 # include <elf.h>
  47 #endif
  48 #ifdef HAVE_SYS_ELF32_H
  49 # include <sys/elf32.h>
  50 #endif
  51 #ifdef HAVE_SYS_EXEC_ELF_H
  52 # include <sys/exec_elf.h>
  53 #endif
  54 #if !defined(DT_NUM)
  55 # if defined(DT_COUNT)
  56 #  define DT_NUM DT_COUNT
  57 # else
  58 /* this seems to be a satisfactory value on Solaris, which doesn't support this AFAICT */
  59 #  define DT_NUM 24
  60 # endif
  61 #endif
  62 #ifdef HAVE_LINK_H
  63 # include <link.h>
  64 #endif
  65 #ifdef HAVE_SYS_LINK_H
  66 # include <sys/link.h>
  67 #endif
  68
  69 #include "wine/debug.h"
  70
  71 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  72
  73 struct elf_module_info
  74 {
  75     unsigned long               elf_addr;
  76     unsigned short              elf_mark : 1,
  77                                 elf_loader : 1;
  78 };
  79
  80 #ifdef __ELF__
  81
  82 #define ELF_INFO_DEBUG_HEADER   0x0001
  83 #define ELF_INFO_MODULE         0x0002
  84
  85 struct elf_info
  86 {
  87     unsigned                    flags;          /* IN  one (or several) of the ELF_INFO constants */
  88     unsigned long               dbg_hdr_addr;   /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
  89     struct module*              module;         /* OUT loaded module (if ELF_INFO_MODULE is set) */
  90 };
  91
  92 struct symtab_elt
  93 {
  94     struct hash_table_elt       ht_elt;
  95     const Elf32_Sym*            symp;
  96     const char*                 filename;
  97     unsigned                    used;
  98 };
  99
 100 struct thunk_area
 101 {
 102     const char*                 symname;
 103     THUNK_ORDINAL               ordinal;
 104     unsigned long               rva_start;
 105     unsigned long               rva_end;
 106 };
 107
 108 /******************************************************************
 109  *              elf_hash_symtab
 110  *
 111  * creating an internal hash table to ease use ELF symtab information lookup
 112  */
 113 static void elf_hash_symtab(const struct module* module, struct pool* pool,
 114                             struct hash_table* ht_symtab, const char* map_addr,
 115                             const Elf32_Shdr* symtab, const Elf32_Shdr* strtab,
 116                             unsigned num_areas, struct thunk_area* thunks)
 117 {
 118     int                         i, j, nsym;
 119     const char*                 strp;
 120     const char*                 symname;
 121     const char*                 filename = NULL;
 122     const char*                 ptr;
 123     const Elf32_Sym*            symp;
 124     struct symtab_elt*          ste;
 125
 126     symp = (const Elf32_Sym*)(map_addr + symtab->sh_offset);
 127     nsym = symtab->sh_size / sizeof(*symp);
 128     strp = (const char*)(map_addr + strtab->sh_offset);
 129
 130     for (j = 0; j < num_areas; j++)
 131         thunks[j].rva_start = thunks[j].rva_end = 0;
 132
 133     for (i = 0; i < nsym; i++, symp++)
 134     {
 135         /* Ignore certain types of entries which really aren't of that much
 136          * interest.
 137          */
 138         if (ELF32_ST_TYPE(symp->st_info) == STT_SECTION || symp->st_shndx == SHN_UNDEF)
 139         {
 140             continue;
 141         }
 142
 143         symname = strp + symp->st_name;
 144
 145         if (ELF32_ST_TYPE(symp->st_info) == STT_FILE)
 146         {
 147             filename = symname;
 148             continue;
 149         }
 150         for (j = 0; j < num_areas; j++)
 151         {
 152             if (!strcmp(symname, thunks[j].symname))
 153             {
 154                 thunks[j].rva_start = symp->st_value;
 155                 thunks[j].rva_end   = symp->st_value + symp->st_size;
 156                 break;
 157             }
 158         }
 159         if (j < num_areas) continue;
 160
 161         ste = pool_alloc(pool, sizeof(*ste));
 162         /* GCC seems to emit, in some cases, a .<digit>+ suffix.
 163          * This is used for static variable inside functions, so
 164          * that we can have several such variables with same name in
 165          * the same compilation unit
 166          * We simply ignore that suffix when present (we also get rid
 167          * of it in stabs parsing)
 168          */
 169         ptr = symname + strlen(symname) - 1;
 170         ste->ht_elt.name = symname;
 171         if (isdigit(*ptr))
 172         {
 173             while (*ptr >= '0' && *ptr <= '9' && ptr >= symname) ptr--;
 174             if (ptr > symname && *ptr == '.')
 175             {
 176                 char* n = pool_alloc(pool, ptr - symname + 1);
 177                 memcpy(n, symname, ptr - symname + 1);
 178                 n[ptr - symname] = '\0';
 179                 ste->ht_elt.name = n;
 180             }
 181         }
 182         ste->symp        = symp;
 183         ste->filename    = filename;
 184         ste->used        = 0;
 185         hash_table_add(ht_symtab, &ste->ht_elt);
 186     }
 187 }
 188
 189 /******************************************************************
 190  *              elf_lookup_symtab
 191  *
 192  * lookup a symbol by name in our internal hash table for the symtab
 193  */
 194 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
 195                                           const struct hash_table* ht_symtab,
 196                                           const char* name, struct symt* compiland)
 197 {
 198     struct symtab_elt*          weak_result = NULL; /* without compiland name */
 199     struct symtab_elt*          result = NULL;
 200     struct hash_table_iter      hti;
 201     struct symtab_elt*          ste;
 202     const char*                 compiland_name;
 203     const char*                 compiland_basename;
 204     const char*                 base;
 205
 206     /* we need weak match up (at least) when symbols of same name,
 207      * defined several times in different compilation units,
 208      * are merged in a single one (hence a different filename for c.u.)
 209      */
 210     if (compiland)
 211     {
 212         compiland_name = source_get(module,
 213                                     ((struct symt_compiland*)compiland)->source);
 214         compiland_basename = strrchr(compiland_name, '/');
 215         if (!compiland_basename++) compiland_basename = compiland_name;
 216     }
 217     else compiland_name = compiland_basename = NULL;
 218
 219     hash_table_iter_init(ht_symtab, &hti, name);
 220     while ((ste = hash_table_iter_up(&hti)))
 221     {
 222         if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
 223
 224         weak_result = ste;
 225         if ((ste->filename && !compiland_name) || (!ste->filename && compiland_name))
 226             continue;
 227         if (ste->filename && compiland_name)
 228         {
 229             if (strcmp(ste->filename, compiland_name))
 230             {
 231                 base = strrchr(ste->filename, '/');
 232                 if (!base++) base = ste->filename;
 233                 if (strcmp(base, compiland_basename)) continue;
 234             }
 235         }
 236         if (result)
 237         {
 238             FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
 239                   name, compiland_name, result->filename, result->symp->st_value,
 240                   ste->filename, ste->symp->st_value);
 241         }
 242         else
 243         {
 244             result = ste;
 245             ste->used = 1;
 246         }
 247     }
 248     if (!result && !(result = weak_result))
 249     {
 250         FIXME("Couldn't find symbol %s.%s in symtab\n",
 251               module->module.ModuleName, name);
 252         return NULL;
 253     }
 254     return result->symp;
 255 }
 256
 257 /******************************************************************
 258  *              elf_finish_stabs_info
 259  *
 260  * - get any relevant information (address & size) from the bits we got from the
 261  *   stabs debugging information
 262  */
 263 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
 264 {
 265     struct hash_table_iter      hti;
 266     void*                       ptr;
 267     struct symt_ht*             sym;
 268     const Elf32_Sym*            symp;
 269
 270     hash_table_iter_init(&module->ht_symbols, &hti, NULL);
 271     while ((ptr = hash_table_iter_up(&hti)))
 272     {
 273         sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
 274         switch (sym->symt.tag)
 275         {
 276         case SymTagFunction:
 277             if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
 278                 ((struct symt_function*)sym)->size)
 279             {
 280                 break;
 281             }
 282             symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
 283                                      ((struct symt_function*)sym)->container);
 284             if (symp)
 285             {
 286                 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
 287                                                         symp->st_value;
 288                 ((struct symt_function*)sym)->size    = symp->st_size;
 289             }
 290             break;
 291         case SymTagData:
 292             switch (((struct symt_data*)sym)->kind)
 293             {
 294             case DataIsGlobal:
 295             case DataIsFileStatic:
 296                 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr)
 297                     break;
 298                 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
 299                                          ((struct symt_data*)sym)->container);
 300                 if (symp)
 301                 {
 302                     ((struct symt_data*)sym)->u.address = module->elf_info->elf_addr +
 303                                                           symp->st_value;
 304                     ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
 305                         DataIsFileStatic : DataIsGlobal;
 306                 }
 307                 break;
 308             default:;
 309             }
 310             break;
 311         default:
 312             FIXME("Unsupported tag %u\n", sym->symt.tag);
 313             break;
 314         }
 315     }
 316     /* since we may have changed some addresses & sizes, mark the module to be resorted */
 317     module->sortlist_valid = FALSE;
 318 }
 319
 320 /******************************************************************
 321  *              elf_load_wine_thunks
 322  *
 323  * creating the thunk objects for a wine native DLL
 324  */
 325 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
 326                                unsigned num_areas, struct thunk_area* thunks)
 327 {
 328     int                         j;
 329     struct symt_compiland*      compiland = NULL;
 330     const char*                 compiland_name = NULL;
 331     struct hash_table_iter      hti;
 332     struct symtab_elt*          ste;
 333     DWORD                       addr;
 334     int                         idx;
 335
 336     hash_table_iter_init(ht_symtab, &hti, NULL);
 337     while ((ste = hash_table_iter_up(&hti)))
 338     {
 339         if (ste->used) continue;
 340
 341         /* FIXME: this is not a good idea anyway... we are creating several
 342          * compiland objects for a same compilation unit
 343          * We try to cache the last compiland used, but it's not enough
 344          * (we should here only create compilands if they are not yet
 345          *  defined)
 346          */
 347         if (!compiland_name || compiland_name != ste->filename)
 348             compiland = symt_new_compiland(module,
 349                                            compiland_name = ste->filename);
 350
 351         addr = module->elf_info->elf_addr + ste->symp->st_value;
 352
 353         for (j = 0; j < num_areas; j++)
 354         {
 355             if (ste->symp->st_value >= thunks[j].rva_start &&
 356                 ste->symp->st_value < thunks[j].rva_end)
 357                 break;
 358         }
 359         if (j < num_areas) /* thunk found */
 360         {
 361             symt_new_thunk(module, compiland, ste->ht_elt.name, thunks[j].ordinal,
 362                            addr, ste->symp->st_size);
 363         }
 364         else
 365         {
 366             DWORD       ref_addr;
 367
 368             idx = symt_find_nearest(module, addr);
 369             if (idx != -1)
 370                 symt_get_info(&module->addr_sorttab[idx]->symt,
 371                               TI_GET_ADDRESS, &ref_addr);
 372             if (idx == -1 || addr != ref_addr)
 373             {
 374                 /* creating public symbols for all the ELF symbols which haven't been
 375                  * used yet (ie we have no debug information on them)
 376                  * That's the case, for example, of the .spec.c files
 377                  */
 378                 if (ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC)
 379                 {
 380                     symt_new_function(module, compiland, ste->ht_elt.name,
 381                                       addr, ste->symp->st_size, NULL);
 382                 }
 383                 else
 384                 {
 385                     symt_new_global_variable(module, compiland, ste->ht_elt.name,
 386                                              ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
 387                                              addr, ste->symp->st_size, NULL);
 388                 }
 389                 /* FIXME: this is a hack !!!
 390                  * we are adding new symbols, but as we're parsing a symbol table
 391                  * (hopefully without duplicate symbols) we delay rebuilding the sorted
 392                  * module table until we're done with the symbol table
 393                  * Otherwise, as we intertwine symbols's add and lookup, performance
 394                  * is rather bad
 395                  */
 396                 module->sortlist_valid = TRUE;
 397             }
 398             else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
 399             {
 400                 DWORD   xaddr = 0, xsize = 0, kind = -1;
 401
 402                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS,  &xaddr);
 403                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH,   &xsize);
 404                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind);
 405
 406                 /* If none of symbols has a correct size, we consider they are both markers
 407                  * Hence, we can silence this warning
 408                  * Also, we check that we don't have two symbols, one local, the other
 409                  * global which is legal
 410                  */
 411                 if ((xsize || ste->symp->st_size) &&
 412                     (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
 413                     FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%08lx-%08lx>\n",
 414                           module->module.ModuleName,
 415                           ste->ht_elt.name, addr, ste->symp->st_size,
 416                           module->addr_sorttab[idx]->hash_elt.name, xaddr, xsize);
 417             }
 418         }
 419     }
 420     /* see comment above */
 421     module->sortlist_valid = FALSE;
 422     return TRUE;
 423 }
 424
 425 /******************************************************************
 426  *              elf_new_public_symbols
 427  *
 428  * Creates a set of public symbols from an ELF symtab
 429  */
 430 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
 431 {
 432     struct symt_compiland*      compiland = NULL;
 433     const char*                 compiland_name = NULL;
 434     struct hash_table_iter      hti;
 435     struct symtab_elt*          ste;
 436
 437     if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
 438
 439     /* FIXME: we're missing the ELF entry point here */
 440
 441     hash_table_iter_init(symtab, &hti, NULL);
 442     while ((ste = hash_table_iter_up(&hti)))
 443     {
 444         /* FIXME: this is not a good idea anyway... we are creating several
 445          * compiland objects for a same compilation unit
 446          * We try to cache the last compiland used, but it's not enough
 447          * (we should here only create compilands if they are not yet
 448          *  defined)
 449          */
 450         if (!compiland_name || compiland_name != ste->filename)
 451             compiland = symt_new_compiland(module,
 452                                            compiland_name = ste->filename);
 453
 454         symt_new_public(module, compiland, ste->ht_elt.name,
 455                         module->elf_info->elf_addr + ste->symp->st_value,
 456                         ste->symp->st_size, TRUE /* FIXME */,
 457                         ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
 458     }
 459     return TRUE;
 460 }
 461
 462 /******************************************************************
 463  *              elf_load_debug_info
 464  *
 465  * Loads the symbolic information from ELF module stored in 'filename'
 466  * the module has been loaded at 'load_offset' address, so symbols' address
 467  * relocation is performed
 468  * returns
 469  *      -1 if the file cannot be found/opened
 470  *      0 if the file doesn't contain symbolic info (or this info cannot be
 471  *      read or parsed)
 472  *      1 on success
 473  */
 474 BOOL elf_load_debug_info(struct module* module)
 475 {
 476     BOOL                ret = FALSE;
 477     char*               addr = (char*)0xffffffff;
 478     int                 fd = -1;
 479     struct stat         statbuf;
 480     const Elf32_Ehdr*   ehptr;
 481     const Elf32_Shdr*   spnt;
 482     const char*         shstrtab;
 483     int                 i;
 484     int                 symtab_sect, dynsym_sect, stab_sect, stabstr_sect, debug_sect;
 485     struct pool         pool;
 486     struct hash_table   ht_symtab;
 487     struct thunk_area   thunks[] =
 488     {
 489         {"__wine_spec_import_thunks",           THUNK_ORDINAL_NOTYPE, 0, 0},    /* inter DLL calls */
 490         {"__wine_spec_delayed_import_loaders",  THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
 491         {"__wine_spec_delayed_import_thunks",   THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
 492         {"__wine_delay_load",                   THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
 493         {"__wine_spec_thunk_text_16",           -16,                  0, 0},    /* 16 => 32 thunks */
 494         {"__wine_spec_thunk_data_16",           -16,                  0, 0},    /* 16 => 32 thunks */
 495         {"__wine_spec_thunk_text_32",           -32,                  0, 0},    /* 32 => 16 thunks */
 496         {"__wine_spec_thunk_data_32",           -32,                  0, 0},    /* 32 => 16 thunks */
 497     };
 498
 499     if (module->type != DMT_ELF || !module->elf_info)
 500     {
 501         ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
 502         return FALSE;
 503     }
 504
 505     TRACE("%s\n", module->module.LoadedImageName);
 506     /* check that the file exists, and that the module hasn't been loaded yet */
 507     if (stat(module->module.LoadedImageName, &statbuf) == -1) goto leave;
 508     if (S_ISDIR(statbuf.st_mode)) goto leave;
 509
 510     /*
 511      * Now open the file, so that we can mmap() it.
 512      */
 513     if ((fd = open(module->module.LoadedImageName, O_RDONLY)) == -1) goto leave;
 514
 515     /*
 516      * Now mmap() the file.
 517      */
 518     addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 519     if (addr == (char*)0xffffffff) goto leave;
 520
 521     /*
 522      * Next, we need to find a few of the internal ELF headers within
 523      * this thing.  We need the main executable header, and the section
 524      * table.
 525      */
 526     ehptr = (Elf32_Ehdr*)addr;
 527     spnt = (Elf32_Shdr*)(addr + ehptr->e_shoff);
 528     shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
 529
 530     symtab_sect = dynsym_sect = stab_sect = stabstr_sect = debug_sect = -1;
 531
 532     for (i = 0; i < ehptr->e_shnum; i++)
 533     {
 534         if (strcmp(shstrtab + spnt[i].sh_name, ".stab") == 0)
 535             stab_sect = i;
 536         if (strcmp(shstrtab + spnt[i].sh_name, ".stabstr") == 0)
 537             stabstr_sect = i;
 538         if (strcmp(shstrtab + spnt[i].sh_name, ".debug_info") == 0)
 539             debug_sect = i;
 540         if ((strcmp(shstrtab + spnt[i].sh_name, ".symtab") == 0) &&
 541             (spnt[i].sh_type == SHT_SYMTAB))
 542             symtab_sect = i;
 543         if ((strcmp(shstrtab + spnt[i].sh_name, ".dynsym") == 0) &&
 544             (spnt[i].sh_type == SHT_DYNSYM))
 545             dynsym_sect = i;
 546     }
 547
 548     if (symtab_sect == -1)
 549     {
 550         /* if we don't have a symtab but a dynsym, process the dynsym
 551          * section instead. It'll contain less (relevant) information,
 552          * but it'll be better than nothing
 553          */
 554         if (dynsym_sect == -1) goto leave;
 555         symtab_sect = dynsym_sect;
 556     }
 557
 558     module->module.SymType = SymExport;
 559     /* FIXME: guess a better size from ELF info */
 560     pool_init(&pool, 65536);
 561     hash_table_init(&pool, &ht_symtab, 256);
 562
 563     /* create a hash table for the symtab */
 564     elf_hash_symtab(module, &pool, &ht_symtab, addr,
 565                     spnt + symtab_sect, spnt + spnt[symtab_sect].sh_link,
 566                     sizeof(thunks) / sizeof(thunks[0]), thunks);
 567
 568     if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
 569     {
 570         if (stab_sect != -1 && stabstr_sect != -1)
 571         {
 572             /* OK, now just parse all of the stabs. */
 573             ret = stabs_parse(module, addr, module->elf_info->elf_addr,
 574                               spnt[stab_sect].sh_offset, spnt[stab_sect].sh_size,
 575                               spnt[stabstr_sect].sh_offset,
 576                               spnt[stabstr_sect].sh_size);
 577             if (!ret)
 578             {
 579                 WARN("Couldn't read correctly read stabs\n");
 580                 goto leave;
 581             }
 582             /* and fill in the missing information for stabs */
 583             elf_finish_stabs_info(module, &ht_symtab);
 584         }
 585         else if (debug_sect != -1)
 586         {
 587             /* Dwarf 2 debug information */
 588             FIXME("Unsupported Dwarf2 information for %s\n", module->module.ModuleName);
 589         }
 590     }
 591     if (strstr(module->module.ModuleName, "<elf>") ||
 592         !strcmp(module->module.ModuleName, "<wine-loader>"))
 593     {
 594         /* add the thunks for native libraries */
 595         if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
 596             elf_new_wine_thunks(module, &ht_symtab,
 597                                 sizeof(thunks) / sizeof(thunks[0]), thunks);
 598     }
 599     /* add all the public symbols from symtab */
 600     if (elf_new_public_symbols(module, &ht_symtab) && !ret) ret = TRUE;
 601
 602     pool_destroy(&pool);
 603
 604 leave:
 605     if (addr != (char*)0xffffffff) munmap(addr, statbuf.st_size);
 606     if (fd != -1) close(fd);
 607
 608     return ret;
 609 }
 610
 611 /******************************************************************
 612  *              is_dt_flag_valid
 613  * returns true iff the section tag is valid
 614  */
 615 static unsigned is_dt_flag_valid(unsigned d_tag)
 616 {
 617 #ifndef DT_PROCNUM
 618 #define DT_PROCNUM 0
 619 #endif
 620 #ifndef DT_EXTRANUM
 621 #define DT_EXTRANUM 0
 622 #endif
 623     return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
 624 #if defined(DT_LOOS) && defined(DT_HIOS)
 625         || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
 626 #endif
 627 #if defined(DT_LOPROC) && defined(DT_HIPROC)
 628         || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
 629 #endif
 630         ;
 631 }
 632
 633 /******************************************************************
 634  *              elf_load_file
 635  *
 636  * Loads the information for ELF module stored in 'filename'
 637  * the module has been loaded at 'load_offset' address
 638  * returns
 639  *      -1 if the file cannot be found/opened
 640  *      0 if the file doesn't contain symbolic info (or this info cannot be
 641  *      read or parsed)
 642  *      1 on success
 643  */
 644 static BOOL elf_load_file(struct process* pcs, const char* filename,
 645                           unsigned long load_offset, struct elf_info* elf_info)
 646 {
 647     static const BYTE   elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
 648     BOOL                ret = FALSE;
 649     const char*         addr = (char*)0xffffffff;
 650     int                 fd = -1;
 651     struct stat         statbuf;
 652     const Elf32_Ehdr*   ehptr;
 653     const Elf32_Shdr*   spnt;
 654     const Elf32_Phdr*   ppnt;
 655     const char*         shstrtab;
 656     int                 i;
 657     DWORD               size, start;
 658     unsigned            tmp, page_mask = getpagesize() - 1;
 659
 660     TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
 661
 662     /* check that the file exists, and that the module hasn't been loaded yet */
 663     if (stat(filename, &statbuf) == -1) goto leave;
 664
 665     /* Now open the file, so that we can mmap() it. */
 666     if ((fd = open(filename, O_RDONLY)) == -1) goto leave;
 667
 668     /* Now mmap() the file. */
 669     addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 670     if (addr == (char*)-1) goto leave;
 671
 672     /* Next, we need to find a few of the internal ELF headers within
 673      * this thing.  We need the main executable header, and the section
 674      * table.
 675      */
 676     ehptr = (const Elf32_Ehdr*)addr;
 677     if (memcmp(ehptr->e_ident, elf_signature, sizeof(elf_signature))) goto leave;
 678
 679     spnt = (const Elf32_Shdr*)(addr + ehptr->e_shoff);
 680     shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset);
 681
 682     /* grab size of module once loaded in memory */
 683     ppnt = (const Elf32_Phdr*)(addr + ehptr->e_phoff);
 684     size = 0; start = ~0L;
 685
 686     for (i = 0; i < ehptr->e_phnum; i++)
 687     {
 688         if (ppnt[i].p_type == PT_LOAD)
 689         {
 690             tmp = (ppnt[i].p_vaddr + ppnt[i].p_memsz + page_mask) & ~page_mask;
 691             if (size < tmp) size = tmp;
 692             if (ppnt[i].p_vaddr < start) start = ppnt[i].p_vaddr;
 693         }
 694     }
 695
 696     /* if non relocatable ELF, then remove fixed address from computation
 697      * otherwise, all addresses are zero based and start has no effect
 698      */
 699     size -= start;
 700     if (!start && !load_offset)
 701         ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
 702             filename);
 703     if (start && load_offset)
 704     {
 705         WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
 706              "Assuming load address is corrupt\n", filename, load_offset);
 707         load_offset = 0;
 708     }
 709
 710     if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
 711     {
 712         for (i = 0; i < ehptr->e_shnum; i++)
 713         {
 714             if (strcmp(shstrtab + spnt[i].sh_name, ".dynamic") == 0 &&
 715                 spnt[i].sh_type == SHT_DYNAMIC)
 716             {
 717                 Elf32_Dyn       dyn;
 718                 char*           ptr = (char*)spnt[i].sh_addr;
 719                 unsigned long   len;
 720
 721                 do
 722                 {
 723                     if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
 724                         len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
 725                         dyn.d_tag = DT_NULL;
 726                     ptr += sizeof(dyn);
 727                 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
 728                 if (dyn.d_tag == DT_NULL) goto leave;
 729                 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
 730             }
 731         }
 732     }
 733
 734     if (elf_info->flags & ELF_INFO_MODULE)
 735     {
 736         elf_info->module = module_new(pcs, filename, DMT_ELF,
 737                                       (load_offset) ? load_offset : start,
 738                                       size, 0, 0);
 739         if (!elf_info->module) goto leave;
 740         elf_info->module->elf_info = HeapAlloc(GetProcessHeap(),
 741                                                0, sizeof(struct elf_module_info));
 742         if (elf_info->module->elf_info == NULL)
 743         {
 744             ERR("OOM\n");
 745             exit(0); /* FIXME */
 746         }
 747             elf_info->module->elf_info->elf_addr = load_offset;
 748
 749         if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
 750         {
 751             elf_info->module->module.SymType = SymDeferred;
 752             ret = TRUE;
 753         }
 754         else ret = elf_load_debug_info(elf_info->module);
 755
 756         elf_info->module->elf_info->elf_mark = 1;
 757         elf_info->module->elf_info->elf_loader = 0;
 758     } else ret = TRUE;
 759
 760 leave:
 761     if (addr != (char*)0xffffffff) munmap((void*)addr, statbuf.st_size);
 762     if (fd != -1) close(fd);
 763
 764     return ret;
 765 }
 766
 767 /******************************************************************
 768  *              elf_load_file_from_path
 769  * tries to load an ELF file from a set of paths (separated by ':')
 770  */
 771 static BOOL elf_load_file_from_path(HANDLE hProcess,
 772                                     const char* filename,
 773                                     unsigned long load_offset,
 774                                     const char* path,
 775                                     struct elf_info* elf_info)
 776 {
 777     BOOL                ret = FALSE;
 778     char                *s, *t, *fn;
 779     char*               paths = NULL;
 780
 781     if (!path) return FALSE;
 782
 783     paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
 784     for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
 785     {
 786         t = strchr(s, ':');
 787         if (t) *t = '\0';
 788         fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
 789         if (!fn) break;
 790         strcpy(fn, s);
 791         strcat(fn, "/");
 792         strcat(fn, filename);
 793         ret = elf_load_file(hProcess, fn, load_offset, elf_info);
 794         HeapFree(GetProcessHeap(), 0, fn);
 795         if (ret) break;
 796         s = (t) ? (t+1) : NULL;
 797     }
 798
 799     HeapFree(GetProcessHeap(), 0, paths);
 800     return ret;
 801 }
 802
 803 /******************************************************************
 804  *              elf_search_and_load_file
 805  *
 806  * lookup a file in standard ELF locations, and if found, load it
 807  */
 808 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
 809                                      unsigned long load_offset,
 810                                      struct elf_info* elf_info)
 811 {
 812     BOOL                ret = FALSE;
 813     struct module*      module;
 814
 815     if (filename == NULL || *filename == '\0') return FALSE;
 816     if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
 817     {
 818         elf_info->module = module;
 819         module->elf_info->elf_mark = 1;
 820         return module->module.SymType;
 821     }
 822
 823     if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
 824     ret = elf_load_file(pcs, filename, load_offset, elf_info);
 825     /* if relative pathname, try some absolute base dirs */
 826     if (!ret && !strchr(filename, '/'))
 827     {
 828         ret = elf_load_file_from_path(pcs, filename, load_offset,
 829                                       getenv("PATH"), elf_info) ||
 830             elf_load_file_from_path(pcs, filename, load_offset,
 831                                     getenv("LD_LIBRARY_PATH"), elf_info) ||
 832             elf_load_file_from_path(pcs, filename, load_offset,
 833                                     getenv("WINEDLLPATH"), elf_info);
 834     }
 835
 836     return ret;
 837 }
 838
 839 /******************************************************************
 840  *              elf_synchronize_module_list
 841  *
 842  * this functions rescans the debuggee module's list and synchronizes it with
 843  * the one from 'pcs', ie:
 844  * - if a module is in debuggee and not in pcs, it's loaded into pcs
 845  * - if a module is in pcs and not in debuggee, it's unloaded from pcs
 846  */
 847 BOOL    elf_synchronize_module_list(struct process* pcs)
 848 {
 849     struct r_debug      dbg_hdr;
 850     void*               lm_addr;
 851     struct link_map     lm;
 852     char                bufstr[256];
 853     struct elf_info     elf_info;
 854     struct module*      module;
 855
 856     if (!pcs->dbg_hdr_addr) return FALSE;
 857     if (!read_mem(pcs->handle, pcs->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr)))
 858         return FALSE;
 859
 860     for (module = pcs->lmodules; module; module = module->next)
 861     {
 862         if (module->type == DMT_ELF) module->elf_info->elf_mark = 0;
 863     }
 864
 865     elf_info.flags = ELF_INFO_MODULE;
 866     /* Now walk the linked list.  In all known ELF implementations,
 867      * the dynamic loader maintains this linked list for us.  In some
 868      * cases the first entry doesn't appear with a name, in other cases it
 869      * does.
 870      */
 871     for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
 872     {
 873         if (!read_mem(pcs->handle, (ULONG)lm_addr, &lm, sizeof(lm)))
 874             return FALSE;
 875
 876         if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
 877             lm.l_name != NULL &&
 878             read_mem(pcs->handle, (ULONG)lm.l_name, bufstr, sizeof(bufstr)))
 879         {
 880             bufstr[sizeof(bufstr) - 1] = '\0';
 881             elf_search_and_load_file(pcs, bufstr, (unsigned long)lm.l_addr,
 882                                      &elf_info);
 883         }
 884     }
 885
 886     for (module = pcs->lmodules; module; module = module->next)
 887     {
 888         if (module->type == DMT_ELF && !module->elf_info->elf_mark &&
 889             !module->elf_info->elf_loader)
 890         {
 891             module_remove(pcs, module);
 892             /* restart all over */
 893             module = pcs->lmodules;
 894         }
 895     }
 896     return TRUE;
 897 }
 898
 899 /******************************************************************
 900  *              elf_read_wine_loader_dbg_info
 901  *
 902  * Try to find a decent wine executable which could have loaded the debuggee
 903  */
 904 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
 905 {
 906     const char*         ptr;
 907     struct elf_info     elf_info;
 908     BOOL                ret;
 909
 910     elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
 911     /* All binaries are loaded with WINELOADER (if run from tree) or by the
 912      * main executable (either wine-kthread or wine-pthread)
 913      * Note: the heuristic use to know whether we need to load wine-pthread or
 914      * wine-kthread is not 100% safe
 915      */
 916     if ((ptr = getenv("WINELOADER")))
 917         ret = elf_search_and_load_file(pcs, ptr, 0, &elf_info);
 918     else
 919     {
 920         ret = elf_search_and_load_file(pcs, "wine-kthread", 0, &elf_info) ||
 921             elf_search_and_load_file(pcs, "wine-pthread", 0, &elf_info);
 922     }
 923     if (!ret) return FALSE;
 924     elf_info.module->elf_info->elf_loader = 1;
 925     strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
 926     return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
 927 }
 928
 929 /******************************************************************
 930  *              elf_load_module
 931  *
 932  * loads an ELF module and stores it in process' module list
 933  * if 'sync' is TRUE, let's find module real name and load address from
 934  * the real loaded modules list in pcs address space
 935  */
 936 struct module*  elf_load_module(struct process* pcs, const char* name)
 937 {
 938     struct elf_info     elf_info;
 939     BOOL                ret = FALSE;
 940     const char*         p;
 941     const char*         xname;
 942     struct r_debug      dbg_hdr;
 943     void*               lm_addr;
 944     struct link_map     lm;
 945     char                bufstr[256];
 946
 947     TRACE("(%p %s)\n", pcs, name);
 948
 949     elf_info.flags = ELF_INFO_MODULE;
 950
 951     /* do only the lookup from the filename, not the path (as we lookup module name
 952      * in the process' loaded module list)
 953      */
 954     xname = strrchr(name, '/');
 955     if (!xname++) xname = name;
 956
 957     if (!read_mem(pcs->handle, pcs->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr)))
 958         return NULL;
 959
 960     for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
 961     {
 962         if (!read_mem(pcs->handle, (ULONG)lm_addr, &lm, sizeof(lm)))
 963             return NULL;
 964
 965         if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
 966             lm.l_name != NULL &&
 967             read_mem(pcs->handle, (ULONG)lm.l_name, bufstr, sizeof(bufstr)))
 968         {
 969             bufstr[sizeof(bufstr) - 1] = '\0';
 970             /* memcmp is needed for matches when bufstr contains also version information
 971              * name: libc.so, bufstr: libc.so.6.0
 972              */
 973             p = strrchr(bufstr, '/');
 974             if (!p++) p = bufstr;
 975             if (!memcmp(p, xname, strlen(xname)))
 976             {
 977                 ret = elf_search_and_load_file(pcs, bufstr,
 978                                                (unsigned long)lm.l_addr, &elf_info);
 979                 break;
 980             }
 981         }
 982     }
 983     if (!lm_addr || !ret) return NULL;
 984     assert(elf_info.module);
 985     return elf_info.module;
 986 }
 987
 988 #else   /* !__ELF__ */
 989
 990 BOOL    elf_synchronize_module_list(struct process* pcs)
 991 {
 992     return FALSE;
 993 }
 994
 995 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
 996 {
 997     return FALSE;
 998 }
 999
1000 struct module*  elf_load_module(struct process* pcs, const char* name)
1001 {
1002     return NULL;
1003 }
1004
1005 BOOL elf_load_debug_info(struct module* module)
1006 {
1007     return FALSE;
1008 }
1009 #endif  /* __ELF__ */