?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32: Add more tracing to GetDiskFreeSpaceW.
[wine/multimedia.git] / dlls / dbghelp / elf_module.c
blob52060e08c9b4de8ed2ceaf716d82d86c8a51a739
1 /*
2 * File elf.c - processing of ELF files
3 *
4 * Copyright (C) 1996, Eric Youngdale.
5 * 1999-2007 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #if defined(__svr4__) || defined(__sun)
26 #define __ELF__ 1
27 /* large files are not supported by libelf */
28 #undef _FILE_OFFSET_BITS
29 #define _FILE_OFFSET_BITS 32
30 #endif
31
32 #include <assert.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #ifdef HAVE_SYS_STAT_H
36 # include <sys/stat.h>
37 #endif
38 #include <fcntl.h>
39 #ifdef HAVE_SYS_MMAN_H
40 #include <sys/mman.h>
41 #endif
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45
46 #include "dbghelp_private.h"
47
48 #include "image_private.h"
49
50 #include "wine/library.h"
51 #include "wine/debug.h"
52
53 #ifdef __ELF__
54
55 #define ELF_INFO_DEBUG_HEADER 0x0001
56 #define ELF_INFO_MODULE 0x0002
57 #define ELF_INFO_NAME 0x0004
58
59 #ifndef NT_GNU_BUILD_ID
60 #define NT_GNU_BUILD_ID 3
61 #endif
62
63 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
64
65 struct elf_info
66 {
67 unsigned flags; /* IN one (or several) of the ELF_INFO constants */
68 DWORD_PTR dbg_hdr_addr; /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
69 struct module* module; /* OUT loaded module (if ELF_INFO_MODULE is set) */
70 const WCHAR* module_name; /* OUT found module name (if ELF_INFO_NAME is set) */
71 };
72
73 struct symtab_elt
74 {
75 struct hash_table_elt ht_elt;
76 const Elf_Sym* symp;
77 struct symt_compiland* compiland;
78 unsigned used;
79 };
80
81 struct elf_thunk_area
82 {
83 const char* symname;
84 THUNK_ORDINAL ordinal;
85 unsigned long rva_start;
86 unsigned long rva_end;
87 };
88
89 struct elf_module_info
90 {
91 unsigned long elf_addr;
92 unsigned short elf_mark : 1,
93 elf_loader : 1;
94 struct image_file_map file_map;
95 };
96
97 /******************************************************************
98 * elf_map_section
99 *
100 * Maps a single section into memory from an ELF file
101 */
102 const char* elf_map_section(struct image_section_map* ism)
103 {
104 struct elf_file_map* fmap = &ism->fmap->u.elf;
105
106 unsigned long pgsz = getpagesize();
107 unsigned long ofst, size;
108
109 assert(ism->fmap->modtype == DMT_ELF);
110 if (ism->sidx < 0 || ism->sidx >= ism->fmap->u.elf.elfhdr.e_shnum ||
111 fmap->sect[ism->sidx].shdr.sh_type == SHT_NOBITS)
112 return IMAGE_NO_MAP;
113
114 if (fmap->target_copy)
115 {
116 return fmap->target_copy + fmap->sect[ism->sidx].shdr.sh_offset;
117 }
118 /* align required information on page size (we assume pagesize is a power of 2) */
119 ofst = fmap->sect[ism->sidx].shdr.sh_offset & ~(pgsz - 1);
120 size = ((fmap->sect[ism->sidx].shdr.sh_offset +
121 fmap->sect[ism->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst;
122 fmap->sect[ism->sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE,
123 fmap->fd, ofst);
124 if (fmap->sect[ism->sidx].mapped == IMAGE_NO_MAP) return IMAGE_NO_MAP;
125 return fmap->sect[ism->sidx].mapped + (fmap->sect[ism->sidx].shdr.sh_offset & (pgsz - 1));
126 }
127
128 /******************************************************************
129 * elf_find_section
130 *
131 * Finds a section by name (and type) into memory from an ELF file
132 * or its alternate if any
133 */
134 BOOL elf_find_section(struct image_file_map* _fmap, const char* name,
135 unsigned sht, struct image_section_map* ism)
136 {
137 struct elf_file_map* fmap;
138 unsigned i;
139
140 while (_fmap)
141 {
142 fmap = &_fmap->u.elf;
143 if (fmap->shstrtab == IMAGE_NO_MAP)
144 {
145 struct image_section_map hdr_ism = {_fmap, fmap->elfhdr.e_shstrndx};
146 if ((fmap->shstrtab = elf_map_section(&hdr_ism)) == IMAGE_NO_MAP) break;
147 }
148 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
149 {
150 if (strcmp(fmap->shstrtab + fmap->sect[i].shdr.sh_name, name) == 0 &&
151 (sht == SHT_NULL || sht == fmap->sect[i].shdr.sh_type))
152 {
153 ism->fmap = _fmap;
154 ism->sidx = i;
155 return TRUE;
156 }
157 }
158 _fmap = fmap->alternate;
159 }
160 ism->fmap = NULL;
161 ism->sidx = -1;
162 return FALSE;
163 }
164
165 /******************************************************************
166 * elf_unmap_section
167 *
168 * Unmaps a single section from memory
169 */
170 void elf_unmap_section(struct image_section_map* ism)
171 {
172 struct elf_file_map* fmap = &ism->fmap->u.elf;
173
174 if (ism->sidx >= 0 && ism->sidx < fmap->elfhdr.e_shnum && !fmap->target_copy &&
175 fmap->sect[ism->sidx].mapped != IMAGE_NO_MAP)
176 {
177 unsigned long pgsz = getpagesize();
178 unsigned long ofst, size;
179
180 ofst = fmap->sect[ism->sidx].shdr.sh_offset & ~(pgsz - 1);
181 size = ((fmap->sect[ism->sidx].shdr.sh_offset +
182 fmap->sect[ism->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst;
183 if (munmap((char*)fmap->sect[ism->sidx].mapped, size) < 0)
184 WARN("Couldn't unmap the section\n");
185 fmap->sect[ism->sidx].mapped = IMAGE_NO_MAP;
186 }
187 }
188
189 static void elf_end_find(struct image_file_map* fmap)
190 {
191 struct image_section_map ism;
192
193 while (fmap)
194 {
195 ism.fmap = fmap;
196 ism.sidx = fmap->u.elf.elfhdr.e_shstrndx;
197 elf_unmap_section(&ism);
198 fmap->u.elf.shstrtab = IMAGE_NO_MAP;
199 fmap = fmap->u.elf.alternate;
200 }
201 }
202
203 /******************************************************************
204 * elf_get_map_rva
205 *
206 * Get the RVA of an ELF section
207 */
208 DWORD_PTR elf_get_map_rva(const struct image_section_map* ism)
209 {
210 if (ism->sidx < 0 || ism->sidx >= ism->fmap->u.elf.elfhdr.e_shnum)
211 return 0;
212 return ism->fmap->u.elf.sect[ism->sidx].shdr.sh_addr - ism->fmap->u.elf.elf_start;
213 }
214
215 /******************************************************************
216 * elf_get_map_size
217 *
218 * Get the size of an ELF section
219 */
220 unsigned elf_get_map_size(const struct image_section_map* ism)
221 {
222 if (ism->sidx < 0 || ism->sidx >= ism->fmap->u.elf.elfhdr.e_shnum)
223 return 0;
224 return ism->fmap->u.elf.sect[ism->sidx].shdr.sh_size;
225 }
226
227 static inline void elf_reset_file_map(struct image_file_map* fmap)
228 {
229 fmap->u.elf.fd = -1;
230 fmap->u.elf.shstrtab = IMAGE_NO_MAP;
231 fmap->u.elf.alternate = NULL;
232 fmap->u.elf.target_copy = NULL;
233 }
234
235 struct elf_map_file_data
236 {
237 enum {from_file, from_process} kind;
238 union
239 {
240 struct
241 {
242 const WCHAR* filename;
243 } file;
244 struct
245 {
246 HANDLE handle;
247 void* load_addr;
248 } process;
249 } u;
250 };
251
252 static BOOL elf_map_file_read(struct image_file_map* fmap, struct elf_map_file_data* emfd,
253 void* buf, size_t len, off_t off)
254 {
255 SIZE_T dw;
256
257 switch (emfd->kind)
258 {
259 case from_file:
260 return pread(fmap->u.elf.fd, buf, len, off) == len;
261 case from_process:
262 return ReadProcessMemory(emfd->u.process.handle,
263 (void*)((unsigned long)emfd->u.process.load_addr + (unsigned long)off),
264 buf, len, &dw) && dw == len;
265 default:
266 assert(0);
267 return FALSE;
268 }
269 }
270
271 /******************************************************************
272 * elf_map_file
273 *
274 * Maps an ELF file into memory (and checks it's a real ELF file)
275 */
276 static BOOL elf_map_file(struct elf_map_file_data* emfd, struct image_file_map* fmap)
277 {
278 static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
279 struct stat statbuf;
280 int i;
281 Elf_Phdr phdr;
282 unsigned long tmp, page_mask = getpagesize() - 1;
283 char* filename;
284 unsigned len;
285 BOOL ret = FALSE;
286
287 switch (emfd->kind)
288 {
289 case from_file:
290 len = WideCharToMultiByte(CP_UNIXCP, 0, emfd->u.file.filename, -1, NULL, 0, NULL, NULL);
291 if (!(filename = HeapAlloc(GetProcessHeap(), 0, len))) return FALSE;
292 WideCharToMultiByte(CP_UNIXCP, 0, emfd->u.file.filename, -1, filename, len, NULL, NULL);
293 break;
294 case from_process:
295 filename = NULL;
296 break;
297 default: assert(0);
298 return FALSE;
299 }
300
301 elf_reset_file_map(fmap);
302
303 fmap->modtype = DMT_ELF;
304 fmap->u.elf.fd = -1;
305 fmap->u.elf.target_copy = NULL;
306
307 switch (emfd->kind)
308 {
309 case from_file:
310 /* check that the file exists, and that the module hasn't been loaded yet */
311 if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) goto done;
312
313 /* Now open the file, so that we can mmap() it. */
314 if ((fmap->u.elf.fd = open(filename, O_RDONLY)) == -1) goto done;
315 break;
316 case from_process:
317 break;
318 }
319 if (!elf_map_file_read(fmap, emfd, &fmap->u.elf.elfhdr, sizeof(fmap->u.elf.elfhdr), 0))
320 goto done;
321
322 /* and check for an ELF header */
323 if (memcmp(fmap->u.elf.elfhdr.e_ident,
324 elf_signature, sizeof(elf_signature))) goto done;
325 /* and check 32 vs 64 size according to current machine */
326 #ifdef _WIN64
327 if (fmap->u.elf.elfhdr.e_ident[EI_CLASS] != ELFCLASS64) goto done;
328 #else
329 if (fmap->u.elf.elfhdr.e_ident[EI_CLASS] != ELFCLASS32) goto done;
330 #endif
331 fmap->addr_size = fmap->u.elf.elfhdr.e_ident[EI_CLASS] == ELFCLASS64 ? 64 : 32;
332 fmap->u.elf.sect = HeapAlloc(GetProcessHeap(), 0,
333 fmap->u.elf.elfhdr.e_shnum * sizeof(fmap->u.elf.sect[0]));
334 if (!fmap->u.elf.sect) goto done;
335
336 for (i = 0; i < fmap->u.elf.elfhdr.e_shnum; i++)
337 {
338 if (!elf_map_file_read(fmap, emfd, &fmap->u.elf.sect[i].shdr, sizeof(fmap->u.elf.sect[i].shdr),
339 fmap->u.elf.elfhdr.e_shoff + i * sizeof(fmap->u.elf.sect[i].shdr)))
340 {
341 HeapFree(GetProcessHeap(), 0, fmap->u.elf.sect);
342 fmap->u.elf.sect = NULL;
343 goto done;
344 }
345 fmap->u.elf.sect[i].mapped = IMAGE_NO_MAP;
346 }
347
348 /* grab size of module once loaded in memory */
349 fmap->u.elf.elf_size = 0;
350 fmap->u.elf.elf_start = ~0L;
351 for (i = 0; i < fmap->u.elf.elfhdr.e_phnum; i++)
352 {
353 if (elf_map_file_read(fmap, emfd, &phdr, sizeof(phdr),
354 fmap->u.elf.elfhdr.e_phoff + i * sizeof(phdr)) &&
355 phdr.p_type == PT_LOAD)
356 {
357 tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
358 if (fmap->u.elf.elf_size < tmp) fmap->u.elf.elf_size = tmp;
359 if (phdr.p_vaddr < fmap->u.elf.elf_start) fmap->u.elf.elf_start = phdr.p_vaddr;
360 }
361 }
362 /* if non relocatable ELF, then remove fixed address from computation
363 * otherwise, all addresses are zero based and start has no effect
364 */
365 fmap->u.elf.elf_size -= fmap->u.elf.elf_start;
366
367 switch (emfd->kind)
368 {
369 case from_file: break;
370 case from_process:
371 if (!(fmap->u.elf.target_copy = HeapAlloc(GetProcessHeap(), 0, fmap->u.elf.elf_size)))
372 {
373 HeapFree(GetProcessHeap(), 0, fmap->u.elf.sect);
374 goto done;
375 }
376 if (!ReadProcessMemory(emfd->u.process.handle, emfd->u.process.load_addr, fmap->u.elf.target_copy,
377 fmap->u.elf.elf_size, NULL))
378 {
379 HeapFree(GetProcessHeap(), 0, fmap->u.elf.target_copy);
380 HeapFree(GetProcessHeap(), 0, fmap->u.elf.sect);
381 goto done;
382 }
383 break;
384 }
385 ret = TRUE;
386 done:
387 HeapFree(GetProcessHeap(), 0, filename);
388 return ret;
389 }
390
391 /******************************************************************
392 * elf_unmap_file
393 *
394 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
395 */
396 static void elf_unmap_file(struct image_file_map* fmap)
397 {
398 while (fmap)
399 {
400 if (fmap->u.elf.fd != -1)
401 {
402 struct image_section_map ism;
403 ism.fmap = fmap;
404 for (ism.sidx = 0; ism.sidx < fmap->u.elf.elfhdr.e_shnum; ism.sidx++)
405 {
406 elf_unmap_section(&ism);
407 }
408 HeapFree(GetProcessHeap(), 0, fmap->u.elf.sect);
409 close(fmap->u.elf.fd);
410 }
411 HeapFree(GetProcessHeap(), 0, fmap->u.elf.target_copy);
412 fmap = fmap->u.elf.alternate;
413 }
414 }
415
416 static void elf_module_remove(struct process* pcs, struct module_format* modfmt)
417 {
418 elf_unmap_file(&modfmt->u.elf_info->file_map);
419 HeapFree(GetProcessHeap(), 0, modfmt);
420 }
421
422 /******************************************************************
423 * elf_is_in_thunk_area
424 *
425 * Check whether an address lies within one of the thunk area we
426 * know of.
427 */
428 int elf_is_in_thunk_area(unsigned long addr,
429 const struct elf_thunk_area* thunks)
430 {
431 unsigned i;
432
433 if (thunks) for (i = 0; thunks[i].symname; i++)
434 {
435 if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
436 return i;
437 }
438 return -1;
439 }
440
441 /******************************************************************
442 * elf_hash_symtab
443 *
444 * creating an internal hash table to ease use ELF symtab information lookup
445 */
446 static void elf_hash_symtab(struct module* module, struct pool* pool,
447 struct hash_table* ht_symtab, struct image_file_map* fmap,
448 struct elf_thunk_area* thunks)
449 {
450 int i, j, nsym;
451 const char* strp;
452 const char* symname;
453 struct symt_compiland* compiland = NULL;
454 const char* ptr;
455 const Elf_Sym* symp;
456 struct symtab_elt* ste;
457 struct image_section_map ism, ism_str;
458
459 if (!elf_find_section(fmap, ".symtab", SHT_SYMTAB, &ism) &&
460 !elf_find_section(fmap, ".dynsym", SHT_DYNSYM, &ism)) return;
461 if ((symp = (const Elf_Sym*)image_map_section(&ism)) == IMAGE_NO_MAP) return;
462 ism_str.fmap = ism.fmap;
463 ism_str.sidx = fmap->u.elf.sect[ism.sidx].shdr.sh_link;
464 if ((strp = image_map_section(&ism_str)) == IMAGE_NO_MAP)
465 {
466 image_unmap_section(&ism);
467 return;
468 }
469
470 nsym = image_get_map_size(&ism) / sizeof(*symp);
471
472 for (j = 0; thunks[j].symname; j++)
473 thunks[j].rva_start = thunks[j].rva_end = 0;
474
475 for (i = 0; i < nsym; i++, symp++)
476 {
477 /* Ignore certain types of entries which really aren't of that much
478 * interest.
479 */
480 if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE &&
481 ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
482 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
483 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
484 symp->st_shndx == SHN_UNDEF)
485 {
486 continue;
487 }
488
489 symname = strp + symp->st_name;
490
491 /* handle some specific symtab (that we'll throw away when done) */
492 switch (ELF32_ST_TYPE(symp->st_info))
493 {
494 case STT_FILE:
495 if (symname)
496 compiland = symt_new_compiland(module, symp->st_value,
497 source_new(module, NULL, symname));
498 else
499 compiland = NULL;
500 continue;
501 case STT_NOTYPE:
502 /* we are only interested in wine markers inserted by winebuild */
503 for (j = 0; thunks[j].symname; j++)
504 {
505 if (!strcmp(symname, thunks[j].symname))
506 {
507 thunks[j].rva_start = symp->st_value;
508 thunks[j].rva_end = symp->st_value + symp->st_size;
509 break;
510 }
511 }
512 continue;
513 }
514
515 /* FIXME: we don't need to handle them (GCC internals)
516 * Moreover, they screw up our symbol lookup :-/
517 */
518 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
519 continue;
520
521 ste = pool_alloc(pool, sizeof(*ste));
522 ste->ht_elt.name = symname;
523 /* GCC emits, in some cases, a .<digit>+ suffix.
524 * This is used for static variable inside functions, so
525 * that we can have several such variables with same name in
526 * the same compilation unit
527 * We simply ignore that suffix when present (we also get rid
528 * of it in stabs parsing)
529 */
530 ptr = symname + strlen(symname) - 1;
531 if (isdigit(*ptr))
532 {
533 while (isdigit(*ptr) && ptr >= symname) ptr--;
534 if (ptr > symname && *ptr == '.')
535 {
536 char* n = pool_alloc(pool, ptr - symname + 1);
537 memcpy(n, symname, ptr - symname + 1);
538 n[ptr - symname] = '\0';
539 ste->ht_elt.name = n;
540 }
541 }
542 ste->symp = symp;
543 ste->compiland = compiland;
544 ste->used = 0;
545 hash_table_add(ht_symtab, &ste->ht_elt);
546 }
547 /* as we added in the ht_symtab pointers to the symbols themselves,
548 * we cannot unmap yet the sections, it will be done when we're over
549 * with this ELF file
550 */
551 }
552
553 /******************************************************************
554 * elf_lookup_symtab
555 *
556 * lookup a symbol by name in our internal hash table for the symtab
557 */
558 static const Elf_Sym* elf_lookup_symtab(const struct module* module,
559 const struct hash_table* ht_symtab,
560 const char* name, const struct symt* compiland)
561 {
562 struct symtab_elt* weak_result = NULL; /* without compiland name */
563 struct symtab_elt* result = NULL;
564 struct hash_table_iter hti;
565 struct symtab_elt* ste;
566 const char* compiland_name;
567 const char* compiland_basename;
568 const char* base;
569
570 /* we need weak match up (at least) when symbols of same name,
571 * defined several times in different compilation units,
572 * are merged in a single one (hence a different filename for c.u.)
573 */
574 if (compiland)
575 {
576 compiland_name = source_get(module,
577 ((const struct symt_compiland*)compiland)->source);
578 compiland_basename = strrchr(compiland_name, '/');
579 if (!compiland_basename++) compiland_basename = compiland_name;
580 }
581 else compiland_name = compiland_basename = NULL;
582
583 hash_table_iter_init(ht_symtab, &hti, name);
584 while ((ste = hash_table_iter_up(&hti)))
585 {
586 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
587
588 weak_result = ste;
589 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
590 continue;
591 if (ste->compiland && compiland_name)
592 {
593 const char* filename = source_get(module, ste->compiland->source);
594 if (strcmp(filename, compiland_name))
595 {
596 base = strrchr(filename, '/');
597 if (!base++) base = filename;
598 if (strcmp(base, compiland_basename)) continue;
599 }
600 }
601 if (result)
602 {
603 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
604 name, compiland_name,
605 source_get(module, result->compiland->source), (unsigned int)result->symp->st_value,
606 source_get(module, ste->compiland->source), (unsigned int)ste->symp->st_value);
607 }
608 else
609 {
610 result = ste;
611 ste->used = 1;
612 }
613 }
614 if (!result && !(result = weak_result))
615 {
616 FIXME("Couldn't find symbol %s!%s in symtab\n",
617 debugstr_w(module->module.ModuleName), name);
618 return NULL;
619 }
620 return result->symp;
621 }
622
623 /******************************************************************
624 * elf_finish_stabs_info
625 *
626 * - get any relevant information (address & size) from the bits we got from the
627 * stabs debugging information
628 */
629 static void elf_finish_stabs_info(struct module* module, const struct hash_table* symtab)
630 {
631 struct hash_table_iter hti;
632 void* ptr;
633 struct symt_ht* sym;
634 const Elf_Sym* symp;
635 struct elf_module_info* elf_info = module->format_info[DFI_ELF]->u.elf_info;
636
637 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
638 while ((ptr = hash_table_iter_up(&hti)))
639 {
640 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
641 switch (sym->symt.tag)
642 {
643 case SymTagFunction:
644 if (((struct symt_function*)sym)->address != elf_info->elf_addr &&
645 ((struct symt_function*)sym)->size)
646 {
647 break;
648 }
649 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
650 ((struct symt_function*)sym)->container);
651 if (symp)
652 {
653 if (((struct symt_function*)sym)->address != elf_info->elf_addr &&
654 ((struct symt_function*)sym)->address != elf_info->elf_addr + symp->st_value)
655 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
656 sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name,
657 ((struct symt_function*)sym)->address, elf_info->elf_addr + symp->st_value);
658 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
659 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
660 sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name,
661 ((struct symt_function*)sym)->size, (unsigned int)symp->st_size);
662
663 ((struct symt_function*)sym)->address = elf_info->elf_addr + symp->st_value;
664 ((struct symt_function*)sym)->size = symp->st_size;
665 } else
666 FIXME("Couldn't find %s!%s\n",
667 debugstr_w(module->module.ModuleName), sym->hash_elt.name);
668 break;
669 case SymTagData:
670 switch (((struct symt_data*)sym)->kind)
671 {
672 case DataIsGlobal:
673 case DataIsFileStatic:
674 if (((struct symt_data*)sym)->u.var.kind != loc_absolute ||
675 ((struct symt_data*)sym)->u.var.offset != elf_info->elf_addr)
676 break;
677 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
678 ((struct symt_data*)sym)->container);
679 if (symp)
680 {
681 if (((struct symt_data*)sym)->u.var.offset != elf_info->elf_addr &&
682 ((struct symt_data*)sym)->u.var.offset != elf_info->elf_addr + symp->st_value)
683 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
684 sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name,
685 ((struct symt_function*)sym)->address, elf_info->elf_addr + symp->st_value);
686 ((struct symt_data*)sym)->u.var.offset = elf_info->elf_addr + symp->st_value;
687 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
688 DataIsFileStatic : DataIsGlobal;
689 } else
690 FIXME("Couldn't find %s!%s\n",
691 debugstr_w(module->module.ModuleName), sym->hash_elt.name);
692 break;
693 default:;
694 }
695 break;
696 default:
697 FIXME("Unsupported tag %u\n", sym->symt.tag);
698 break;
699 }
700 }
701 /* since we may have changed some addresses & sizes, mark the module to be resorted */
702 module->sortlist_valid = FALSE;
703 }
704
705 /******************************************************************
706 * elf_load_wine_thunks
707 *
708 * creating the thunk objects for a wine native DLL
709 */
710 static int elf_new_wine_thunks(struct module* module, const struct hash_table* ht_symtab,
711 const struct elf_thunk_area* thunks)
712 {
713 int j;
714 struct hash_table_iter hti;
715 struct symtab_elt* ste;
716 DWORD_PTR addr;
717 struct symt_ht* symt;
718
719 hash_table_iter_init(ht_symtab, &hti, NULL);
720 while ((ste = hash_table_iter_up(&hti)))
721 {
722 if (ste->used) continue;
723
724 addr = module->reloc_delta + ste->symp->st_value;
725
726 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
727 if (j >= 0) /* thunk found */
728 {
729 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
730 addr, ste->symp->st_size);
731 }
732 else
733 {
734 ULONG64 ref_addr;
735 struct location loc;
736
737 symt = symt_find_nearest(module, addr);
738 if (symt && !symt_get_address(&symt->symt, &ref_addr))
739 ref_addr = addr;
740 if (!symt || addr != ref_addr)
741 {
742 /* creating public symbols for all the ELF symbols which haven't been
743 * used yet (ie we have no debug information on them)
744 * That's the case, for example, of the .spec.c files
745 */
746 switch (ELF32_ST_TYPE(ste->symp->st_info))
747 {
748 case STT_FUNC:
749 symt_new_function(module, ste->compiland, ste->ht_elt.name,
750 addr, ste->symp->st_size, NULL);
751 break;
752 case STT_OBJECT:
753 loc.kind = loc_absolute;
754 loc.reg = 0;
755 loc.offset = addr;
756 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
757 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
758 loc, ste->symp->st_size, NULL);
759 break;
760 default:
761 FIXME("Shouldn't happen\n");
762 break;
763 }
764 /* FIXME: this is a hack !!!
765 * we are adding new symbols, but as we're parsing a symbol table
766 * (hopefully without duplicate symbols) we delay rebuilding the sorted
767 * module table until we're done with the symbol table
768 * Otherwise, as we intertwine symbols' add and lookup, performance
769 * is rather bad
770 */
771 module->sortlist_valid = TRUE;
772 }
773 }
774 }
775 /* see comment above */
776 module->sortlist_valid = FALSE;
777 return TRUE;
778 }
779
780 /******************************************************************
781 * elf_new_public_symbols
782 *
783 * Creates a set of public symbols from an ELF symtab
784 */
785 static int elf_new_public_symbols(struct module* module, const struct hash_table* symtab)
786 {
787 struct hash_table_iter hti;
788 struct symtab_elt* ste;
789
790 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
791
792 /* FIXME: we're missing the ELF entry point here */
793
794 hash_table_iter_init(symtab, &hti, NULL);
795 while ((ste = hash_table_iter_up(&hti)))
796 {
797 symt_new_public(module, ste->compiland, ste->ht_elt.name,
798 module->reloc_delta + ste->symp->st_value,
799 ste->symp->st_size);
800 }
801 return TRUE;
802 }
803
804 static BOOL elf_check_debug_link(const WCHAR* file, struct image_file_map* fmap, DWORD crc)
805 {
806 BOOL ret;
807 struct elf_map_file_data emfd;
808
809 emfd.kind = from_file;
810 emfd.u.file.filename = file;
811 if (!elf_map_file(&emfd, fmap)) return FALSE;
812 if (!(ret = crc == calc_crc32(fmap->u.elf.fd)))
813 {
814 WARN("Bad CRC for file %s (got %08x while expecting %08x)\n",
815 debugstr_w(file), calc_crc32(fmap->u.elf.fd), crc);
816 elf_unmap_file(fmap);
817 }
818 return ret;
819 }
820
821 /******************************************************************
822 * elf_locate_debug_link
823 *
824 * Locate a filename from a .gnu_debuglink section, using the same
825 * strategy as gdb:
826 * "If the full name of the directory containing the executable is
827 * execdir, and the executable has a debug link that specifies the
828 * name debugfile, then GDB will automatically search for the
829 * debugging information file in three places:
830 * - the directory containing the executable file (that is, it
831 * will look for a file named `execdir/debugfile',
832 * - a subdirectory of that directory named `.debug' (that is, the
833 * file `execdir/.debug/debugfile', and
834 * - a subdirectory of the global debug file directory that includes
835 * the executable's full path, and the name from the link (that is,
836 * the file `globaldebugdir/execdir/debugfile', where globaldebugdir
837 * is the global debug file directory, and execdir has been turned
838 * into a relative path)." (from GDB manual)
839 */
840 static BOOL elf_locate_debug_link(struct image_file_map* fmap, const char* filename,
841 const WCHAR* loaded_file, DWORD crc)
842 {
843 static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
844 static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'};
845 const size_t globalDebugDirLen = sizeof(globalDebugDirW) / sizeof(WCHAR);
846 size_t filename_len;
847 WCHAR* p = NULL;
848 WCHAR* slash;
849 struct image_file_map* fmap_link = NULL;
850
851 fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
852 if (!fmap_link) return FALSE;
853
854 filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0);
855 p = HeapAlloc(GetProcessHeap(), 0,
856 (globalDebugDirLen + strlenW(loaded_file) + 6 + 1 + filename_len + 1) * sizeof(WCHAR));
857 if (!p) goto found;
858
859 /* we prebuild the string with "execdir" */
860 strcpyW(p, loaded_file);
861 slash = strrchrW(p, '/');
862 if (slash == NULL) slash = p; else slash++;
863
864 /* testing execdir/filename */
865 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
866 if (elf_check_debug_link(p, fmap_link, crc)) goto found;
867
868 /* testing execdir/.debug/filename */
869 memcpy(slash, dotDebugW, sizeof(dotDebugW));
870 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + sizeof(dotDebugW) / sizeof(WCHAR), filename_len);
871 if (elf_check_debug_link(p, fmap_link, crc)) goto found;
872
873 /* testing globaldebugdir/execdir/filename */
874 memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR));
875 memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR));
876 slash += globalDebugDirLen;
877 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
878 if (elf_check_debug_link(p, fmap_link, crc)) goto found;
879
880 /* finally testing filename */
881 if (elf_check_debug_link(slash, fmap_link, crc)) goto found;
882
883
884 WARN("Couldn't locate or map %s\n", filename);
885 HeapFree(GetProcessHeap(), 0, p);
886 HeapFree(GetProcessHeap(), 0, fmap_link);
887 return FALSE;
888
889 found:
890 TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p));
891 HeapFree(GetProcessHeap(), 0, p);
892 fmap->u.elf.alternate = fmap_link;
893 return TRUE;
894 }
895
896 /******************************************************************
897 * elf_locate_build_id_target
898 *
899 * Try to find the .so file containing the debug info out of the build-id note information
900 */
901 static BOOL elf_locate_build_id_target(struct image_file_map* fmap, const BYTE* id, unsigned idlen)
902 {
903 static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
904 static const WCHAR buildidW[] = {'.','b','u','i','l','d','-','i','d','/'};
905 static const WCHAR dotDebug0W[] = {'.','d','e','b','u','g',0};
906 struct image_file_map* fmap_link = NULL;
907 WCHAR* p;
908 WCHAR* z;
909 const BYTE* idend = id + idlen;
910 struct elf_map_file_data emfd;
911
912 fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
913 if (!fmap_link) return FALSE;
914
915 p = HeapAlloc(GetProcessHeap(), 0,
916 sizeof(globalDebugDirW) + sizeof(buildidW) +
917 (idlen * 2 + 1) * sizeof(WCHAR) + sizeof(dotDebug0W));
918 z = p;
919 memcpy(z, globalDebugDirW, sizeof(globalDebugDirW));
920 z += sizeof(globalDebugDirW) / sizeof(WCHAR);
921 memcpy(z, buildidW, sizeof(buildidW));
922 z += sizeof(buildidW) / sizeof(WCHAR);
923
924 if (id < idend)
925 {
926 *z++ = "0123456789abcdef"[*id >> 4 ];
927 *z++ = "0123456789abcdef"[*id & 0x0F];
928 id++;
929 }
930 if (id < idend)
931 *z++ = '/';
932 while (id < idend)
933 {
934 *z++ = "0123456789abcdef"[*id >> 4 ];
935 *z++ = "0123456789abcdef"[*id & 0x0F];
936 id++;
937 }
938 memcpy(z, dotDebug0W, sizeof(dotDebug0W));
939 TRACE("checking %s\n", wine_dbgstr_w(p));
940
941 emfd.kind = from_file;
942 emfd.u.file.filename = p;
943 if (elf_map_file(&emfd, fmap_link))
944 {
945 struct image_section_map buildid_sect;
946 if (elf_find_section(fmap_link, ".note.gnu.build-id", SHT_NULL, &buildid_sect))
947 {
948 const uint32_t* note;
949
950 note = (const uint32_t*)image_map_section(&buildid_sect);
951 if (note != IMAGE_NO_MAP)
952 {
953 /* the usual ELF note structure: name-size desc-size type <name> <desc> */
954 if (note[2] == NT_GNU_BUILD_ID)
955 {
956 if (note[1] == idlen &&
957 !memcmp(note + 3 + ((note[0] + 3) >> 2), idend - idlen, idlen))
958 {
959 TRACE("Located debug information file at %s\n", debugstr_w(p));
960 HeapFree(GetProcessHeap(), 0, p);
961 fmap->u.elf.alternate = fmap_link;
962 return TRUE;
963 }
964 WARN("mismatch in buildid information for %s\n", wine_dbgstr_w(p));
965 }
966 }
967 image_unmap_section(&buildid_sect);
968 }
969 elf_unmap_file(fmap_link);
970 }
971
972 TRACE("not found\n");
973 HeapFree(GetProcessHeap(), 0, p);
974 HeapFree(GetProcessHeap(), 0, fmap_link);
975 return FALSE;
976 }
977
978 /******************************************************************
979 * elf_check_alternate
980 *
981 * Load alternate files for a given ELF file, looking at either .note.gnu_build-id
982 * or .gnu_debuglink sections.
983 */
984 static BOOL elf_check_alternate(struct image_file_map* fmap, const struct module* module)
985 {
986 BOOL ret = FALSE;
987 BOOL found = FALSE;
988 struct image_section_map buildid_sect, debuglink_sect;
989
990 /* if present, add the .gnu_debuglink file as an alternate to current one */
991 if (elf_find_section(fmap, ".note.gnu.build-id", SHT_NULL, &buildid_sect))
992 {
993 const uint32_t* note;
994
995 found = TRUE;
996 note = (const uint32_t*)image_map_section(&buildid_sect);
997 if (note != IMAGE_NO_MAP)
998 {
999 /* the usual ELF note structure: name-size desc-size type <name> <desc> */
1000 if (note[2] == NT_GNU_BUILD_ID)
1001 {
1002 ret = elf_locate_build_id_target(fmap, (const BYTE*)(note + 3 + ((note[0] + 3) >> 2)), note[1]);
1003 }
1004 }
1005 image_unmap_section(&buildid_sect);
1006 }
1007 /* if present, add the .gnu_debuglink file as an alternate to current one */
1008 if (!ret && elf_find_section(fmap, ".gnu_debuglink", SHT_NULL, &debuglink_sect))
1009 {
1010 const char* dbg_link;
1011
1012 found = TRUE;
1013 dbg_link = (const char*)image_map_section(&debuglink_sect);
1014 if (dbg_link != IMAGE_NO_MAP)
1015 {
1016 /* The content of a debug link section is:
1017 * 1/ a NULL terminated string, containing the file name for the
1018 * debug info
1019 * 2/ padding on 4 byte boundary
1020 * 3/ CRC of the linked ELF file
1021 */
1022 DWORD crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
1023 ret = elf_locate_debug_link(fmap, dbg_link, module->module.LoadedImageName, crc);
1024 if (!ret)
1025 WARN("Couldn't load linked debug file for %s\n",
1026 debugstr_w(module->module.ModuleName));
1027 }
1028 image_unmap_section(&debuglink_sect);
1029 }
1030 return found ? ret : TRUE;
1031 }
1032
1033 /******************************************************************
1034 * elf_load_debug_info_from_map
1035 *
1036 * Loads the symbolic information from ELF module which mapping is described
1037 * in fmap
1038 * the module has been loaded at 'load_offset' address, so symbols' address
1039 * relocation is performed.
1040 * CRC is checked if fmap->with_crc is TRUE
1041 * returns
1042 * 0 if the file doesn't contain symbolic info (or this info cannot be
1043 * read or parsed)
1044 * 1 on success
1045 */
1046 static BOOL elf_load_debug_info_from_map(struct module* module,
1047 struct image_file_map* fmap,
1048 struct pool* pool,
1049 struct hash_table* ht_symtab)
1050 {
1051 BOOL ret = FALSE, lret;
1052 struct elf_thunk_area thunks[] =
1053 {
1054 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
1055 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
1056 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
1057 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
1058 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
1059 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
1060 {NULL, 0, 0, 0}
1061 };
1062
1063 module->module.SymType = SymExport;
1064
1065 /* create a hash table for the symtab */
1066 elf_hash_symtab(module, pool, ht_symtab, fmap, thunks);
1067
1068 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1069 {
1070 struct image_section_map stab_sect, stabstr_sect;
1071
1072 /* check if we need an alternate file (from debuglink or build-id) */
1073 ret = elf_check_alternate(fmap, module);
1074
1075 if (elf_find_section(fmap, ".stab", SHT_NULL, &stab_sect) &&
1076 elf_find_section(fmap, ".stabstr", SHT_NULL, &stabstr_sect))
1077 {
1078 const char* stab;
1079 const char* stabstr;
1080
1081 stab = image_map_section(&stab_sect);
1082 stabstr = image_map_section(&stabstr_sect);
1083 if (stab != IMAGE_NO_MAP && stabstr != IMAGE_NO_MAP)
1084 {
1085 /* OK, now just parse all of the stabs. */
1086 lret = stabs_parse(module, module->format_info[DFI_ELF]->u.elf_info->elf_addr,
1087 stab, image_get_map_size(&stab_sect),
1088 stabstr, image_get_map_size(&stabstr_sect),
1089 NULL, NULL);
1090 if (lret)
1091 /* and fill in the missing information for stabs */
1092 elf_finish_stabs_info(module, ht_symtab);
1093 else
1094 WARN("Couldn't correctly read stabs\n");
1095 ret = ret || lret;
1096 }
1097 image_unmap_section(&stab_sect);
1098 image_unmap_section(&stabstr_sect);
1099 }
1100 lret = dwarf2_parse(module, module->reloc_delta, thunks, fmap);
1101 ret = ret || lret;
1102 }
1103 if (strstrW(module->module.ModuleName, S_ElfW) ||
1104 !strcmpW(module->module.ModuleName, S_WineLoaderW))
1105 {
1106 /* add the thunks for native libraries */
1107 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1108 elf_new_wine_thunks(module, ht_symtab, thunks);
1109 }
1110 /* add all the public symbols from symtab */
1111 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
1112
1113 return ret;
1114 }
1115
1116 /******************************************************************
1117 * elf_load_debug_info
1118 *
1119 * Loads ELF debugging information from the module image file.
1120 */
1121 BOOL elf_load_debug_info(struct module* module)
1122 {
1123 BOOL ret = TRUE;
1124 struct pool pool;
1125 struct hash_table ht_symtab;
1126 struct module_format* modfmt;
1127
1128 if (module->type != DMT_ELF || !(modfmt = module->format_info[DFI_ELF]) || !modfmt->u.elf_info)
1129 {
1130 ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName));
1131 return FALSE;
1132 }
1133
1134 pool_init(&pool, 65536);
1135 hash_table_init(&pool, &ht_symtab, 256);
1136
1137 ret = elf_load_debug_info_from_map(module, &modfmt->u.elf_info->file_map, &pool, &ht_symtab);
1138
1139 pool_destroy(&pool);
1140 return ret;
1141 }
1142
1143 /******************************************************************
1144 * elf_fetch_file_info
1145 *
1146 * Gathers some more information for an ELF module from a given file
1147 */
1148 BOOL elf_fetch_file_info(const WCHAR* name, DWORD_PTR* base,
1149 DWORD* size, DWORD* checksum)
1150 {
1151 struct image_file_map fmap;
1152
1153 struct elf_map_file_data emfd;
1154
1155 emfd.kind = from_file;
1156 emfd.u.file.filename = name;
1157 if (!elf_map_file(&emfd, &fmap)) return FALSE;
1158 if (base) *base = fmap.u.elf.elf_start;
1159 *size = fmap.u.elf.elf_size;
1160 *checksum = calc_crc32(fmap.u.elf.fd);
1161 elf_unmap_file(&fmap);
1162 return TRUE;
1163 }
1164
1165 static BOOL elf_load_file_from_fmap(struct process* pcs, const WCHAR* filename,
1166 struct image_file_map* fmap, unsigned long load_offset,
1167 unsigned long dyn_addr, struct elf_info* elf_info)
1168 {
1169 BOOL ret = FALSE;
1170
1171 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1172 {
1173 struct image_section_map ism;
1174
1175 if (elf_find_section(fmap, ".dynamic", SHT_DYNAMIC, &ism))
1176 {
1177 Elf_Dyn dyn;
1178 char* ptr = (char*)fmap->u.elf.sect[ism.sidx].shdr.sh_addr;
1179 unsigned long len;
1180
1181 do
1182 {
1183 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1184 len != sizeof(dyn))
1185 return ret;
1186 if (dyn.d_tag == DT_DEBUG)
1187 {
1188 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1189 if (load_offset == 0 && dyn_addr == 0) /* likely the case */
1190 /* Assume this module (the Wine loader) has been loaded at its preferred address */
1191 dyn_addr = ism.fmap->u.elf.sect[ism.sidx].shdr.sh_addr;
1192 break;
1193 }
1194 ptr += sizeof(dyn);
1195 } while (dyn.d_tag != DT_NULL);
1196 if (dyn.d_tag == DT_NULL) return ret;
1197 }
1198 elf_end_find(fmap);
1199 }
1200
1201 if (elf_info->flags & ELF_INFO_MODULE)
1202 {
1203 struct elf_module_info *elf_module_info;
1204 struct module_format* modfmt;
1205 struct image_section_map ism;
1206 unsigned long modbase = load_offset;
1207
1208 if (elf_find_section(fmap, ".dynamic", SHT_DYNAMIC, &ism))
1209 {
1210 unsigned long rva_dyn = elf_get_map_rva(&ism);
1211
1212 TRACE("For module %s, got ELF (start=%lx dyn=%lx), link_map (start=%lx dyn=%lx)\n",
1213 debugstr_w(filename), (unsigned long)fmap->u.elf.elf_start, rva_dyn,
1214 load_offset, dyn_addr);
1215 if (dyn_addr && load_offset + rva_dyn != dyn_addr)
1216 {
1217 WARN("\thave to relocate: %lx\n", dyn_addr - rva_dyn);
1218 modbase = dyn_addr - rva_dyn;
1219 }
1220 } else WARN("For module %s, no .dynamic section\n", debugstr_w(filename));
1221 elf_end_find(fmap);
1222
1223 modfmt = HeapAlloc(GetProcessHeap(), 0,
1224 sizeof(struct module_format) + sizeof(struct elf_module_info));
1225 if (!modfmt) return FALSE;
1226 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE, modbase,
1227 fmap->u.elf.elf_size, 0, calc_crc32(fmap->u.elf.fd));
1228 if (!elf_info->module)
1229 {
1230 HeapFree(GetProcessHeap(), 0, modfmt);
1231 return FALSE;
1232 }
1233 elf_info->module->reloc_delta = elf_info->module->module.BaseOfImage - fmap->u.elf.elf_start;
1234 elf_module_info = (void*)(modfmt + 1);
1235 elf_info->module->format_info[DFI_ELF] = modfmt;
1236 modfmt->module = elf_info->module;
1237 modfmt->remove = elf_module_remove;
1238 modfmt->loc_compute = NULL;
1239 modfmt->u.elf_info = elf_module_info;
1240
1241 elf_module_info->elf_addr = load_offset;
1242
1243 elf_module_info->file_map = *fmap;
1244 elf_reset_file_map(fmap);
1245 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1246 {
1247 elf_info->module->module.SymType = SymDeferred;
1248 ret = TRUE;
1249 }
1250 else ret = elf_load_debug_info(elf_info->module);
1251
1252 elf_module_info->elf_mark = 1;
1253 elf_module_info->elf_loader = 0;
1254 } else ret = TRUE;
1255
1256 if (elf_info->flags & ELF_INFO_NAME)
1257 {
1258 WCHAR* ptr;
1259 ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
1260 if (ptr)
1261 {
1262 strcpyW(ptr, filename);
1263 elf_info->module_name = ptr;
1264 }
1265 else ret = FALSE;
1266 }
1267
1268 return ret;
1269 }
1270
1271 /******************************************************************
1272 * elf_load_file
1273 *
1274 * Loads the information for ELF module stored in 'filename'
1275 * the module has been loaded at 'load_offset' address
1276 * returns
1277 * -1 if the file cannot be found/opened
1278 * 0 if the file doesn't contain symbolic info (or this info cannot be
1279 * read or parsed)
1280 * 1 on success
1281 */
1282 static BOOL elf_load_file(struct process* pcs, const WCHAR* filename,
1283 unsigned long load_offset, unsigned long dyn_addr,
1284 struct elf_info* elf_info)
1285 {
1286 BOOL ret = FALSE;
1287 struct image_file_map fmap;
1288 struct elf_map_file_data emfd;
1289
1290 TRACE("Processing elf file '%s' at %08lx\n", debugstr_w(filename), load_offset);
1291
1292 emfd.kind = from_file;
1293 emfd.u.file.filename = filename;
1294 if (!elf_map_file(&emfd, &fmap)) return ret;
1295
1296 /* Next, we need to find a few of the internal ELF headers within
1297 * this thing. We need the main executable header, and the section
1298 * table.
1299 */
1300 if (!fmap.u.elf.elf_start && !load_offset)
1301 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1302 debugstr_w(filename));
1303
1304 ret = elf_load_file_from_fmap(pcs, filename, &fmap, load_offset, dyn_addr, elf_info);
1305
1306 elf_unmap_file(&fmap);
1307
1308 return ret;
1309 }
1310
1311 /******************************************************************
1312 * elf_load_file_from_path
1313 * tries to load an ELF file from a set of paths (separated by ':')
1314 */
1315 static BOOL elf_load_file_from_path(HANDLE hProcess,
1316 const WCHAR* filename,
1317 unsigned long load_offset,
1318 unsigned long dyn_addr,
1319 const char* path,
1320 struct elf_info* elf_info)
1321 {
1322 BOOL ret = FALSE;
1323 WCHAR *s, *t, *fn;
1324 WCHAR* pathW = NULL;
1325 unsigned len;
1326
1327 if (!path) return FALSE;
1328
1329 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1330 pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1331 if (!pathW) return FALSE;
1332 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, pathW, len);
1333
1334 for (s = pathW; s && *s; s = (t) ? (t+1) : NULL)
1335 {
1336 t = strchrW(s, ':');
1337 if (t) *t = '\0';
1338 fn = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1 + lstrlenW(s) + 1) * sizeof(WCHAR));
1339 if (!fn) break;
1340 strcpyW(fn, s);
1341 strcatW(fn, S_SlashW);
1342 strcatW(fn, filename);
1343 ret = elf_load_file(hProcess, fn, load_offset, dyn_addr, elf_info);
1344 HeapFree(GetProcessHeap(), 0, fn);
1345 if (ret) break;
1346 }
1347
1348 HeapFree(GetProcessHeap(), 0, pathW);
1349 return ret;
1350 }
1351
1352 /******************************************************************
1353 * elf_load_file_from_dll_path
1354 *
1355 * Tries to load an ELF file from the dll path
1356 */
1357 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1358 const WCHAR* filename,
1359 unsigned long load_offset,
1360 unsigned long dyn_addr,
1361 struct elf_info* elf_info)
1362 {
1363 BOOL ret = FALSE;
1364 unsigned int index = 0;
1365 const char *path;
1366
1367 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1368 {
1369 WCHAR *name;
1370 unsigned len;
1371
1372 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1373
1374 name = HeapAlloc( GetProcessHeap(), 0,
1375 (len + lstrlenW(filename) + 2) * sizeof(WCHAR) );
1376
1377 if (!name) break;
1378 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, name, len);
1379 strcatW( name, S_SlashW );
1380 strcatW( name, filename );
1381 ret = elf_load_file(hProcess, name, load_offset, dyn_addr, elf_info);
1382 HeapFree( GetProcessHeap(), 0, name );
1383 }
1384 return ret;
1385 }
1386
1387 #ifdef AT_SYSINFO_EHDR
1388 /******************************************************************
1389 * elf_search_auxv
1390 *
1391 * locate some a value from the debuggee auxiliary vector
1392 */
1393 static BOOL elf_search_auxv(const struct process* pcs, unsigned type, unsigned long* val)
1394 {
1395 char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
1396 SYMBOL_INFO*si = (SYMBOL_INFO*)buffer;
1397 void* addr;
1398 void* str;
1399 void* str_max;
1400 Elf_auxv_t auxv;
1401
1402 si->SizeOfStruct = sizeof(*si);
1403 si->MaxNameLen = MAX_SYM_NAME;
1404 if (!SymFromName(pcs->handle, "libwine.so.1!__wine_main_environ", si) ||
1405 !(addr = (void*)(DWORD_PTR)si->Address) ||
1406 !ReadProcessMemory(pcs->handle, addr, &addr, sizeof(addr), NULL) ||
1407 !addr)
1408 {
1409 FIXME("can't find symbol in module\n");
1410 return FALSE;
1411 }
1412 /* walk through envp[] */
1413 /* envp[] strings are located after the auxiliary vector, so protect the walk */
1414 str_max = (void*)(DWORD_PTR)~0L;
1415 while (ReadProcessMemory(pcs->handle, addr, &str, sizeof(str), NULL) &&
1416 (addr = (void*)((DWORD_PTR)addr + sizeof(str))) != NULL && str != NULL)
1417 str_max = min(str_max, str);
1418
1419 /* Walk through the end of envp[] array.
1420 * Actually, there can be several NULLs at the end of envp[]. This happens when an env variable is
1421 * deleted, the last entry is replaced by an extra NULL.
1422 */
1423 while (addr < str_max && ReadProcessMemory(pcs->handle, addr, &str, sizeof(str), NULL) && str == NULL)
1424 addr = (void*)((DWORD_PTR)addr + sizeof(str));
1425
1426 while (ReadProcessMemory(pcs->handle, addr, &auxv, sizeof(auxv), NULL) && auxv.a_type != AT_NULL)
1427 {
1428 if (auxv.a_type == type)
1429 {
1430 *val = auxv.a_un.a_val;
1431 return TRUE;
1432 }
1433 addr = (void*)((DWORD_PTR)addr + sizeof(auxv));
1434 }
1435
1436 return FALSE;
1437 }
1438 #endif
1439
1440 /******************************************************************
1441 * elf_search_and_load_file
1442 *
1443 * lookup a file in standard ELF locations, and if found, load it
1444 */
1445 static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename,
1446 unsigned long load_offset, unsigned long dyn_addr,
1447 struct elf_info* elf_info)
1448 {
1449 BOOL ret = FALSE;
1450 struct module* module;
1451 static WCHAR S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'};
1452
1453 if (filename == NULL || *filename == '\0') return FALSE;
1454 if ((module = module_is_already_loaded(pcs, filename)))
1455 {
1456 elf_info->module = module;
1457 elf_info->module->format_info[DFI_ELF]->u.elf_info->elf_mark = 1;
1458 return module->module.SymType;
1459 }
1460
1461 if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */
1462 ret = elf_load_file(pcs, filename, load_offset, dyn_addr, elf_info);
1463 /* if relative pathname, try some absolute base dirs */
1464 if (!ret && !strchrW(filename, '/'))
1465 {
1466 ret = elf_load_file_from_path(pcs, filename, load_offset, dyn_addr,
1467 getenv("PATH"), elf_info) ||
1468 elf_load_file_from_path(pcs, filename, load_offset, dyn_addr,
1469 getenv("LD_LIBRARY_PATH"), elf_info);
1470 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename,
1471 load_offset, dyn_addr, elf_info);
1472 }
1473
1474 return ret;
1475 }
1476
1477 typedef BOOL (*enum_elf_modules_cb)(const WCHAR*, unsigned long load_addr,
1478 unsigned long dyn_addr, BOOL is_system, void* user);
1479
1480 /******************************************************************
1481 * elf_enum_modules_internal
1482 *
1483 * Enumerate ELF modules from a running process
1484 */
1485 static BOOL elf_enum_modules_internal(const struct process* pcs,
1486 const WCHAR* main_name,
1487 enum_elf_modules_cb cb, void* user)
1488 {
1489 struct r_debug dbg_hdr;
1490 void* lm_addr;
1491 struct link_map lm;
1492 char bufstr[256];
1493 WCHAR bufstrW[MAX_PATH];
1494
1495 if (!pcs->dbg_hdr_addr ||
1496 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1497 &dbg_hdr, sizeof(dbg_hdr), NULL))
1498 return FALSE;
1499
1500 /* Now walk the linked list. In all known ELF implementations,
1501 * the dynamic loader maintains this linked list for us. In some
1502 * cases the first entry doesn't appear with a name, in other cases it
1503 * does.
1504 */
1505 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1506 {
1507 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1508 return FALSE;
1509
1510 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1511 lm.l_name != NULL &&
1512 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1513 {
1514 bufstr[sizeof(bufstr) - 1] = '\0';
1515 MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR));
1516 if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
1517 if (!cb(bufstrW, (unsigned long)lm.l_addr, (unsigned long)lm.l_ld, FALSE, user)) break;
1518 }
1519 }
1520
1521 #ifdef AT_SYSINFO_EHDR
1522 if (!lm_addr)
1523 {
1524 unsigned long ehdr_addr;
1525
1526 if (elf_search_auxv(pcs, AT_SYSINFO_EHDR, &ehdr_addr))
1527 {
1528 static const WCHAR vdsoW[] = {'[','v','d','s','o',']','.','s','o',0};
1529 cb(vdsoW, ehdr_addr, 0, TRUE, user);
1530 }
1531 }
1532 #endif
1533 return TRUE;
1534 }
1535
1536 /******************************************************************
1537 * elf_search_loader
1538 *
1539 * Lookup in a running ELF process the loader, and sets its ELF link
1540 * address (for accessing the list of loaded .so libs) in pcs.
1541 * If flags is ELF_INFO_MODULE, the module for the loader is also
1542 * added as a module into pcs.
1543 */
1544 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1545 {
1546 return elf_search_and_load_file(pcs, get_wine_loader_name(), 0, 0, elf_info);
1547 }
1548
1549 /******************************************************************
1550 * elf_read_wine_loader_dbg_info
1551 *
1552 * Try to find a decent wine executable which could have loaded the debuggee
1553 */
1554 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1555 {
1556 struct elf_info elf_info;
1557
1558 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1559 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1560 elf_info.module->format_info[DFI_ELF]->u.elf_info->elf_loader = 1;
1561 module_set_module(elf_info.module, S_WineLoaderW);
1562 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1563 }
1564
1565 struct elf_enum_user
1566 {
1567 enum_modules_cb cb;
1568 void* user;
1569 };
1570
1571 static BOOL elf_enum_modules_translate(const WCHAR* name, unsigned long load_addr,
1572 unsigned long dyn_addr, BOOL is_system, void* user)
1573 {
1574 struct elf_enum_user* eeu = user;
1575 return eeu->cb(name, load_addr, eeu->user);
1576 }
1577
1578 /******************************************************************
1579 * elf_enum_modules
1580 *
1581 * Enumerates the ELF loaded modules from a running target (hProc)
1582 * This function doesn't require that someone has called SymInitialize
1583 * on this very process.
1584 */
1585 BOOL elf_enum_modules(HANDLE hProc, enum_modules_cb cb, void* user)
1586 {
1587 struct process pcs;
1588 struct elf_info elf_info;
1589 BOOL ret;
1590 struct elf_enum_user eeu;
1591
1592 memset(&pcs, 0, sizeof(pcs));
1593 pcs.handle = hProc;
1594 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1595 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1596 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1597 eeu.cb = cb;
1598 eeu.user = user;
1599 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, elf_enum_modules_translate, &eeu);
1600 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1601 return ret;
1602 }
1603
1604 struct elf_load
1605 {
1606 struct process* pcs;
1607 struct elf_info elf_info;
1608 const WCHAR* name;
1609 BOOL ret;
1610 };
1611
1612 /******************************************************************
1613 * elf_load_cb
1614 *
1615 * Callback for elf_load_module, used to walk the list of loaded
1616 * modules.
1617 */
1618 static BOOL elf_load_cb(const WCHAR* name, unsigned long load_addr,
1619 unsigned long dyn_addr, BOOL is_system, void* user)
1620 {
1621 struct elf_load* el = user;
1622 BOOL ret = TRUE;
1623 const WCHAR* p;
1624
1625 if (is_system) /* virtual ELF module, created by system. handle it from memory */
1626 {
1627 struct module* module;
1628 struct elf_map_file_data emfd;
1629 struct image_file_map fmap;
1630
1631 if ((module = module_is_already_loaded(el->pcs, name)))
1632 {
1633 el->elf_info.module = module;
1634 el->elf_info.module->format_info[DFI_ELF]->u.elf_info->elf_mark = 1;
1635 return module->module.SymType;
1636 }
1637
1638 emfd.kind = from_process;
1639 emfd.u.process.handle = el->pcs->handle;
1640 emfd.u.process.load_addr = (void*)load_addr;
1641
1642 if (elf_map_file(&emfd, &fmap))
1643 el->ret = elf_load_file_from_fmap(el->pcs, name, &fmap, load_addr, 0, &el->elf_info);
1644 return TRUE;
1645 }
1646 if (el->name)
1647 {
1648 /* memcmp is needed for matches when bufstr contains also version information
1649 * el->name: libc.so, name: libc.so.6.0
1650 */
1651 p = strrchrW(name, '/');
1652 if (!p++) p = name;
1653 }
1654
1655 if (!el->name || !memcmp(p, el->name, lstrlenW(el->name) * sizeof(WCHAR)))
1656 {
1657 el->ret = elf_search_and_load_file(el->pcs, name, load_addr, dyn_addr, &el->elf_info);
1658 if (el->name) ret = FALSE;
1659 }
1660
1661 return ret;
1662 }
1663
1664 /******************************************************************
1665 * elf_load_module
1666 *
1667 * loads an ELF module and stores it in process' module list
1668 * Also, find module real name and load address from
1669 * the real loaded modules list in pcs address space
1670 */
1671 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1672 {
1673 struct elf_load el;
1674
1675 TRACE("(%p %s %08lx)\n", pcs, debugstr_w(name), addr);
1676
1677 el.elf_info.flags = ELF_INFO_MODULE;
1678 el.ret = FALSE;
1679
1680 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1681 {
1682 el.pcs = pcs;
1683 /* do only the lookup from the filename, not the path (as we lookup module
1684 * name in the process' loaded module list)
1685 */
1686 el.name = strrchrW(name, '/');
1687 if (!el.name++) el.name = name;
1688 el.ret = FALSE;
1689
1690 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1691 return NULL;
1692 }
1693 else if (addr)
1694 {
1695 el.name = name;
1696 el.ret = elf_search_and_load_file(pcs, el.name, addr, 0, &el.elf_info);
1697 }
1698 if (!el.ret) return NULL;
1699 assert(el.elf_info.module);
1700 return el.elf_info.module;
1701 }
1702
1703 /******************************************************************
1704 * elf_synchronize_module_list
1705 *
1706 * this functions rescans the debuggee module's list and synchronizes it with
1707 * the one from 'pcs', ie:
1708 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1709 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1710 */
1711 BOOL elf_synchronize_module_list(struct process* pcs)
1712 {
1713 struct module* module;
1714 struct elf_load el;
1715
1716 for (module = pcs->lmodules; module; module = module->next)
1717 {
1718 if (module->type == DMT_ELF && !module->is_virtual)
1719 module->format_info[DFI_ELF]->u.elf_info->elf_mark = 0;
1720 }
1721
1722 el.pcs = pcs;
1723 el.elf_info.flags = ELF_INFO_MODULE;
1724 el.ret = FALSE;
1725 el.name = NULL; /* fetch all modules */
1726
1727 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1728 return FALSE;
1729
1730 module = pcs->lmodules;
1731 while (module)
1732 {
1733 if (module->type == DMT_ELF && !module->is_virtual)
1734 {
1735 struct elf_module_info* elf_info = module->format_info[DFI_ELF]->u.elf_info;
1736
1737 if (!elf_info->elf_mark && !elf_info->elf_loader)
1738 {
1739 module_remove(pcs, module);
1740 /* restart all over */
1741 module = pcs->lmodules;
1742 continue;
1743 }
1744 }
1745 module = module->next;
1746 }
1747 return TRUE;
1748 }
1749
1750 #else /* !__ELF__ */
1751
1752 BOOL elf_find_section(struct image_file_map* fmap, const char* name,
1753 unsigned sht, struct image_section_map* ism)
1754 {
1755 return FALSE;
1756 }
1757
1758 const char* elf_map_section(struct image_section_map* ism)
1759 {
1760 return NULL;
1761 }
1762
1763 void elf_unmap_section(struct image_section_map* ism)
1764 {}
1765
1766 unsigned elf_get_map_size(const struct image_section_map* ism)
1767 {
1768 return 0;
1769 }
1770
1771 DWORD_PTR elf_get_map_rva(const struct image_section_map* ism)
1772 {
1773 return 0;
1774 }
1775
1776 BOOL elf_synchronize_module_list(struct process* pcs)
1777 {
1778 return FALSE;
1779 }
1780
1781 BOOL elf_fetch_file_info(const WCHAR* name, DWORD_PTR* base,
1782 DWORD* size, DWORD* checksum)
1783 {
1784 return FALSE;
1785 }
1786
1787 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1788 {
1789 return FALSE;
1790 }
1791
1792 BOOL elf_enum_modules(HANDLE hProc, enum_modules_cb cb, void* user)
1793 {
1794 return FALSE;
1795 }
1796
1797 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1798 {
1799 return NULL;
1800 }
1801
1802 BOOL elf_load_debug_info(struct module* module)
1803 {
1804 return FALSE;
1805 }
1806
1807 int elf_is_in_thunk_area(unsigned long addr,
1808 const struct elf_thunk_area* thunks)
1809 {
1810 return -1;
1811 }
1812 #endif /* __ELF__ */
Maarten's multimedia branch