2 * File elf.c - processing of ELF files
4 * Copyright (C) 1996, Eric Youngdale.
5 * 1999-2004 Eric Pouech
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.
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.
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
23 #include "wine/port.h"
25 #if defined(__svr4__) || defined(__sun)
27 /* large files are not supported by libelf */
28 #undef _FILE_OFFSET_BITS
29 #define _FILE_OFFSET_BITS 32
35 #ifdef HAVE_SYS_STAT_H
36 # include <sys/stat.h>
39 #ifdef HAVE_SYS_MMAN_H
46 #define PATH_MAX MAX_PATH
49 #include "dbghelp_private.h"
54 #ifdef HAVE_SYS_ELF32_H
55 # include <sys/elf32.h>
57 #ifdef HAVE_SYS_EXEC_ELF_H
58 # include <sys/exec_elf.h>
61 # if defined(DT_COUNT)
62 # define DT_NUM DT_COUNT
64 /* this seems to be a satisfactory value on Solaris, which doesn't support this AFAICT */
71 #ifdef HAVE_SYS_LINK_H
72 # include <sys/link.h>
75 #include "wine/library.h"
76 #include "wine/debug.h"
78 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
80 struct elf_module_info
82 unsigned long elf_addr;
83 unsigned short elf_mark : 1,
89 #define ELF_INFO_DEBUG_HEADER 0x0001
90 #define ELF_INFO_MODULE 0x0002
91 #define ELF_INFO_NAME 0x0004
95 unsigned flags; /* IN one (or several) of the ELF_INFO constants */
96 unsigned long dbg_hdr_addr; /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
97 struct module* module; /* OUT loaded module (if ELF_INFO_MODULE is set) */
98 const char* module_name; /* OUT found module name (if ELF_INFO_NAME is set) */
101 /* structure holding information while handling an ELF image
102 * allows one by one section mapping for memory savings
121 struct hash_table_elt ht_elt;
122 const Elf32_Sym* symp;
123 struct symt_compiland* compiland;
127 struct elf_thunk_area
130 THUNK_ORDINAL ordinal;
131 unsigned long rva_start;
132 unsigned long rva_end;
135 /******************************************************************
138 * Maps a single section into memory from an ELF file
140 static const char* elf_map_section(struct elf_file_map* fmap, int sidx)
142 unsigned pgsz = getpagesize();
145 if (sidx < 0 || sidx >= fmap->elfhdr.e_shnum ||
146 fmap->sect[sidx].shdr.sh_type == SHT_NOBITS)
148 /* align required information on page size (we assume pagesize is a power of 2) */
149 ofst = fmap->sect[sidx].shdr.sh_offset & ~(pgsz - 1);
150 size = (fmap->sect[sidx].shdr.sh_offset +
151 fmap->sect[sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1);
152 fmap->sect[sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fmap->fd, ofst);
153 if (fmap->sect[sidx].mapped == ELF_NO_MAP) return ELF_NO_MAP;
154 return fmap->sect[sidx].mapped + (fmap->sect[sidx].shdr.sh_offset & (pgsz - 1));
157 /******************************************************************
160 * Unmaps a single section from memory
162 static void elf_unmap_section(struct elf_file_map* fmap, int sidx)
164 if (sidx >= 0 && sidx < fmap->elfhdr.e_shnum && fmap->sect[sidx].mapped != ELF_NO_MAP)
166 munmap((char*)fmap->sect[sidx].mapped, fmap->sect[sidx].shdr.sh_size);
167 fmap->sect[sidx].mapped = ELF_NO_MAP;
171 /******************************************************************
174 * Get the size of an ELF section
176 static inline unsigned elf_get_map_size(struct elf_file_map* fmap, int sidx)
178 if (sidx < 0 || sidx >= fmap->elfhdr.e_shnum)
180 return fmap->sect[sidx].shdr.sh_size;
183 /******************************************************************
186 * Maps an ELF file into memory (and checks it's a real ELF file)
188 static BOOL elf_map_file(const char* filename, struct elf_file_map* fmap)
190 static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
194 unsigned tmp, page_mask = getpagesize() - 1;
200 /* check that the file exists, and that the module hasn't been loaded yet */
201 if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) return FALSE;
203 /* Now open the file, so that we can mmap() it. */
204 if ((fmap->fd = open(filename, O_RDONLY)) == -1) return FALSE;
206 if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr))
208 /* and check for an ELF header */
209 if (memcmp(fmap->elfhdr.e_ident,
210 elf_signature, sizeof(elf_signature))) return FALSE;
212 fmap->sect = HeapAlloc(GetProcessHeap(), 0,
213 fmap->elfhdr.e_shnum * sizeof(fmap->sect[0]));
214 if (!fmap->sect) return FALSE;
216 lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET);
217 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
219 read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr));
220 fmap->sect[i].mapped = ELF_NO_MAP;
223 /* grab size of module once loaded in memory */
224 lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET);
226 fmap->elf_start = ~0L;
227 for (i = 0; i < fmap->elfhdr.e_phnum; i++)
229 if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) &&
230 phdr.p_type == PT_LOAD)
232 tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
233 if (fmap->elf_size < tmp) fmap->elf_size = tmp;
234 if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr;
237 /* if non relocatable ELF, then remove fixed address from computation
238 * otherwise, all addresses are zero based and start has no effect
240 fmap->elf_size -= fmap->elf_start;
244 /******************************************************************
247 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
249 static void elf_unmap_file(struct elf_file_map* fmap)
254 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
256 elf_unmap_section(fmap, i);
258 HeapFree(GetProcessHeap(), 0, fmap->sect);
263 /******************************************************************
264 * elf_is_in_thunk_area
266 * Check whether an address lies within one of the thunk area we
269 int elf_is_in_thunk_area(unsigned long addr,
270 const struct elf_thunk_area* thunks)
274 for (i = 0; thunks[i].symname; i++)
276 if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
282 /******************************************************************
285 * creating an internal hash table to ease use ELF symtab information lookup
287 static void elf_hash_symtab(struct module* module, struct pool* pool,
288 struct hash_table* ht_symtab, struct elf_file_map* fmap,
289 int symtab_idx, struct elf_thunk_area* thunks)
294 struct symt_compiland* compiland = NULL;
296 const Elf32_Sym* symp;
297 struct symtab_elt* ste;
299 symp = (const Elf32_Sym*)elf_map_section(fmap, symtab_idx);
300 strp = elf_map_section(fmap, fmap->sect[symtab_idx].shdr.sh_link);
301 if (symp == ELF_NO_MAP || strp == ELF_NO_MAP) return;
303 nsym = elf_get_map_size(fmap, symtab_idx) / sizeof(*symp);
305 for (j = 0; thunks[j].symname; j++)
306 thunks[j].rva_start = thunks[j].rva_end = 0;
308 for (i = 0; i < nsym; i++, symp++)
310 /* Ignore certain types of entries which really aren't of that much
313 if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE &&
314 ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
315 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
316 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
317 symp->st_shndx == SHN_UNDEF)
322 symname = strp + symp->st_name;
324 /* handle some specific symtab (that we'll throw away when done) */
325 switch (ELF32_ST_TYPE(symp->st_info))
329 compiland = symt_new_compiland(module, symp->st_value,
330 source_new(module, NULL, symname));
335 /* we are only interested in wine markers inserted by winebuild */
336 for (j = 0; thunks[j].symname; j++)
338 if (!strcmp(symname, thunks[j].symname))
340 thunks[j].rva_start = symp->st_value;
341 thunks[j].rva_end = symp->st_value + symp->st_size;
348 /* FIXME: we don't need to handle them (GCC internals)
349 * Moreover, they screw up our symbol lookup :-/
351 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
354 ste = pool_alloc(pool, sizeof(*ste));
355 ste->ht_elt.name = symname;
356 /* GCC emits, in some cases, a .<digit>+ suffix.
357 * This is used for static variable inside functions, so
358 * that we can have several such variables with same name in
359 * the same compilation unit
360 * We simply ignore that suffix when present (we also get rid
361 * of it in stabs parsing)
363 ptr = symname + strlen(symname) - 1;
366 while (isdigit(*ptr) && ptr >= symname) ptr--;
367 if (ptr > symname && *ptr == '.')
369 char* n = pool_alloc(pool, ptr - symname + 1);
370 memcpy(n, symname, ptr - symname + 1);
371 n[ptr - symname] = '\0';
372 ste->ht_elt.name = n;
376 ste->compiland = compiland;
378 hash_table_add(ht_symtab, &ste->ht_elt);
380 /* as we added in the ht_symtab pointers to the symbols themselves,
381 * we cannot unmap yet the sections, it will be done when we're over
386 /******************************************************************
389 * lookup a symbol by name in our internal hash table for the symtab
391 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
392 const struct hash_table* ht_symtab,
393 const char* name, struct symt* compiland)
395 struct symtab_elt* weak_result = NULL; /* without compiland name */
396 struct symtab_elt* result = NULL;
397 struct hash_table_iter hti;
398 struct symtab_elt* ste;
399 const char* compiland_name;
400 const char* compiland_basename;
403 /* we need weak match up (at least) when symbols of same name,
404 * defined several times in different compilation units,
405 * are merged in a single one (hence a different filename for c.u.)
409 compiland_name = source_get(module,
410 ((struct symt_compiland*)compiland)->source);
411 compiland_basename = strrchr(compiland_name, '/');
412 if (!compiland_basename++) compiland_basename = compiland_name;
414 else compiland_name = compiland_basename = NULL;
416 hash_table_iter_init(ht_symtab, &hti, name);
417 while ((ste = hash_table_iter_up(&hti)))
419 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
422 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
424 if (ste->compiland && compiland_name)
426 const char* filename = source_get(module, ste->compiland->source);
427 if (strcmp(filename, compiland_name))
429 base = strrchr(filename, '/');
430 if (!base++) base = filename;
431 if (strcmp(base, compiland_basename)) continue;
436 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
437 name, compiland_name,
438 source_get(module, result->compiland->source), result->symp->st_value,
439 source_get(module, ste->compiland->source), ste->symp->st_value);
447 if (!result && !(result = weak_result))
449 FIXME("Couldn't find symbol %s!%s in symtab\n",
450 module->module.ModuleName, name);
456 /******************************************************************
457 * elf_finish_stabs_info
459 * - get any relevant information (address & size) from the bits we got from the
460 * stabs debugging information
462 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
464 struct hash_table_iter hti;
467 const Elf32_Sym* symp;
469 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
470 while ((ptr = hash_table_iter_up(&hti)))
472 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
473 switch (sym->symt.tag)
476 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
477 ((struct symt_function*)sym)->size)
481 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
482 ((struct symt_function*)sym)->container);
485 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
486 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
487 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
488 sym, module->module.ModuleName, sym->hash_elt.name,
489 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
490 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
491 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
492 sym, module->module.ModuleName, sym->hash_elt.name,
493 ((struct symt_function*)sym)->size, symp->st_size);
495 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
497 ((struct symt_function*)sym)->size = symp->st_size;
498 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
501 switch (((struct symt_data*)sym)->kind)
504 case DataIsFileStatic:
505 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr)
507 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
508 ((struct symt_data*)sym)->container);
511 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr &&
512 ((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr + symp->st_value)
513 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
514 sym, module->module.ModuleName, sym->hash_elt.name,
515 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
516 ((struct symt_data*)sym)->u.var.offset = module->elf_info->elf_addr +
518 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
519 DataIsFileStatic : DataIsGlobal;
520 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
526 FIXME("Unsupported tag %u\n", sym->symt.tag);
530 /* since we may have changed some addresses & sizes, mark the module to be resorted */
531 module->sortlist_valid = FALSE;
534 /******************************************************************
535 * elf_load_wine_thunks
537 * creating the thunk objects for a wine native DLL
539 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
540 const struct elf_thunk_area* thunks)
543 struct hash_table_iter hti;
544 struct symtab_elt* ste;
548 hash_table_iter_init(ht_symtab, &hti, NULL);
549 while ((ste = hash_table_iter_up(&hti)))
551 if (ste->used) continue;
553 addr = module->elf_info->elf_addr + ste->symp->st_value;
555 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
556 if (j >= 0) /* thunk found */
558 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
559 addr, ste->symp->st_size);
565 idx = symt_find_nearest(module, addr);
567 symt_get_info(&module->addr_sorttab[idx]->symt,
568 TI_GET_ADDRESS, &ref_addr);
569 if (idx == -1 || addr != ref_addr)
571 /* creating public symbols for all the ELF symbols which haven't been
572 * used yet (ie we have no debug information on them)
573 * That's the case, for example, of the .spec.c files
575 switch (ELF32_ST_TYPE(ste->symp->st_info))
578 symt_new_function(module, ste->compiland, ste->ht_elt.name,
579 addr, ste->symp->st_size, NULL);
582 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
583 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
584 addr, ste->symp->st_size, NULL);
587 FIXME("Shouldn't happen\n");
590 /* FIXME: this is a hack !!!
591 * we are adding new symbols, but as we're parsing a symbol table
592 * (hopefully without duplicate symbols) we delay rebuilding the sorted
593 * module table until we're done with the symbol table
594 * Otherwise, as we intertwine symbols's add and lookup, performance
597 module->sortlist_valid = TRUE;
599 else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
601 ULONG64 xaddr = 0, xsize = 0;
604 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr);
605 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize);
606 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind);
608 /* If none of symbols has a correct size, we consider they are both markers
609 * Hence, we can silence this warning
610 * Also, we check that we don't have two symbols, one local, the other
611 * global which is legal
613 if ((xsize || ste->symp->st_size) &&
614 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
615 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
616 module->module.ModuleName,
617 ste->ht_elt.name, addr, ste->symp->st_size,
618 module->addr_sorttab[idx]->hash_elt.name,
619 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
623 /* see comment above */
624 module->sortlist_valid = FALSE;
628 /******************************************************************
629 * elf_new_public_symbols
631 * Creates a set of public symbols from an ELF symtab
633 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
635 struct hash_table_iter hti;
636 struct symtab_elt* ste;
638 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
640 /* FIXME: we're missing the ELF entry point here */
642 hash_table_iter_init(symtab, &hti, NULL);
643 while ((ste = hash_table_iter_up(&hti)))
645 symt_new_public(module, ste->compiland, ste->ht_elt.name,
646 module->elf_info->elf_addr + ste->symp->st_value,
647 ste->symp->st_size, TRUE /* FIXME */,
648 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
653 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
654 the following calc_crc32 code or tables extracted from it, as desired without
657 /**********************************************************************\
658 |* Demonstration program to compute the 32-bit CRC used as the frame *|
659 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
660 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
661 |* protocol). The 32-bit FCS was added via the Federal Register, *|
662 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
663 |* this polynomial is or will be included in CCITT V.41, which *|
664 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
665 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
666 |* errors by a factor of 10^-5 over 16-bit FCS. *|
667 \**********************************************************************/
669 /* First, the polynomial itself and its table of feedback terms. The */
671 /* 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 */
672 /* Note that we take it "backwards" and put the highest-order term in */
673 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
674 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
675 /* the MSB being 1. */
677 /* Note that the usual hardware shift register implementation, which */
678 /* is what we're using (we're merely optimizing it by doing eight-bit */
679 /* chunks at a time) shifts bits into the lowest-order term. In our */
680 /* implementation, that means shifting towards the right. Why do we */
681 /* do it this way? Because the calculated CRC must be transmitted in */
682 /* order from highest-order term to lowest-order term. UARTs transmit */
683 /* characters in order from LSB to MSB. By storing the CRC this way, */
684 /* we hand it to the UART in the order low-byte to high-byte; the UART */
685 /* sends each low-bit to hight-bit; and the result is transmission bit */
686 /* by bit from highest- to lowest-order term without requiring any bit */
687 /* shuffling on our part. Reception works similarly. */
689 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
691 /* 1. The table can be generated at runtime if desired; code to do so */
692 /* is shown later. It might not be obvious, but the feedback */
693 /* terms simply represent the results of eight shift/xor opera- */
694 /* tions for all combinations of data and CRC register values. */
696 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
697 /* be they sixteen or thirty-two bits wide. You simply choose the */
698 /* appropriate table. Alternatively, because the table can be */
699 /* generated at runtime, you can start by generating the table for */
700 /* the polynomial in question and use exactly the same "updcrc", */
701 /* if your application needn't simultaneously handle two CRC */
702 /* polynomials. (Note, however, that XMODEM is strange.) */
704 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
705 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
707 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
708 /* logic; the shift must be unsigned (bring in zeroes). On some */
709 /* hardware you could probably optimize the shift in assembler by */
710 /* using byte-swap instructions. */
713 static DWORD calc_crc32(struct elf_file_map* fmap)
715 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
716 static const DWORD crc_32_tab[] =
717 { /* CRC polynomial 0xedb88320 */
718 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
719 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
720 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
721 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
722 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
723 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
724 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
725 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
726 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
727 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
728 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
729 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
730 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
731 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
732 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
733 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
734 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
735 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
736 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
737 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
738 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
739 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
740 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
741 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
742 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
743 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
744 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
745 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
746 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
747 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
748 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
749 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
750 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
751 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
752 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
753 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
754 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
755 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
756 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
757 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
758 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
759 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
760 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
763 unsigned char buffer[256];
766 lseek(fmap->fd, 0, SEEK_SET);
767 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
769 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
775 /******************************************************************
776 * elf_load_debug_info_from_map
778 * Loads the symbolic information from ELF module which mapping is described
780 * the module has been loaded at 'load_offset' address, so symbols' address
781 * relocation is performed.
782 * CRC is checked if fmap->with_crc is TRUE
784 * 0 if the file doesn't contain symbolic info (or this info cannot be
788 static BOOL elf_load_debug_info_from_map(struct module* module,
789 struct elf_file_map* fmap,
791 struct hash_table* ht_symtab)
793 BOOL ret = FALSE, lret;
794 const char* shstrtab;
796 int symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
797 int debug_sect, debug_str_sect, debug_abbrev_sect;
798 int debug_line_sect, debug_loclist_sect;
800 struct elf_thunk_area thunks[] =
802 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
803 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
804 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
805 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
806 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
807 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
811 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
813 ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
814 module->module.ImageName, calc_crc32(fmap), fmap->crc);
815 /* we don't tolerate mis-matched files */
820 * Next, we need to find a few of the internal ELF headers within
821 * this thing. We need the main executable header, and the section
824 shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
825 if (shstrtab == ELF_NO_MAP) return FALSE;
827 symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
828 debug_sect = debug_str_sect = debug_abbrev_sect = -1;
829 debug_line_sect = debug_loclist_sect = -1;
832 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
834 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
836 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
838 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
840 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
842 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
843 debug_abbrev_sect = i;
844 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
846 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_loc") == 0)
847 debug_loclist_sect = i;
848 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
850 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
851 (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
853 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
854 (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
857 elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
860 if (symtab_sect == -1)
862 /* if we don't have a symtab but a dynsym, process the dynsym
863 * section instead. It'll contain less (relevant) information,
864 * but it'll be better than nothing
866 if (dynsym_sect == -1) return FALSE;
867 symtab_sect = dynsym_sect;
870 module->module.SymType = SymExport;
872 /* create a hash table for the symtab */
873 elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
875 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
877 if (stab_sect != -1 && stabstr_sect != -1)
882 stab = elf_map_section(fmap, stab_sect);
883 stabstr = elf_map_section(fmap, stabstr_sect);
884 if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP)
886 /* OK, now just parse all of the stabs. */
887 lret = stabs_parse(module, module->elf_info->elf_addr,
888 stab, elf_get_map_size(fmap, stab_sect),
889 stabstr, elf_get_map_size(fmap, stabstr_sect));
891 /* and fill in the missing information for stabs */
892 elf_finish_stabs_info(module, ht_symtab);
894 WARN("Couldn't correctly read stabs\n");
898 elf_unmap_section(fmap, stab_sect);
899 elf_unmap_section(fmap, stabstr_sect);
902 if (debug_sect != -1)
904 /* Dwarf 2 debug information */
905 const BYTE* dw2_debug;
906 const BYTE* dw2_debug_abbrev;
907 const BYTE* dw2_debug_str;
908 const BYTE* dw2_debug_line;
909 const BYTE* dw2_debug_loclist;
911 TRACE("Loading Dwarf2 information for %s\n", module->module.ModuleName);
913 dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
914 dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
915 dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
916 dw2_debug_line = (const BYTE*) elf_map_section(fmap, debug_line_sect);
917 dw2_debug_loclist = (const BYTE*) elf_map_section(fmap, debug_loclist_sect);
918 if (dw2_debug != ELF_NO_MAP && dw2_debug_abbrev != ELF_NO_MAP && dw2_debug_str != ELF_NO_MAP)
920 /* OK, now just parse dwarf2 debug infos. */
921 lret = dwarf2_parse(module, module->elf_info->elf_addr, thunks,
922 dw2_debug, elf_get_map_size(fmap, debug_sect),
923 dw2_debug_abbrev, elf_get_map_size(fmap, debug_abbrev_sect),
924 dw2_debug_str, elf_get_map_size(fmap, debug_str_sect),
925 dw2_debug_line, elf_get_map_size(fmap, debug_line_sect),
926 dw2_debug_loclist, elf_get_map_size(fmap, debug_loclist_sect));
929 WARN("Couldn't correctly read stabs\n");
932 elf_unmap_section(fmap, debug_sect);
933 elf_unmap_section(fmap, debug_abbrev_sect);
934 elf_unmap_section(fmap, debug_str_sect);
935 elf_unmap_section(fmap, debug_line_sect);
936 elf_unmap_section(fmap, debug_loclist_sect);
938 if (debuglink_sect != -1)
940 const char* dbg_link;
941 struct elf_file_map fmap_link;
943 dbg_link = elf_map_section(fmap, debuglink_sect);
944 /* The content of a debug link section is:
945 * 1/ a NULL terminated string, containing the file name for the
947 * 2/ padding on 4 byte boundary
948 * 3/ CRC of the linked ELF file
950 if (dbg_link != ELF_NO_MAP && elf_map_file(dbg_link, &fmap_link))
952 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
953 fmap_link.with_crc = 1;
954 lret = elf_load_debug_info_from_map(module, &fmap_link, pool,
957 strcpy(module->module.LoadedPdbName, dbg_link);
959 WARN("Couldn't load debug information from %s\n", dbg_link);
963 WARN("Couldn't load linked debug file for %s\n",
964 module->module.ModuleName);
965 elf_unmap_file(&fmap_link);
968 if (strstr(module->module.ModuleName, "<elf>") ||
969 !strcmp(module->module.ModuleName, "<wine-loader>"))
971 /* add the thunks for native libraries */
972 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
973 elf_new_wine_thunks(module, ht_symtab, thunks);
975 /* add all the public symbols from symtab */
976 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
981 /******************************************************************
982 * elf_load_debug_info
984 * Loads ELF debugging information from the module image file.
986 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
990 struct hash_table ht_symtab;
991 struct elf_file_map my_fmap;
993 if (module->type != DMT_ELF || !module->elf_info)
995 ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
999 pool_init(&pool, 65536);
1000 hash_table_init(&pool, &ht_symtab, 256);
1005 ret = elf_map_file(module->module.LoadedImageName, fmap);
1008 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
1010 pool_destroy(&pool);
1011 if (fmap == &my_fmap) elf_unmap_file(fmap);
1015 /******************************************************************
1016 * elf_fetch_file_info
1018 * Gathers some more information for an ELF module from a given file
1020 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1021 DWORD* size, DWORD* checksum)
1023 struct elf_file_map fmap;
1024 if (!elf_map_file(name, &fmap)) return FALSE;
1025 if (base) *base = fmap.elf_start;
1026 *size = fmap.elf_size;
1027 *checksum = calc_crc32(&fmap);
1028 elf_unmap_file(&fmap);
1032 /******************************************************************
1034 * returns true iff the section tag is valid
1036 static unsigned is_dt_flag_valid(unsigned d_tag)
1039 #define DT_PROCNUM 0
1042 #define DT_EXTRANUM 0
1045 #define DT_GNU_HASH 0x6ffffef5
1047 return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
1048 || (d_tag == DT_GNU_HASH)
1049 #if defined(DT_LOOS) && defined(DT_HIOS)
1050 || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
1052 #if defined(DT_LOPROC) && defined(DT_HIPROC)
1053 || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
1058 /******************************************************************
1061 * Loads the information for ELF module stored in 'filename'
1062 * the module has been loaded at 'load_offset' address
1064 * -1 if the file cannot be found/opened
1065 * 0 if the file doesn't contain symbolic info (or this info cannot be
1069 static BOOL elf_load_file(struct process* pcs, const char* filename,
1070 unsigned long load_offset, struct elf_info* elf_info)
1073 struct elf_file_map fmap;
1076 TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1078 if (!elf_map_file(filename, &fmap)) goto leave;
1080 /* Next, we need to find a few of the internal ELF headers within
1081 * this thing. We need the main executable header, and the section
1084 if (!fmap.elf_start && !load_offset)
1085 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1087 if (fmap.elf_start && load_offset)
1089 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1090 "Assuming load address is corrupt\n", filename, load_offset);
1094 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1096 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1097 if (shstrtab == ELF_NO_MAP) goto leave;
1098 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1100 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1101 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1104 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1109 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1110 len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
1111 dyn.d_tag = DT_NULL;
1113 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1114 if (dyn.d_tag == DT_NULL) goto leave;
1115 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1118 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1121 if (elf_info->flags & ELF_INFO_MODULE)
1123 struct elf_module_info *elf_module_info =
1124 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1125 if (!elf_module_info) goto leave;
1126 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1127 (load_offset) ? load_offset : fmap.elf_start,
1128 fmap.elf_size, 0, calc_crc32(&fmap));
1129 if (!elf_info->module)
1131 HeapFree(GetProcessHeap(), 0, elf_module_info);
1134 elf_info->module->elf_info = elf_module_info;
1135 elf_info->module->elf_info->elf_addr = load_offset;
1137 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1139 elf_info->module->module.SymType = SymDeferred;
1142 else ret = elf_load_debug_info(elf_info->module, &fmap);
1144 elf_info->module->elf_info->elf_mark = 1;
1145 elf_info->module->elf_info->elf_loader = 0;
1148 if (elf_info->flags & ELF_INFO_NAME)
1150 elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1151 strlen(filename) + 1), filename);
1154 elf_unmap_file(&fmap);
1159 /******************************************************************
1160 * elf_load_file_from_path
1161 * tries to load an ELF file from a set of paths (separated by ':')
1163 static BOOL elf_load_file_from_path(HANDLE hProcess,
1164 const char* filename,
1165 unsigned long load_offset,
1167 struct elf_info* elf_info)
1173 if (!path) return FALSE;
1175 paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1176 for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
1180 fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1184 strcat(fn, filename);
1185 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1186 HeapFree(GetProcessHeap(), 0, fn);
1188 s = (t) ? (t+1) : NULL;
1191 HeapFree(GetProcessHeap(), 0, paths);
1195 /******************************************************************
1196 * elf_load_file_from_dll_path
1198 * Tries to load an ELF file from the dll path
1200 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1201 const char* filename,
1202 unsigned long load_offset,
1203 struct elf_info* elf_info)
1206 unsigned int index = 0;
1209 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1211 char *name = HeapAlloc( GetProcessHeap(), 0, strlen(path) + strlen(filename) + 2 );
1213 strcpy( name, path );
1214 strcat( name, "/" );
1215 strcat( name, filename );
1216 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1217 HeapFree( GetProcessHeap(), 0, name );
1222 /******************************************************************
1223 * elf_search_and_load_file
1225 * lookup a file in standard ELF locations, and if found, load it
1227 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1228 unsigned long load_offset,
1229 struct elf_info* elf_info)
1232 struct module* module;
1234 if (filename == NULL || *filename == '\0') return FALSE;
1235 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1237 elf_info->module = module;
1238 module->elf_info->elf_mark = 1;
1239 return module->module.SymType;
1242 if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1243 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1244 /* if relative pathname, try some absolute base dirs */
1245 if (!ret && !strchr(filename, '/'))
1247 ret = elf_load_file_from_path(pcs, filename, load_offset,
1248 getenv("PATH"), elf_info) ||
1249 elf_load_file_from_path(pcs, filename, load_offset,
1250 getenv("LD_LIBRARY_PATH"), elf_info);
1251 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1257 /******************************************************************
1258 * elf_enum_modules_internal
1260 * Enumerate ELF modules from a running process
1262 static BOOL elf_enum_modules_internal(const struct process* pcs,
1263 const char* main_name,
1264 elf_enum_modules_cb cb, void* user)
1266 struct r_debug dbg_hdr;
1271 if (!pcs->dbg_hdr_addr ||
1272 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1273 &dbg_hdr, sizeof(dbg_hdr), NULL))
1276 /* Now walk the linked list. In all known ELF implementations,
1277 * the dynamic loader maintains this linked list for us. In some
1278 * cases the first entry doesn't appear with a name, in other cases it
1281 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1283 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1286 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1287 lm.l_name != NULL &&
1288 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1290 bufstr[sizeof(bufstr) - 1] = '\0';
1291 if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1292 if (!cb(bufstr, (unsigned long)lm.l_addr, user)) break;
1300 struct process* pcs;
1301 struct elf_info elf_info;
1304 static BOOL elf_enum_sync_cb(const char* name, unsigned long addr, void* user)
1306 struct elf_sync* es = user;
1308 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1312 /******************************************************************
1313 * elf_synchronize_module_list
1315 * this functions rescans the debuggee module's list and synchronizes it with
1316 * the one from 'pcs', ie:
1317 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1318 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1320 BOOL elf_synchronize_module_list(struct process* pcs)
1322 struct module* module;
1325 for (module = pcs->lmodules; module; module = module->next)
1327 if (module->type == DMT_ELF && !module->is_virtual)
1328 module->elf_info->elf_mark = 0;
1332 es.elf_info.flags = ELF_INFO_MODULE;
1333 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1336 module = pcs->lmodules;
1339 if (module->type == DMT_ELF && !module->is_virtual &&
1340 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1342 module_remove(pcs, module);
1343 /* restart all over */
1344 module = pcs->lmodules;
1346 else module = module->next;
1351 /******************************************************************
1354 * Lookup in a running ELF process the loader, and sets its ELF link
1355 * address (for accessing the list of loaded .so libs) in pcs.
1356 * If flags is ELF_INFO_MODULE, the module for the loader is also
1357 * added as a module into pcs.
1359 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1364 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1365 * main executable (either wine-kthread or wine-pthread)
1366 * FIXME: the heuristic used to know whether we need to load wine-pthread
1367 * or wine-kthread is not 100% safe
1369 if ((ptr = getenv("WINELOADER")))
1370 ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1373 ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1374 elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1379 /******************************************************************
1380 * elf_read_wine_loader_dbg_info
1382 * Try to find a decent wine executable which could have loaded the debuggee
1384 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1386 struct elf_info elf_info;
1388 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1389 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1390 elf_info.module->elf_info->elf_loader = 1;
1391 strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
1392 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1395 /******************************************************************
1398 * Enumerates the ELF loaded modules from a running target (hProc)
1399 * This function doesn't require that someone has called SymInitialize
1400 * on this very process.
1402 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1405 struct elf_info elf_info;
1408 memset(&pcs, 0, sizeof(pcs));
1410 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1411 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1412 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1413 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1414 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1420 struct process* pcs;
1421 struct elf_info elf_info;
1426 /******************************************************************
1429 * Callback for elf_load_module, used to walk the list of loaded
1432 static BOOL elf_load_cb(const char* name, unsigned long addr, void* user)
1434 struct elf_load* el = user;
1437 /* memcmp is needed for matches when bufstr contains also version information
1438 * el->name: libc.so, name: libc.so.6.0
1440 p = strrchr(name, '/');
1442 if (!memcmp(p, el->name, strlen(el->name)))
1444 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1450 /******************************************************************
1453 * loads an ELF module and stores it in process' module list
1454 * Also, find module real name and load address from
1455 * the real loaded modules list in pcs address space
1457 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1461 TRACE("(%p %s %08lx)\n", pcs, name, addr);
1463 el.elf_info.flags = ELF_INFO_MODULE;
1466 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1469 /* do only the lookup from the filename, not the path (as we lookup module
1470 * name in the process' loaded module list)
1472 el.name = strrchr(name, '/');
1473 if (!el.name++) el.name = name;
1476 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1481 el.ret = elf_search_and_load_file(pcs, name, addr, &el.elf_info);
1483 if (!el.ret) return NULL;
1484 assert(el.elf_info.module);
1485 return el.elf_info.module;
1488 #else /* !__ELF__ */
1490 BOOL elf_synchronize_module_list(struct process* pcs)
1495 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1496 DWORD* size, DWORD* checksum)
1501 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1506 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1511 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1516 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1521 int elf_is_in_thunk_area(unsigned long addr,
1522 const struct elf_thunk_area* thunks)
1526 #endif /* __ELF__ */