kernel: Added a test for QueryDosDeviceA.
[wine] / 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 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #ifdef HAVE_SYS_STAT_H
29 # include <sys/stat.h>
30 #endif
31 #include <fcntl.h>
32 #ifdef HAVE_SYS_MMAN_H
33 #include <sys/mman.h>
34 #endif
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38 #ifndef PATH_MAX
39 #define PATH_MAX MAX_PATH
40 #endif
41
42 #include "dbghelp_private.h"
43
44 #if defined(__svr4__) || defined(__sun)
45 #define __ELF__
46 #endif
47
48 #ifdef HAVE_ELF_H
49 # include <elf.h>
50 #endif
51 #ifdef HAVE_SYS_ELF32_H
52 # include <sys/elf32.h>
53 #endif
54 #ifdef HAVE_SYS_EXEC_ELF_H
55 # include <sys/exec_elf.h>
56 #endif
57 #if !defined(DT_NUM)
58 # if defined(DT_COUNT)
59 #  define DT_NUM DT_COUNT
60 # else
61 /* this seems to be a satisfactory value on Solaris, which doesn't support this AFAICT */
62 #  define DT_NUM 24
63 # endif
64 #endif
65 #ifdef HAVE_LINK_H
66 # include <link.h>
67 #endif
68 #ifdef HAVE_SYS_LINK_H
69 # include <sys/link.h>
70 #endif
71
72 #include "wine/debug.h"
73
74 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
75
76 struct elf_module_info
77 {
78     unsigned long               elf_addr;
79     unsigned short              elf_mark : 1,
80                                 elf_loader : 1;
81 };
82
83 #ifdef __ELF__
84
85 #define ELF_INFO_DEBUG_HEADER   0x0001
86 #define ELF_INFO_MODULE         0x0002
87 #define ELF_INFO_NAME           0x0004
88
89 struct elf_info
90 {
91     unsigned                    flags;          /* IN  one (or several) of the ELF_INFO constants */
92     unsigned long               dbg_hdr_addr;   /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
93     struct module*              module;         /* OUT loaded module (if ELF_INFO_MODULE is set) */
94     const char*                 module_name;    /* OUT found module name (if ELF_INFO_NAME is set) */
95 };
96
97 #define NO_MAP                  ((const void*)0xffffffff)
98 /* structure holding information while handling an ELF image
99  * allows one by one section mapping for memory savings
100  */
101 struct elf_file_map
102 {
103     Elf32_Ehdr                  elfhdr;
104     size_t                      elf_size;
105     size_t                      elf_start;
106     struct
107     {
108         Elf32_Shdr                      shdr;
109         const char*                     mapped;
110     }*                          sect;
111     int                         fd;
112     unsigned                    with_crc;
113     unsigned long               crc;
114 };
115
116 struct symtab_elt
117 {
118     struct hash_table_elt       ht_elt;
119     const Elf32_Sym*            symp;
120     const char*                 filename;
121     unsigned                    used;
122 };
123
124 struct thunk_area
125 {
126     const char*                 symname;
127     THUNK_ORDINAL               ordinal;
128     unsigned long               rva_start;
129     unsigned long               rva_end;
130 };
131
132 /******************************************************************
133  *              elf_map_section
134  *
135  * Maps a single section into memory from an ELF file
136  */
137 static const char* elf_map_section(struct elf_file_map* fmap, int sidx)
138 {
139     unsigned pgsz = getpagesize();
140     unsigned ofst, size;
141
142     if (sidx >= fmap->elfhdr.e_shnum ||
143         fmap->sect[sidx].shdr.sh_type == SHT_NOBITS)
144         return NO_MAP;
145     /* align required information on page size (we assume pagesize is a power of 2) */
146     ofst = fmap->sect[sidx].shdr.sh_offset & ~(pgsz - 1);
147     size = (fmap->sect[sidx].shdr.sh_offset + 
148             fmap->sect[sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1);
149     fmap->sect[sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fmap->fd, ofst);
150     if (fmap->sect[sidx].mapped == NO_MAP) return NO_MAP;
151     return fmap->sect[sidx].mapped + (fmap->sect[sidx].shdr.sh_offset & (pgsz - 1));
152 }
153
154 /******************************************************************
155  *              elf_unmap_section
156  *
157  * Unmaps a single section from memory
158  */
159 static void elf_unmap_section(struct elf_file_map* fmap, int sidx)
160 {
161     if (sidx < fmap->elfhdr.e_shnum && fmap->sect[sidx].mapped != NO_MAP)
162     {
163         munmap((char*)fmap->sect[sidx].mapped, fmap->sect[sidx].shdr.sh_size);
164         fmap->sect[sidx].mapped = NO_MAP;
165     }
166 }
167
168 /******************************************************************
169  *              elf_map_file
170  *
171  * Maps an ELF file into memory (and checks it's a real ELF file)
172  */
173 static BOOL elf_map_file(const char* filename, struct elf_file_map* fmap)
174 {
175     static const BYTE   elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
176     struct stat         statbuf;
177     int                 i;
178     Elf32_Phdr          phdr;
179     unsigned            tmp, page_mask = getpagesize() - 1;
180
181
182     fmap->fd = -1;
183     fmap->with_crc = 0;
184
185     /* check that the file exists, and that the module hasn't been loaded yet */
186     if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) return FALSE;
187
188     /* Now open the file, so that we can mmap() it. */
189     if ((fmap->fd = open(filename, O_RDONLY)) == -1) return FALSE;
190
191     if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr))
192         return FALSE;
193     /* and check for an ELF header */
194     if (memcmp(fmap->elfhdr.e_ident, 
195                elf_signature, sizeof(elf_signature))) return FALSE;
196
197     fmap->sect = HeapAlloc(GetProcessHeap(), 0,
198                            fmap->elfhdr.e_shnum * sizeof(fmap->sect[0]));
199     if (!fmap->sect) return FALSE;
200
201     lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET);
202     for (i = 0; i < fmap->elfhdr.e_shnum; i++)
203     {
204         read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr));
205         fmap->sect[i].mapped = NO_MAP;
206     }
207
208     /* grab size of module once loaded in memory */
209     lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET);
210     fmap->elf_size = 0; 
211     fmap->elf_start = ~0L;
212     for (i = 0; i < fmap->elfhdr.e_phnum; i++)
213     {
214         if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) && 
215             phdr.p_type == PT_LOAD)
216         {
217             tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
218             if (fmap->elf_size < tmp) fmap->elf_size = tmp;
219             if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr;
220         }
221     }
222     /* if non relocatable ELF, then remove fixed address from computation
223      * otherwise, all addresses are zero based and start has no effect
224      */
225     fmap->elf_size -= fmap->elf_start;
226     return TRUE;
227 }
228
229 /******************************************************************
230  *              elf_unmap_file
231  *
232  * Unmaps an ELF file from memory (previously mapped with elf_map_file)
233  */
234 static void elf_unmap_file(struct elf_file_map* fmap)
235 {
236     if (fmap->fd != -1)
237     {
238         int i;
239         for (i = 0; i < fmap->elfhdr.e_shnum; i++)
240         {
241             elf_unmap_section(fmap, i);
242         }
243         HeapFree(GetProcessHeap(), 0, fmap->sect);
244         close(fmap->fd);
245     }
246 }
247
248 /******************************************************************
249  *              elf_hash_symtab
250  *
251  * creating an internal hash table to ease use ELF symtab information lookup
252  */
253 static void elf_hash_symtab(const struct module* module, struct pool* pool, 
254                             struct hash_table* ht_symtab, struct elf_file_map* fmap,
255                             int symtab_idx, struct thunk_area* thunks)
256 {
257     int                         i, j, nsym;
258     const char*                 strp;
259     const char*                 symname;
260     const char*                 filename = NULL;
261     const char*                 ptr;
262     const Elf32_Sym*            symp;
263     struct symtab_elt*          ste;
264
265     symp = (const Elf32_Sym*)elf_map_section(fmap, symtab_idx);
266     strp = elf_map_section(fmap, fmap->sect[symtab_idx].shdr.sh_link);
267     if (symp == NO_MAP || strp == NO_MAP) return;
268
269     nsym = fmap->sect[symtab_idx].shdr.sh_size / sizeof(*symp);
270
271     for (j = 0; thunks[j].symname; j++)
272         thunks[j].rva_start = thunks[j].rva_end = 0;
273
274     for (i = 0; i < nsym; i++, symp++)
275     {
276         /* Ignore certain types of entries which really aren't of that much
277          * interest.
278          */
279         if ((ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
280              ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
281              ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
282             symp->st_shndx == SHN_UNDEF)
283         {
284             continue;
285         }
286
287         symname = strp + symp->st_name;
288
289         if (ELF32_ST_TYPE(symp->st_info) == STT_FILE)
290         {
291             filename = symname;
292             continue;
293         }
294         for (j = 0; thunks[j].symname; j++)
295         {
296             if (!strcmp(symname, thunks[j].symname))
297             {
298                 thunks[j].rva_start = symp->st_value;
299                 thunks[j].rva_end   = symp->st_value + symp->st_size;
300                 break;
301             }
302         }
303         if (thunks[j].symname) continue;
304
305         /* FIXME: we don't need to handle them (GCC internals)
306          * Moreover, they screw up our symbol lookup :-/
307          */
308         if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
309             continue;
310
311         ste = pool_alloc(pool, sizeof(*ste));
312         ste->ht_elt.name = symname;
313         /* GCC emits, in some cases, a .<digit>+ suffix.
314          * This is used for static variable inside functions, so
315          * that we can have several such variables with same name in
316          * the same compilation unit
317          * We simply ignore that suffix when present (we also get rid
318          * of it in stabs parsing)
319          */
320         ptr = symname + strlen(symname) - 1;
321         if (isdigit(*ptr))
322         {
323             while (isdigit(*ptr) && ptr >= symname) ptr--;
324             if (ptr > symname && *ptr == '.')
325             {
326                 char* n = pool_alloc(pool, ptr - symname + 1);
327                 memcpy(n, symname, ptr - symname + 1);
328                 n[ptr - symname] = '\0';
329                 ste->ht_elt.name = n;
330             }
331         }
332         ste->symp        = symp;
333         ste->filename    = filename;
334         ste->used        = 0;
335         hash_table_add(ht_symtab, &ste->ht_elt);
336     }
337     /* as we added in the ht_symtab pointers to the symbols themselves,
338      * we cannot unmap yet the sections, it will be done when we're over
339      * with this ELF file
340      */
341 }
342
343 /******************************************************************
344  *              elf_lookup_symtab
345  *
346  * lookup a symbol by name in our internal hash table for the symtab
347  */
348 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,        
349                                           const struct hash_table* ht_symtab,
350                                           const char* name, struct symt* compiland)
351 {
352     struct symtab_elt*          weak_result = NULL; /* without compiland name */
353     struct symtab_elt*          result = NULL;
354     struct hash_table_iter      hti;
355     struct symtab_elt*          ste;
356     const char*                 compiland_name;
357     const char*                 compiland_basename;
358     const char*                 base;
359
360     /* we need weak match up (at least) when symbols of same name, 
361      * defined several times in different compilation units,
362      * are merged in a single one (hence a different filename for c.u.)
363      */
364     if (compiland)
365     {
366         compiland_name = source_get(module,
367                                     ((struct symt_compiland*)compiland)->source);
368         compiland_basename = strrchr(compiland_name, '/');
369         if (!compiland_basename++) compiland_basename = compiland_name;
370     }
371     else compiland_name = compiland_basename = NULL;
372     
373     hash_table_iter_init(ht_symtab, &hti, name);
374     while ((ste = hash_table_iter_up(&hti)))
375     {
376         if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
377
378         weak_result = ste;
379         if ((ste->filename && !compiland_name) || (!ste->filename && compiland_name))
380             continue;
381         if (ste->filename && compiland_name)
382         {
383             if (strcmp(ste->filename, compiland_name))
384             {
385                 base = strrchr(ste->filename, '/');
386                 if (!base++) base = ste->filename;
387                 if (strcmp(base, compiland_basename)) continue;
388             }
389         }
390         if (result)
391         {
392             FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n", 
393                   name, compiland_name, result->filename, result->symp->st_value,
394                   ste->filename, ste->symp->st_value);
395         }
396         else
397         {
398             result = ste;
399             ste->used = 1;
400         }
401     }
402     if (!result && !(result = weak_result))
403     {
404         FIXME("Couldn't find symbol %s!%s in symtab\n", 
405               module->module.ModuleName, name);
406         return NULL;
407     }
408     return result->symp;
409 }
410
411 /******************************************************************
412  *              elf_finish_stabs_info
413  *
414  * - get any relevant information (address & size) from the bits we got from the
415  *   stabs debugging information
416  */
417 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
418 {
419     struct hash_table_iter      hti;
420     void*                       ptr;
421     struct symt_ht*             sym;
422     const Elf32_Sym*            symp;
423
424     hash_table_iter_init(&module->ht_symbols, &hti, NULL);
425     while ((ptr = hash_table_iter_up(&hti)))
426     {
427         sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
428         switch (sym->symt.tag)
429         {
430         case SymTagFunction:
431             if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
432                 ((struct symt_function*)sym)->size)
433             {
434                 break;
435             }
436             symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, 
437                                      ((struct symt_function*)sym)->container);
438             if (symp)
439             {
440                 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
441                     ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
442                     FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n", 
443                           sym, module->module.ModuleName, sym->hash_elt.name, 
444                           ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
445                 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
446                     FIXME("Changing size for %p/%s!%s from %08lx to %08x\n", 
447                           sym, module->module.ModuleName, sym->hash_elt.name,
448                           ((struct symt_function*)sym)->size, symp->st_size);
449
450                 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
451                                                         symp->st_value;
452                 ((struct symt_function*)sym)->size    = symp->st_size;
453             } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
454             break;
455         case SymTagData:
456             switch (((struct symt_data*)sym)->kind)
457             {
458             case DataIsGlobal:
459             case DataIsFileStatic:
460                 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr)
461                     break;
462                 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, 
463                                          ((struct symt_data*)sym)->container);
464                 if (symp)
465                 {
466                 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr &&
467                     ((struct symt_data*)sym)->u.address != module->elf_info->elf_addr + symp->st_value)
468                     FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n", 
469                           sym, module->module.ModuleName, sym->hash_elt.name, 
470                           ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
471                     ((struct symt_data*)sym)->u.address = module->elf_info->elf_addr +
472                                                           symp->st_value;
473                     ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
474                         DataIsFileStatic : DataIsGlobal;
475                 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
476                 break;
477             default:;
478             }
479             break;
480         default:
481             FIXME("Unsupported tag %u\n", sym->symt.tag);
482             break;
483         }
484     }
485     /* since we may have changed some addresses & sizes, mark the module to be resorted */
486     module->sortlist_valid = FALSE;
487 }
488
489 /******************************************************************
490  *              elf_load_wine_thunks
491  *
492  * creating the thunk objects for a wine native DLL
493  */
494 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
495                                unsigned num_areas, struct thunk_area* thunks)
496 {
497     int                         j;
498     struct symt_compiland*      compiland = NULL;
499     const char*                 compiland_name = NULL;
500     struct hash_table_iter      hti;
501     struct symtab_elt*          ste;
502     DWORD                       addr;
503     int                         idx;
504
505     hash_table_iter_init(ht_symtab, &hti, NULL);
506     while ((ste = hash_table_iter_up(&hti)))
507     {
508         if (ste->used) continue;
509
510         /* FIXME: this is not a good idea anyway... we are creating several
511          * compiland objects for a same compilation unit
512          * We try to cache the last compiland used, but it's not enough
513          * (we should here only create compilands if they are not yet 
514          *  defined)
515          */
516         if (!compiland_name || compiland_name != ste->filename)
517             compiland = symt_new_compiland(module, 
518                                            compiland_name = ste->filename);
519
520         addr = module->elf_info->elf_addr + ste->symp->st_value;
521
522         for (j = 0; j < num_areas; j++)
523         {
524             if (ste->symp->st_value >= thunks[j].rva_start && 
525                 ste->symp->st_value < thunks[j].rva_end)
526                 break;
527         }
528         if (j < num_areas) /* thunk found */
529         {
530             symt_new_thunk(module, compiland, ste->ht_elt.name, thunks[j].ordinal,
531                            addr, ste->symp->st_size);
532         }
533         else
534         {
535             ULONG64     ref_addr;
536
537             idx = symt_find_nearest(module, addr);
538             if (idx != -1)
539                 symt_get_info(&module->addr_sorttab[idx]->symt, 
540                               TI_GET_ADDRESS, &ref_addr);
541             if (idx == -1 || addr != ref_addr)
542             {
543                 /* creating public symbols for all the ELF symbols which haven't been
544                  * used yet (ie we have no debug information on them)
545                  * That's the case, for example, of the .spec.c files
546                  */
547                 switch (ELF32_ST_TYPE(ste->symp->st_info))
548                 {
549                 case STT_FUNC:
550                     symt_new_function(module, compiland, ste->ht_elt.name,
551                                       addr, ste->symp->st_size, NULL);
552                     break;
553                 case STT_OBJECT:
554                     symt_new_global_variable(module, compiland, ste->ht_elt.name,
555                                              ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
556                                              addr, ste->symp->st_size, NULL);
557                     break;
558                 default:
559                     FIXME("Shouldn't happen\n");
560                     break;
561                 }
562                 /* FIXME: this is a hack !!!
563                  * we are adding new symbols, but as we're parsing a symbol table
564                  * (hopefully without duplicate symbols) we delay rebuilding the sorted
565                  * module table until we're done with the symbol table
566                  * Otherwise, as we intertwine symbols's add and lookup, performance
567                  * is rather bad
568                  */
569                 module->sortlist_valid = TRUE;
570             }
571             else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
572             {
573                 ULONG64 xaddr = 0, xsize = 0;
574                 DWORD   kind = -1;
575
576                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS,  &xaddr);
577                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH,   &xsize);
578                 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind);
579
580                 /* If none of symbols has a correct size, we consider they are both markers
581                  * Hence, we can silence this warning
582                  * Also, we check that we don't have two symbols, one local, the other 
583                  * global which is legal
584                  */
585                 if ((xsize || ste->symp->st_size) && 
586                     (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
587                     FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%s>\n", 
588                           module->module.ModuleName,
589                           ste->ht_elt.name, addr, ste->symp->st_size,
590                           module->addr_sorttab[idx]->hash_elt.name,
591                           wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
592             }
593         }
594     }
595     /* see comment above */
596     module->sortlist_valid = FALSE;
597     return TRUE;
598 }
599
600 /******************************************************************
601  *              elf_new_public_symbols
602  *
603  * Creates a set of public symbols from an ELF symtab
604  */
605 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
606 {
607     struct symt_compiland*      compiland = NULL;
608     const char*                 compiland_name = NULL;
609     struct hash_table_iter      hti;
610     struct symtab_elt*          ste;
611
612     if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
613
614     /* FIXME: we're missing the ELF entry point here */
615
616     hash_table_iter_init(symtab, &hti, NULL);
617     while ((ste = hash_table_iter_up(&hti)))
618     {
619         /* FIXME: this is not a good idea anyway... we are creating several
620          * compiland objects for a same compilation unit
621          * We try to cache the last compiland used, but it's not enough
622          * (we should here only create compilands if they are not yet 
623          *  defined)
624          */
625         if (!compiland_name || compiland_name != ste->filename)
626             compiland = symt_new_compiland(module, 
627                                            compiland_name = ste->filename);
628
629         symt_new_public(module, compiland, ste->ht_elt.name,
630                         module->elf_info->elf_addr + ste->symp->st_value,
631                         ste->symp->st_size, TRUE /* FIXME */, 
632                         ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
633     }
634     return TRUE;
635 }
636
637 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
638    the following calc_crc32 code or tables extracted from it, as desired without
639    restriction. */
640
641 /**********************************************************************\
642 |* Demonstration program to compute the 32-bit CRC used as the frame  *|
643 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71     *|
644 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level     *|
645 |* protocol).  The 32-bit FCS was added via the Federal Register,     *|
646 |* 1 June 1982, p.23798.  I presume but don't know for certain that   *|
647 |* this polynomial is or will be included in CCITT V.41, which        *|
648 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial.  FIPS  *|
649 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected       *|
650 |* errors by a factor of 10^-5 over 16-bit FCS.                       *|
651 \**********************************************************************/
652
653 /* First, the polynomial itself and its table of feedback terms.  The  */
654 /* polynomial is                                                       */
655 /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
656 /* Note that we take it "backwards" and put the highest-order term in  */
657 /* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   */
658 /* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    */
659 /* the MSB being 1.                                                    */
660
661 /* Note that the usual hardware shift register implementation, which   */
662 /* is what we're using (we're merely optimizing it by doing eight-bit  */
663 /* chunks at a time) shifts bits into the lowest-order term.  In our   */
664 /* implementation, that means shifting towards the right.  Why do we   */
665 /* do it this way?  Because the calculated CRC must be transmitted in  */
666 /* order from highest-order term to lowest-order term.  UARTs transmit */
667 /* characters in order from LSB to MSB.  By storing the CRC this way,  */
668 /* we hand it to the UART in the order low-byte to high-byte; the UART */
669 /* sends each low-bit to hight-bit; and the result is transmission bit */
670 /* by bit from highest- to lowest-order term without requiring any bit */
671 /* shuffling on our part.  Reception works similarly.                  */
672
673 /* The feedback terms table consists of 256, 32-bit entries.  Notes:   */
674 /*                                                                     */
675 /*  1. The table can be generated at runtime if desired; code to do so */
676 /*     is shown later.  It might not be obvious, but the feedback      */
677 /*     terms simply represent the results of eight shift/xor opera-    */
678 /*     tions for all combinations of data and CRC register values.     */
679 /*                                                                     */
680 /*  2. The CRC accumulation logic is the same for all CRC polynomials, */
681 /*     be they sixteen or thirty-two bits wide.  You simply choose the */
682 /*     appropriate table.  Alternatively, because the table can be     */
683 /*     generated at runtime, you can start by generating the table for */
684 /*     the polynomial in question and use exactly the same "updcrc",   */
685 /*     if your application needn't simultaneously handle two CRC       */
686 /*     polynomials.  (Note, however, that XMODEM is strange.)          */
687 /*                                                                     */
688 /*  3. For 16-bit CRCs, the table entries need be only 16 bits wide;   */
689 /*     of course, 32-bit entries work OK if the high 16 bits are zero. */
690 /*                                                                     */
691 /*  4. The values must be right-shifted by eight bits by the "updcrc"  */
692 /*     logic; the shift must be unsigned (bring in zeroes).  On some   */
693 /*     hardware you could probably optimize the shift in assembler by  */
694 /*     using byte-swap instructions.                                   */
695
696
697 static DWORD calc_crc32(struct elf_file_map* fmap)
698 {
699 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
700     static const DWORD crc_32_tab[] =
701     { /* CRC polynomial 0xedb88320 */
702         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
703         0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
704         0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
705         0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
706         0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
707         0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
708         0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
709         0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
710         0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
711         0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
712         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
713         0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
714         0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
715         0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
716         0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
717         0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
718         0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
719         0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
720         0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
721         0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
722         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
723         0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
724         0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
725         0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
726         0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
727         0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
728         0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
729         0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
730         0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
731         0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
732         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
733         0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
734         0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
735         0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
736         0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
737         0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
738         0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
739         0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
740         0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
741         0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
742         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
743         0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
744         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
745     };
746     int                 i, r;
747     unsigned char       buffer[256];
748     DWORD               crc = ~0;
749
750     lseek(fmap->fd, 0, SEEK_SET);
751     while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
752     {
753         for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
754     }
755     return ~crc;
756 #undef UPDC32
757 }
758
759 /******************************************************************
760  *              elf_load_debug_info_from_map
761  *
762  * Loads the symbolic information from ELF module which mapping is described
763  * in fmap
764  * the module has been loaded at 'load_offset' address, so symbols' address
765  * relocation is performed.
766  * CRC is checked if fmap->with_crc is TRUE
767  * returns
768  *      0 if the file doesn't contain symbolic info (or this info cannot be
769  *      read or parsed)
770  *      1 on success
771  */
772 static BOOL elf_load_debug_info_from_map(struct module* module, 
773                                          struct elf_file_map* fmap,
774                                          struct pool* pool,
775                                          struct hash_table* ht_symtab)
776 {
777     BOOL                ret = FALSE;
778     const char*         shstrtab;
779     int                 i;
780     int                 symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
781     int                 debug_sect, debug_str_sect, debug_abbrev_sect, debug_line_sect;
782     int                 debuglink_sect;
783     struct thunk_area   thunks[] = 
784     {
785         {"__wine_spec_import_thunks",           THUNK_ORDINAL_NOTYPE, 0, 0},    /* inter DLL calls */
786         {"__wine_spec_delayed_import_loaders",  THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
787         {"__wine_spec_delayed_import_thunks",   THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
788         {"__wine_delay_load",                   THUNK_ORDINAL_LOAD,   0, 0},    /* delayed inter DLL calls */
789         {"__wine_spec_thunk_text_16",           -16,                  0, 0},    /* 16 => 32 thunks */
790         {"__wine_spec_thunk_text_32",           -32,                  0, 0},    /* 32 => 16 thunks */
791         {NULL,                                  0,                    0, 0}
792     };
793
794     if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
795     {
796         ERR("Bad CRC for module %s (got %08lx while expecting %08lx)\n",
797             module->module.ImageName, calc_crc32(fmap), fmap->crc);
798         /* we don't tolerate mis-matched files */
799         return FALSE;
800     }
801
802     /*
803      * Next, we need to find a few of the internal ELF headers within
804      * this thing.  We need the main executable header, and the section
805      * table.
806      */
807     shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
808     if (shstrtab == NO_MAP) return FALSE;
809
810     symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
811     debug_sect = debug_str_sect = debug_abbrev_sect = debug_line_sect = -1;
812     debuglink_sect = -1;
813
814     for (i = 0; i < fmap->elfhdr.e_shnum; i++)
815     {
816         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
817             stab_sect = i;
818         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
819             stabstr_sect = i;
820         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
821             debug_sect = i;
822         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
823             debug_str_sect = i;
824         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
825             debug_abbrev_sect = i;
826         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
827             debug_line_sect = i;
828         if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
829             debuglink_sect = i;
830         if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
831             (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
832             symtab_sect = i;
833         if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
834             (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
835             dynsym_sect = i;
836     }
837     elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
838     shstrtab = NULL;
839
840     if (symtab_sect == -1)
841     {
842         /* if we don't have a symtab but a dynsym, process the dynsym
843          * section instead. It'll contain less (relevant) information, 
844          * but it'll be better than nothing
845          */
846         if (dynsym_sect == -1) return FALSE;
847         symtab_sect = dynsym_sect;
848     }
849
850     module->module.SymType = SymExport;
851
852     /* create a hash table for the symtab */
853     elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
854
855     if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
856     {
857         if (stab_sect != -1 && stabstr_sect != -1)
858         {
859             const char* stab;
860             const char* stabstr;
861
862             stab = elf_map_section(fmap, stab_sect);
863             stabstr = elf_map_section(fmap, stabstr_sect);
864             if (stab != NO_MAP && stabstr != NO_MAP)
865             {
866                 /* OK, now just parse all of the stabs. */
867                 ret = stabs_parse(module, module->elf_info->elf_addr,
868                                   stab, fmap->sect[stab_sect].shdr.sh_size,
869                                   stabstr, fmap->sect[stabstr_sect].shdr.sh_size);
870             }
871             elf_unmap_section(fmap, stab_sect);
872             elf_unmap_section(fmap, stabstr_sect);
873             
874             if (!ret)
875             {
876                 WARN("Couldn't correctly read stabs\n");
877                 return FALSE;
878             }
879             /* and fill in the missing information for stabs */
880             elf_finish_stabs_info(module, ht_symtab);
881         }
882         else if (debug_sect != -1)
883         {
884             /* Dwarf 2 debug information */
885             const BYTE* dw2_debug;
886             const BYTE* dw2_debug_abbrev;
887             const BYTE* dw2_debug_str;
888
889             FIXME("Alpha-support for Dwarf2 information for %s\n", module->module.ModuleName);
890
891             dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
892             dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
893             dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
894             if (dw2_debug != NO_MAP && NO_MAP != dw2_debug_abbrev && dw2_debug_str != NO_MAP)
895             {
896                 /* OK, now just parse dwarf2 debug infos. */
897                 ret = dwarf2_parse(module, module->elf_info->elf_addr,
898                                    dw2_debug, fmap->sect[debug_sect].shdr.sh_size,
899                                    dw2_debug_abbrev, fmap->sect[debug_abbrev_sect].shdr.sh_size,
900                                    dw2_debug_str, fmap->sect[debug_str_sect].shdr.sh_size);
901             }
902             elf_unmap_section(fmap, debug_sect);
903             elf_unmap_section(fmap, debug_abbrev_sect);
904             elf_unmap_section(fmap, debug_str_sect);
905             if (!ret)
906             {
907                 WARN("Couldn't correctly read stabs\n");
908                 return FALSE;
909             }
910         }
911         else if (debuglink_sect != -1)
912         {
913             const char* dbg_link;
914             struct elf_file_map fmap_link;
915
916             dbg_link = elf_map_section(fmap, debuglink_sect);
917             /* The content of a debug link section is:
918              * 1/ a NULL terminated string, containing the file name for the
919              *    debug info
920              * 2/ padding on 4 byte boundary
921              * 3/ CRC of the linked ELF file
922              */
923             if (dbg_link != NO_MAP && elf_map_file(dbg_link, &fmap_link))
924             {
925                 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
926                 fmap_link.with_crc = 1;
927                 ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
928                                                    ht_symtab);
929                 if (!ret)
930                     WARN("Couldn't load debug information from %s\n", dbg_link);
931             }
932             else
933                 WARN("Couldn't load linked debug file for %s\n",
934                      module->module.ModuleName);
935             elf_unmap_file(&fmap_link);
936         }
937     }
938     if (strstr(module->module.ModuleName, "<elf>") ||
939         !strcmp(module->module.ModuleName, "<wine-loader>"))
940     {
941         /* add the thunks for native libraries */
942         if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
943             elf_new_wine_thunks(module, ht_symtab, 
944                                 sizeof(thunks) / sizeof(thunks[0]), thunks);
945     }
946     /* add all the public symbols from symtab */
947     if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
948
949     return ret;
950 }
951
952 /******************************************************************
953  *              elf_load_debug_info
954  *
955  * Loads ELF debugging information from the module image file.
956  */
957 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
958 {
959     BOOL                ret = TRUE;
960     struct pool         pool;
961     struct hash_table   ht_symtab;
962     struct elf_file_map my_fmap;
963
964     if (module->type != DMT_ELF || !module->elf_info)
965     {
966         ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
967         return FALSE;
968     }
969
970     pool_init(&pool, 65536);
971     hash_table_init(&pool, &ht_symtab, 256);
972
973     if (!fmap)
974     {
975         fmap = &my_fmap;
976         ret = elf_map_file(module->module.LoadedImageName, fmap);
977     }
978     if (ret)
979         ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
980
981     pool_destroy(&pool);
982     if (fmap == &my_fmap) elf_unmap_file(fmap);
983     return ret;
984 }
985
986 /******************************************************************
987  *              elf_fetch_file_info
988  *
989  * Gathers some more information for an ELF module from a given file
990  */
991 BOOL elf_fetch_file_info(const char* name, DWORD* base,
992                          DWORD* size, DWORD* checksum)
993 {
994     struct elf_file_map fmap;
995     if (!elf_map_file(name, &fmap)) return FALSE;
996     if (base) *base = fmap.elf_start;
997     *size = fmap.elf_size;
998     *checksum = calc_crc32(&fmap);
999     elf_unmap_file(&fmap);
1000     return TRUE;
1001 }
1002
1003 /******************************************************************
1004  *              is_dt_flag_valid
1005  * returns true iff the section tag is valid 
1006  */
1007 static unsigned is_dt_flag_valid(unsigned d_tag)
1008 {
1009 #ifndef DT_PROCNUM
1010 #define DT_PROCNUM 0
1011 #endif
1012 #ifndef DT_EXTRANUM
1013 #define DT_EXTRANUM 0
1014 #endif
1015     return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
1016 #if defined(DT_LOOS) && defined(DT_HIOS)
1017         || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
1018 #endif
1019 #if defined(DT_LOPROC) && defined(DT_HIPROC)
1020         || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
1021 #endif
1022         ;
1023 }
1024
1025 /******************************************************************
1026  *              elf_load_file
1027  *
1028  * Loads the information for ELF module stored in 'filename'
1029  * the module has been loaded at 'load_offset' address
1030  * returns
1031  *      -1 if the file cannot be found/opened
1032  *      0 if the file doesn't contain symbolic info (or this info cannot be
1033  *      read or parsed)
1034  *      1 on success
1035  */
1036 static BOOL elf_load_file(struct process* pcs, const char* filename,
1037                           unsigned long load_offset, struct elf_info* elf_info)
1038 {
1039     BOOL                ret = FALSE;
1040     struct elf_file_map fmap;
1041     int                 i;
1042
1043     TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1044
1045     if (!elf_map_file(filename, &fmap)) goto leave;
1046
1047     /* Next, we need to find a few of the internal ELF headers within
1048      * this thing.  We need the main executable header, and the section
1049      * table.
1050      */
1051     if (!fmap.elf_start && !load_offset)
1052         ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1053             filename);
1054     if (fmap.elf_start && load_offset)
1055     {
1056         WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1057              "Assuming load address is corrupt\n", filename, load_offset);
1058         load_offset = 0;
1059     }
1060
1061     if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1062     {
1063         const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1064         if (shstrtab == NO_MAP) goto leave;
1065         for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1066         {
1067             if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1068                 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1069             {
1070                 Elf32_Dyn       dyn;
1071                 char*           ptr = (char*)fmap.sect[i].shdr.sh_addr;
1072                 unsigned long   len;
1073
1074                 do
1075                 {
1076                     if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1077                         len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
1078                         dyn.d_tag = DT_NULL;
1079                     ptr += sizeof(dyn);
1080                 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1081                 if (dyn.d_tag == DT_NULL) goto leave;
1082                 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1083             }
1084         }
1085         elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1086     }
1087
1088     if (elf_info->flags & ELF_INFO_MODULE)
1089     {
1090         struct elf_module_info *elf_module_info = 
1091             HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1092         if (!elf_module_info) goto leave;
1093         elf_info->module = module_new(pcs, filename, DMT_ELF, 
1094                                       (load_offset) ? load_offset : fmap.elf_start, 
1095                                       fmap.elf_size, 0, calc_crc32(&fmap));
1096         if (!elf_info->module)
1097         {
1098             HeapFree(GetProcessHeap(), 0, elf_module_info);
1099             goto leave;
1100         }
1101         elf_info->module->elf_info = elf_module_info;
1102         elf_info->module->elf_info->elf_addr = load_offset;
1103
1104         if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1105         {
1106             elf_info->module->module.SymType = SymDeferred;
1107             ret = TRUE;
1108         }
1109         else ret = elf_load_debug_info(elf_info->module, &fmap);
1110
1111         elf_info->module->elf_info->elf_mark = 1;
1112         elf_info->module->elf_info->elf_loader = 0;
1113     } else ret = TRUE;
1114
1115     if (elf_info->flags & ELF_INFO_NAME)
1116     {
1117         elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1118                                                  strlen(filename) + 1), filename);
1119     }
1120 leave:
1121     elf_unmap_file(&fmap);
1122
1123     return ret;
1124 }
1125
1126 /******************************************************************
1127  *              elf_load_file_from_path
1128  * tries to load an ELF file from a set of paths (separated by ':')
1129  */
1130 static BOOL elf_load_file_from_path(HANDLE hProcess,
1131                                     const char* filename,
1132                                     unsigned long load_offset,
1133                                     const char* path,
1134                                     struct elf_info* elf_info)
1135 {
1136     BOOL                ret = FALSE;
1137     char                *s, *t, *fn;
1138     char*               paths = NULL;
1139
1140     if (!path) return FALSE;
1141
1142     paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1143     for (s = paths; s && *s; s = (t) ? (t+1) : NULL) 
1144     {
1145         t = strchr(s, ':');
1146         if (t) *t = '\0';
1147         fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1148         if (!fn) break;
1149         strcpy(fn, s);
1150         strcat(fn, "/");
1151         strcat(fn, filename);
1152         ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1153         HeapFree(GetProcessHeap(), 0, fn);
1154         if (ret) break;
1155         s = (t) ? (t+1) : NULL;
1156     }
1157     
1158     HeapFree(GetProcessHeap(), 0, paths);
1159     return ret;
1160 }
1161
1162 /******************************************************************
1163  *              elf_search_and_load_file
1164  *
1165  * lookup a file in standard ELF locations, and if found, load it
1166  */
1167 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1168                                      unsigned long load_offset, 
1169                                      struct elf_info* elf_info)
1170 {
1171     BOOL                ret = FALSE;
1172     struct module*      module;
1173
1174     if (filename == NULL || *filename == '\0') return FALSE;
1175     if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1176     {
1177         elf_info->module = module;
1178         module->elf_info->elf_mark = 1;
1179         return module->module.SymType;
1180     }
1181
1182     if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1183     ret = elf_load_file(pcs, filename, load_offset, elf_info);
1184     /* if relative pathname, try some absolute base dirs */
1185     if (!ret && !strchr(filename, '/'))
1186     {
1187         ret = elf_load_file_from_path(pcs, filename, load_offset, 
1188                                       getenv("PATH"), elf_info) ||
1189             elf_load_file_from_path(pcs, filename, load_offset,
1190                                     getenv("LD_LIBRARY_PATH"), elf_info) ||
1191             elf_load_file_from_path(pcs, filename, load_offset,
1192                                     getenv("WINEDLLPATH"), elf_info);
1193     }
1194     
1195     return ret;
1196 }
1197
1198 /******************************************************************
1199  *              elf_enum_modules_internal
1200  *
1201  * Enumerate ELF modules from a running process
1202  */
1203 static BOOL elf_enum_modules_internal(const struct process* pcs,
1204                                       const char* main_name,
1205                                       elf_enum_modules_cb cb, void* user)
1206 {
1207     struct r_debug      dbg_hdr;
1208     void*               lm_addr;
1209     struct link_map     lm;
1210     char                bufstr[256];
1211
1212     if (!pcs->dbg_hdr_addr ||
1213         !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr, 
1214                            &dbg_hdr, sizeof(dbg_hdr), NULL))
1215         return FALSE;
1216
1217     /* Now walk the linked list.  In all known ELF implementations,
1218      * the dynamic loader maintains this linked list for us.  In some
1219      * cases the first entry doesn't appear with a name, in other cases it
1220      * does.
1221      */
1222     for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1223     {
1224         if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1225             return FALSE;
1226
1227         if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1228             lm.l_name != NULL &&
1229             ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL)) 
1230         {
1231             bufstr[sizeof(bufstr) - 1] = '\0';
1232             if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1233             if (!cb(bufstr, (unsigned long)lm.l_addr, user)) break;
1234         }
1235     }
1236     return TRUE;
1237 }
1238
1239 struct elf_sync
1240 {
1241     struct process*     pcs;
1242     struct elf_info     elf_info;
1243 };
1244
1245 static BOOL elf_enum_sync_cb(const char* name, unsigned long addr, void* user)
1246 {
1247     struct elf_sync*    es = user;
1248
1249     elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1250     return TRUE;
1251 }
1252     
1253 /******************************************************************
1254  *              elf_synchronize_module_list
1255  *
1256  * this functions rescans the debuggee module's list and synchronizes it with
1257  * the one from 'pcs', ie:
1258  * - if a module is in debuggee and not in pcs, it's loaded into pcs
1259  * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1260  */
1261 BOOL    elf_synchronize_module_list(struct process* pcs)
1262 {
1263     struct module*      module;
1264     struct elf_sync     es;
1265
1266     for (module = pcs->lmodules; module; module = module->next)
1267     {
1268         if (module->type == DMT_ELF) module->elf_info->elf_mark = 0;
1269     }
1270
1271     es.pcs = pcs;
1272     es.elf_info.flags = ELF_INFO_MODULE;
1273     if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1274         return FALSE;
1275
1276     module = pcs->lmodules;
1277     while (module)
1278     {
1279         if (module->type == DMT_ELF && !module->elf_info->elf_mark && 
1280             !module->elf_info->elf_loader)
1281         {
1282             module_remove(pcs, module);
1283             /* restart all over */
1284             module = pcs->lmodules;
1285         }
1286         else module = module->next;
1287     }
1288     return TRUE;
1289 }
1290
1291 /******************************************************************
1292  *              elf_search_loader
1293  *
1294  * Lookup in a running ELF process the loader, and sets its ELF link
1295  * address (for accessing the list of loaded .so libs) in pcs.
1296  * If flags is ELF_INFO_MODULE, the module for the loader is also
1297  * added as a module into pcs.
1298  */
1299 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1300 {
1301     BOOL                ret;
1302     const char*         ptr;
1303
1304     /* All binaries are loaded with WINELOADER (if run from tree) or by the
1305      * main executable (either wine-kthread or wine-pthread)
1306      * FIXME: the heuristic used to know whether we need to load wine-pthread
1307      * or wine-kthread is not 100% safe
1308      */
1309     if ((ptr = getenv("WINELOADER")))
1310         ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1311     else 
1312     {
1313         ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1314             elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1315     }
1316     return ret;
1317 }
1318
1319 /******************************************************************
1320  *              elf_read_wine_loader_dbg_info
1321  *
1322  * Try to find a decent wine executable which could have loaded the debuggee
1323  */
1324 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1325 {
1326     struct elf_info     elf_info;
1327
1328     elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1329     if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1330     elf_info.module->elf_info->elf_loader = 1;
1331     strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
1332     return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1333 }
1334
1335 /******************************************************************
1336  *              elf_enum_modules
1337  *
1338  * Enumerates the ELF loaded modules from a running target (hProc)
1339  * This function doesn't require that someone has called SymInitialize
1340  * on this very process.
1341  */
1342 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1343 {
1344     struct process      pcs;
1345     struct elf_info     elf_info;
1346     BOOL                ret;
1347
1348     memset(&pcs, 0, sizeof(pcs));
1349     pcs.handle = hProc;
1350     elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1351     if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1352     pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1353     ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1354     HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1355     return ret;
1356 }
1357
1358 struct elf_load
1359 {
1360     struct process*     pcs;
1361     struct elf_info     elf_info;
1362     const char*         name;
1363     BOOL                ret;
1364 };
1365
1366 /******************************************************************
1367  *              elf_load_cb
1368  *
1369  * Callback for elf_load_module, used to walk the list of loaded
1370  * modules.
1371  */
1372 static BOOL elf_load_cb(const char* name, unsigned long addr, void* user)
1373 {
1374     struct elf_load*    el = user;
1375     const char*         p;
1376
1377     /* memcmp is needed for matches when bufstr contains also version information
1378      * el->name: libc.so, name: libc.so.6.0
1379      */
1380     p = strrchr(name, '/');
1381     if (!p++) p = name;
1382     if (!memcmp(p, el->name, strlen(el->name)))
1383     {
1384         el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1385         return FALSE;
1386     }
1387     return TRUE;
1388 }
1389
1390 /******************************************************************
1391  *              elf_load_module
1392  *
1393  * loads an ELF module and stores it in process' module list
1394  * Also, find module real name and load address from
1395  * the real loaded modules list in pcs address space
1396  */
1397 struct module*  elf_load_module(struct process* pcs, const char* name, DWORD addr)
1398 {
1399     struct elf_load     el;
1400
1401     TRACE("(%p %s %08lx)\n", pcs, name, addr);
1402
1403     el.elf_info.flags = ELF_INFO_MODULE;
1404     el.ret = FALSE;
1405
1406     if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1407     {
1408         el.pcs = pcs;
1409         /* do only the lookup from the filename, not the path (as we lookup module
1410          * name in the process' loaded module list)
1411          */
1412         el.name = strrchr(name, '/');
1413         if (!el.name++) el.name = name;
1414         el.ret = FALSE;
1415
1416         if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1417             return NULL;
1418     }
1419     else if (addr)
1420     {
1421         el.ret = elf_search_and_load_file(pcs, name, addr, &el.elf_info);
1422     }
1423     if (!el.ret) return NULL;
1424     assert(el.elf_info.module);
1425     return el.elf_info.module;
1426 }
1427
1428 #else   /* !__ELF__ */
1429
1430 BOOL    elf_synchronize_module_list(struct process* pcs)
1431 {
1432     return FALSE;
1433 }
1434
1435 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1436                          DWORD* size, DWORD* checksum)
1437 {
1438     return FALSE;
1439 }
1440
1441 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1442 {
1443     return FALSE;
1444 }
1445
1446 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1447 {
1448     return FALSE;
1449 }
1450
1451 struct module*  elf_load_module(struct process* pcs, const char* name, DWORD addr)
1452 {
1453     return NULL;
1454 }
1455
1456 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1457 {
1458     return FALSE;
1459 }
1460 #endif  /* __ELF__ */