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 #define NO_MAP ((const void*)0xffffffff)
102 /* structure holding information while handling an ELF image
103 * allows one by one section mapping for memory savings
122 struct hash_table_elt ht_elt;
123 const Elf32_Sym* symp;
124 struct symt_compiland* compiland;
131 THUNK_ORDINAL ordinal;
132 unsigned long rva_start;
133 unsigned long rva_end;
136 /******************************************************************
139 * Maps a single section into memory from an ELF file
141 static const char* elf_map_section(struct elf_file_map* fmap, int sidx)
143 unsigned pgsz = getpagesize();
146 if (sidx >= fmap->elfhdr.e_shnum ||
147 fmap->sect[sidx].shdr.sh_type == SHT_NOBITS)
149 /* align required information on page size (we assume pagesize is a power of 2) */
150 ofst = fmap->sect[sidx].shdr.sh_offset & ~(pgsz - 1);
151 size = (fmap->sect[sidx].shdr.sh_offset +
152 fmap->sect[sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1);
153 fmap->sect[sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fmap->fd, ofst);
154 if (fmap->sect[sidx].mapped == NO_MAP) return NO_MAP;
155 return fmap->sect[sidx].mapped + (fmap->sect[sidx].shdr.sh_offset & (pgsz - 1));
158 /******************************************************************
161 * Unmaps a single section from memory
163 static void elf_unmap_section(struct elf_file_map* fmap, int sidx)
165 if (sidx < fmap->elfhdr.e_shnum && fmap->sect[sidx].mapped != NO_MAP)
167 munmap((char*)fmap->sect[sidx].mapped, fmap->sect[sidx].shdr.sh_size);
168 fmap->sect[sidx].mapped = NO_MAP;
172 /******************************************************************
175 * Maps an ELF file into memory (and checks it's a real ELF file)
177 static BOOL elf_map_file(const char* filename, struct elf_file_map* fmap)
179 static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
183 unsigned tmp, page_mask = getpagesize() - 1;
189 /* check that the file exists, and that the module hasn't been loaded yet */
190 if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) return FALSE;
192 /* Now open the file, so that we can mmap() it. */
193 if ((fmap->fd = open(filename, O_RDONLY)) == -1) return FALSE;
195 if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr))
197 /* and check for an ELF header */
198 if (memcmp(fmap->elfhdr.e_ident,
199 elf_signature, sizeof(elf_signature))) return FALSE;
201 fmap->sect = HeapAlloc(GetProcessHeap(), 0,
202 fmap->elfhdr.e_shnum * sizeof(fmap->sect[0]));
203 if (!fmap->sect) return FALSE;
205 lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET);
206 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
208 read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr));
209 fmap->sect[i].mapped = NO_MAP;
212 /* grab size of module once loaded in memory */
213 lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET);
215 fmap->elf_start = ~0L;
216 for (i = 0; i < fmap->elfhdr.e_phnum; i++)
218 if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) &&
219 phdr.p_type == PT_LOAD)
221 tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
222 if (fmap->elf_size < tmp) fmap->elf_size = tmp;
223 if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr;
226 /* if non relocatable ELF, then remove fixed address from computation
227 * otherwise, all addresses are zero based and start has no effect
229 fmap->elf_size -= fmap->elf_start;
233 /******************************************************************
236 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
238 static void elf_unmap_file(struct elf_file_map* fmap)
243 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
245 elf_unmap_section(fmap, i);
247 HeapFree(GetProcessHeap(), 0, fmap->sect);
252 /******************************************************************
255 * creating an internal hash table to ease use ELF symtab information lookup
257 static void elf_hash_symtab(struct module* module, struct pool* pool,
258 struct hash_table* ht_symtab, struct elf_file_map* fmap,
259 int symtab_idx, struct thunk_area* thunks)
264 struct symt_compiland* compiland = NULL;
266 const Elf32_Sym* symp;
267 struct symtab_elt* ste;
269 symp = (const Elf32_Sym*)elf_map_section(fmap, symtab_idx);
270 strp = elf_map_section(fmap, fmap->sect[symtab_idx].shdr.sh_link);
271 if (symp == NO_MAP || strp == NO_MAP) return;
273 nsym = fmap->sect[symtab_idx].shdr.sh_size / sizeof(*symp);
275 for (j = 0; thunks[j].symname; j++)
276 thunks[j].rva_start = thunks[j].rva_end = 0;
278 for (i = 0; i < nsym; i++, symp++)
280 /* Ignore certain types of entries which really aren't of that much
283 if ((ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
284 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
285 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
286 symp->st_shndx == SHN_UNDEF)
291 symname = strp + symp->st_name;
293 if (ELF32_ST_TYPE(symp->st_info) == STT_FILE)
295 compiland = symname ? symt_new_compiland(module, symname) : NULL;
298 for (j = 0; thunks[j].symname; j++)
300 if (!strcmp(symname, thunks[j].symname))
302 thunks[j].rva_start = symp->st_value;
303 thunks[j].rva_end = symp->st_value + symp->st_size;
307 if (thunks[j].symname) continue;
309 /* FIXME: we don't need to handle them (GCC internals)
310 * Moreover, they screw up our symbol lookup :-/
312 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
315 ste = pool_alloc(pool, sizeof(*ste));
316 ste->ht_elt.name = symname;
317 /* GCC emits, in some cases, a .<digit>+ suffix.
318 * This is used for static variable inside functions, so
319 * that we can have several such variables with same name in
320 * the same compilation unit
321 * We simply ignore that suffix when present (we also get rid
322 * of it in stabs parsing)
324 ptr = symname + strlen(symname) - 1;
327 while (isdigit(*ptr) && ptr >= symname) ptr--;
328 if (ptr > symname && *ptr == '.')
330 char* n = pool_alloc(pool, ptr - symname + 1);
331 memcpy(n, symname, ptr - symname + 1);
332 n[ptr - symname] = '\0';
333 ste->ht_elt.name = n;
337 ste->compiland = compiland;
339 hash_table_add(ht_symtab, &ste->ht_elt);
341 /* as we added in the ht_symtab pointers to the symbols themselves,
342 * we cannot unmap yet the sections, it will be done when we're over
347 /******************************************************************
350 * lookup a symbol by name in our internal hash table for the symtab
352 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
353 const struct hash_table* ht_symtab,
354 const char* name, struct symt* compiland)
356 struct symtab_elt* weak_result = NULL; /* without compiland name */
357 struct symtab_elt* result = NULL;
358 struct hash_table_iter hti;
359 struct symtab_elt* ste;
360 const char* compiland_name;
361 const char* compiland_basename;
364 /* we need weak match up (at least) when symbols of same name,
365 * defined several times in different compilation units,
366 * are merged in a single one (hence a different filename for c.u.)
370 compiland_name = source_get(module,
371 ((struct symt_compiland*)compiland)->source);
372 compiland_basename = strrchr(compiland_name, '/');
373 if (!compiland_basename++) compiland_basename = compiland_name;
375 else compiland_name = compiland_basename = NULL;
377 hash_table_iter_init(ht_symtab, &hti, name);
378 while ((ste = hash_table_iter_up(&hti)))
380 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
383 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
385 if (ste->compiland && compiland_name)
387 const char* filename = source_get(module, ste->compiland->source);
388 if (strcmp(filename, compiland_name))
390 base = strrchr(filename, '/');
391 if (!base++) base = filename;
392 if (strcmp(base, compiland_basename)) continue;
397 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
398 name, compiland_name,
399 source_get(module, result->compiland->source), result->symp->st_value,
400 source_get(module, ste->compiland->source), ste->symp->st_value);
408 if (!result && !(result = weak_result))
410 FIXME("Couldn't find symbol %s!%s in symtab\n",
411 module->module.ModuleName, name);
417 /******************************************************************
418 * elf_finish_stabs_info
420 * - get any relevant information (address & size) from the bits we got from the
421 * stabs debugging information
423 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
425 struct hash_table_iter hti;
428 const Elf32_Sym* symp;
430 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
431 while ((ptr = hash_table_iter_up(&hti)))
433 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
434 switch (sym->symt.tag)
437 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
438 ((struct symt_function*)sym)->size)
442 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
443 ((struct symt_function*)sym)->container);
446 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
447 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
448 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
449 sym, module->module.ModuleName, sym->hash_elt.name,
450 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
451 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
452 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
453 sym, module->module.ModuleName, sym->hash_elt.name,
454 ((struct symt_function*)sym)->size, symp->st_size);
456 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
458 ((struct symt_function*)sym)->size = symp->st_size;
459 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
462 switch (((struct symt_data*)sym)->kind)
465 case DataIsFileStatic:
466 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr)
468 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
469 ((struct symt_data*)sym)->container);
472 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr &&
473 ((struct symt_data*)sym)->u.address != module->elf_info->elf_addr + symp->st_value)
474 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
475 sym, module->module.ModuleName, sym->hash_elt.name,
476 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
477 ((struct symt_data*)sym)->u.address = module->elf_info->elf_addr +
479 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
480 DataIsFileStatic : DataIsGlobal;
481 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
487 FIXME("Unsupported tag %u\n", sym->symt.tag);
491 /* since we may have changed some addresses & sizes, mark the module to be resorted */
492 module->sortlist_valid = FALSE;
495 /******************************************************************
496 * elf_load_wine_thunks
498 * creating the thunk objects for a wine native DLL
500 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
501 unsigned num_areas, struct thunk_area* thunks)
504 struct hash_table_iter hti;
505 struct symtab_elt* ste;
509 hash_table_iter_init(ht_symtab, &hti, NULL);
510 while ((ste = hash_table_iter_up(&hti)))
512 if (ste->used) continue;
514 addr = module->elf_info->elf_addr + ste->symp->st_value;
516 for (j = 0; j < num_areas; j++)
518 if (ste->symp->st_value >= thunks[j].rva_start &&
519 ste->symp->st_value < thunks[j].rva_end)
522 if (j < num_areas) /* thunk found */
524 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
525 addr, ste->symp->st_size);
531 idx = symt_find_nearest(module, addr);
533 symt_get_info(&module->addr_sorttab[idx]->symt,
534 TI_GET_ADDRESS, &ref_addr);
535 if (idx == -1 || addr != ref_addr)
537 /* creating public symbols for all the ELF symbols which haven't been
538 * used yet (ie we have no debug information on them)
539 * That's the case, for example, of the .spec.c files
541 switch (ELF32_ST_TYPE(ste->symp->st_info))
544 symt_new_function(module, ste->compiland, ste->ht_elt.name,
545 addr, ste->symp->st_size, NULL);
548 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
549 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
550 addr, ste->symp->st_size, NULL);
553 FIXME("Shouldn't happen\n");
556 /* FIXME: this is a hack !!!
557 * we are adding new symbols, but as we're parsing a symbol table
558 * (hopefully without duplicate symbols) we delay rebuilding the sorted
559 * module table until we're done with the symbol table
560 * Otherwise, as we intertwine symbols's add and lookup, performance
563 module->sortlist_valid = TRUE;
565 else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
567 ULONG64 xaddr = 0, xsize = 0;
570 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr);
571 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize);
572 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind);
574 /* If none of symbols has a correct size, we consider they are both markers
575 * Hence, we can silence this warning
576 * Also, we check that we don't have two symbols, one local, the other
577 * global which is legal
579 if ((xsize || ste->symp->st_size) &&
580 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
581 FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%s>\n",
582 module->module.ModuleName,
583 ste->ht_elt.name, addr, ste->symp->st_size,
584 module->addr_sorttab[idx]->hash_elt.name,
585 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
589 /* see comment above */
590 module->sortlist_valid = FALSE;
594 /******************************************************************
595 * elf_new_public_symbols
597 * Creates a set of public symbols from an ELF symtab
599 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
601 struct hash_table_iter hti;
602 struct symtab_elt* ste;
604 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
606 /* FIXME: we're missing the ELF entry point here */
608 hash_table_iter_init(symtab, &hti, NULL);
609 while ((ste = hash_table_iter_up(&hti)))
611 symt_new_public(module, ste->compiland, ste->ht_elt.name,
612 module->elf_info->elf_addr + ste->symp->st_value,
613 ste->symp->st_size, TRUE /* FIXME */,
614 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
619 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
620 the following calc_crc32 code or tables extracted from it, as desired without
623 /**********************************************************************\
624 |* Demonstration program to compute the 32-bit CRC used as the frame *|
625 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
626 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
627 |* protocol). The 32-bit FCS was added via the Federal Register, *|
628 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
629 |* this polynomial is or will be included in CCITT V.41, which *|
630 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
631 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
632 |* errors by a factor of 10^-5 over 16-bit FCS. *|
633 \**********************************************************************/
635 /* First, the polynomial itself and its table of feedback terms. The */
637 /* 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 */
638 /* Note that we take it "backwards" and put the highest-order term in */
639 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
640 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
641 /* the MSB being 1. */
643 /* Note that the usual hardware shift register implementation, which */
644 /* is what we're using (we're merely optimizing it by doing eight-bit */
645 /* chunks at a time) shifts bits into the lowest-order term. In our */
646 /* implementation, that means shifting towards the right. Why do we */
647 /* do it this way? Because the calculated CRC must be transmitted in */
648 /* order from highest-order term to lowest-order term. UARTs transmit */
649 /* characters in order from LSB to MSB. By storing the CRC this way, */
650 /* we hand it to the UART in the order low-byte to high-byte; the UART */
651 /* sends each low-bit to hight-bit; and the result is transmission bit */
652 /* by bit from highest- to lowest-order term without requiring any bit */
653 /* shuffling on our part. Reception works similarly. */
655 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
657 /* 1. The table can be generated at runtime if desired; code to do so */
658 /* is shown later. It might not be obvious, but the feedback */
659 /* terms simply represent the results of eight shift/xor opera- */
660 /* tions for all combinations of data and CRC register values. */
662 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
663 /* be they sixteen or thirty-two bits wide. You simply choose the */
664 /* appropriate table. Alternatively, because the table can be */
665 /* generated at runtime, you can start by generating the table for */
666 /* the polynomial in question and use exactly the same "updcrc", */
667 /* if your application needn't simultaneously handle two CRC */
668 /* polynomials. (Note, however, that XMODEM is strange.) */
670 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
671 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
673 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
674 /* logic; the shift must be unsigned (bring in zeroes). On some */
675 /* hardware you could probably optimize the shift in assembler by */
676 /* using byte-swap instructions. */
679 static DWORD calc_crc32(struct elf_file_map* fmap)
681 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
682 static const DWORD crc_32_tab[] =
683 { /* CRC polynomial 0xedb88320 */
684 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
685 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
686 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
687 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
688 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
689 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
690 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
691 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
692 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
693 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
694 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
695 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
696 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
697 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
698 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
699 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
700 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
701 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
702 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
703 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
704 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
705 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
706 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
707 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
708 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
709 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
710 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
711 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
712 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
713 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
714 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
715 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
716 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
717 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
718 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
719 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
720 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
721 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
722 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
723 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
724 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
725 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
726 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
729 unsigned char buffer[256];
732 lseek(fmap->fd, 0, SEEK_SET);
733 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
735 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
741 /******************************************************************
742 * elf_load_debug_info_from_map
744 * Loads the symbolic information from ELF module which mapping is described
746 * the module has been loaded at 'load_offset' address, so symbols' address
747 * relocation is performed.
748 * CRC is checked if fmap->with_crc is TRUE
750 * 0 if the file doesn't contain symbolic info (or this info cannot be
754 static BOOL elf_load_debug_info_from_map(struct module* module,
755 struct elf_file_map* fmap,
757 struct hash_table* ht_symtab)
760 const char* shstrtab;
762 int symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
763 int debug_sect, debug_str_sect, debug_abbrev_sect, debug_line_sect;
765 struct thunk_area thunks[] =
767 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
768 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
769 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
770 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
771 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
772 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
776 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
778 ERR("Bad CRC for module %s (got %08lx while expecting %08lx)\n",
779 module->module.ImageName, calc_crc32(fmap), fmap->crc);
780 /* we don't tolerate mis-matched files */
785 * Next, we need to find a few of the internal ELF headers within
786 * this thing. We need the main executable header, and the section
789 shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
790 if (shstrtab == NO_MAP) return FALSE;
792 symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
793 debug_sect = debug_str_sect = debug_abbrev_sect = debug_line_sect = -1;
796 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
798 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
800 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
802 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
804 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
806 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
807 debug_abbrev_sect = i;
808 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
810 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
812 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
813 (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
815 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
816 (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
819 elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
822 if (symtab_sect == -1)
824 /* if we don't have a symtab but a dynsym, process the dynsym
825 * section instead. It'll contain less (relevant) information,
826 * but it'll be better than nothing
828 if (dynsym_sect == -1) return FALSE;
829 symtab_sect = dynsym_sect;
832 module->module.SymType = SymExport;
834 /* create a hash table for the symtab */
835 elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
837 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
839 if (stab_sect != -1 && stabstr_sect != -1)
844 stab = elf_map_section(fmap, stab_sect);
845 stabstr = elf_map_section(fmap, stabstr_sect);
846 if (stab != NO_MAP && stabstr != NO_MAP)
848 /* OK, now just parse all of the stabs. */
849 ret = stabs_parse(module, module->elf_info->elf_addr,
850 stab, fmap->sect[stab_sect].shdr.sh_size,
851 stabstr, fmap->sect[stabstr_sect].shdr.sh_size);
853 elf_unmap_section(fmap, stab_sect);
854 elf_unmap_section(fmap, stabstr_sect);
858 WARN("Couldn't correctly read stabs\n");
861 /* and fill in the missing information for stabs */
862 elf_finish_stabs_info(module, ht_symtab);
864 else if (debug_sect != -1)
866 /* Dwarf 2 debug information */
867 const BYTE* dw2_debug;
868 const BYTE* dw2_debug_abbrev;
869 const BYTE* dw2_debug_str;
871 FIXME("Alpha-support for Dwarf2 information for %s\n", module->module.ModuleName);
873 dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
874 dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
875 dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
876 if (dw2_debug != NO_MAP && NO_MAP != dw2_debug_abbrev && dw2_debug_str != NO_MAP)
878 /* OK, now just parse dwarf2 debug infos. */
879 ret = dwarf2_parse(module, module->elf_info->elf_addr,
880 dw2_debug, fmap->sect[debug_sect].shdr.sh_size,
881 dw2_debug_abbrev, fmap->sect[debug_abbrev_sect].shdr.sh_size,
882 dw2_debug_str, fmap->sect[debug_str_sect].shdr.sh_size);
884 elf_unmap_section(fmap, debug_sect);
885 elf_unmap_section(fmap, debug_abbrev_sect);
886 elf_unmap_section(fmap, debug_str_sect);
889 WARN("Couldn't correctly read stabs\n");
893 else if (debuglink_sect != -1)
895 const char* dbg_link;
896 struct elf_file_map fmap_link;
898 dbg_link = elf_map_section(fmap, debuglink_sect);
899 /* The content of a debug link section is:
900 * 1/ a NULL terminated string, containing the file name for the
902 * 2/ padding on 4 byte boundary
903 * 3/ CRC of the linked ELF file
905 if (dbg_link != NO_MAP && elf_map_file(dbg_link, &fmap_link))
907 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
908 fmap_link.with_crc = 1;
909 ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
912 WARN("Couldn't load debug information from %s\n", dbg_link);
915 WARN("Couldn't load linked debug file for %s\n",
916 module->module.ModuleName);
917 elf_unmap_file(&fmap_link);
920 if (strstr(module->module.ModuleName, "<elf>") ||
921 !strcmp(module->module.ModuleName, "<wine-loader>"))
923 /* add the thunks for native libraries */
924 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
925 elf_new_wine_thunks(module, ht_symtab,
926 sizeof(thunks) / sizeof(thunks[0]), thunks);
928 /* add all the public symbols from symtab */
929 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
934 /******************************************************************
935 * elf_load_debug_info
937 * Loads ELF debugging information from the module image file.
939 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
943 struct hash_table ht_symtab;
944 struct elf_file_map my_fmap;
946 if (module->type != DMT_ELF || !module->elf_info)
948 ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
952 pool_init(&pool, 65536);
953 hash_table_init(&pool, &ht_symtab, 256);
958 ret = elf_map_file(module->module.LoadedImageName, fmap);
961 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
964 if (fmap == &my_fmap) elf_unmap_file(fmap);
968 /******************************************************************
969 * elf_fetch_file_info
971 * Gathers some more information for an ELF module from a given file
973 BOOL elf_fetch_file_info(const char* name, DWORD* base,
974 DWORD* size, DWORD* checksum)
976 struct elf_file_map fmap;
977 if (!elf_map_file(name, &fmap)) return FALSE;
978 if (base) *base = fmap.elf_start;
979 *size = fmap.elf_size;
980 *checksum = calc_crc32(&fmap);
981 elf_unmap_file(&fmap);
985 /******************************************************************
987 * returns true iff the section tag is valid
989 static unsigned is_dt_flag_valid(unsigned d_tag)
995 #define DT_EXTRANUM 0
997 return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
998 #if defined(DT_LOOS) && defined(DT_HIOS)
999 || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
1001 #if defined(DT_LOPROC) && defined(DT_HIPROC)
1002 || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
1007 /******************************************************************
1010 * Loads the information for ELF module stored in 'filename'
1011 * the module has been loaded at 'load_offset' address
1013 * -1 if the file cannot be found/opened
1014 * 0 if the file doesn't contain symbolic info (or this info cannot be
1018 static BOOL elf_load_file(struct process* pcs, const char* filename,
1019 unsigned long load_offset, struct elf_info* elf_info)
1022 struct elf_file_map fmap;
1025 TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1027 if (!elf_map_file(filename, &fmap)) goto leave;
1029 /* Next, we need to find a few of the internal ELF headers within
1030 * this thing. We need the main executable header, and the section
1033 if (!fmap.elf_start && !load_offset)
1034 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1036 if (fmap.elf_start && load_offset)
1038 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1039 "Assuming load address is corrupt\n", filename, load_offset);
1043 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1045 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1046 if (shstrtab == NO_MAP) goto leave;
1047 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1049 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1050 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1053 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1058 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1059 len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
1060 dyn.d_tag = DT_NULL;
1062 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1063 if (dyn.d_tag == DT_NULL) goto leave;
1064 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1067 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1070 if (elf_info->flags & ELF_INFO_MODULE)
1072 struct elf_module_info *elf_module_info =
1073 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1074 if (!elf_module_info) goto leave;
1075 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1076 (load_offset) ? load_offset : fmap.elf_start,
1077 fmap.elf_size, 0, calc_crc32(&fmap));
1078 if (!elf_info->module)
1080 HeapFree(GetProcessHeap(), 0, elf_module_info);
1083 elf_info->module->elf_info = elf_module_info;
1084 elf_info->module->elf_info->elf_addr = load_offset;
1086 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1088 elf_info->module->module.SymType = SymDeferred;
1091 else ret = elf_load_debug_info(elf_info->module, &fmap);
1093 elf_info->module->elf_info->elf_mark = 1;
1094 elf_info->module->elf_info->elf_loader = 0;
1097 if (elf_info->flags & ELF_INFO_NAME)
1099 elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1100 strlen(filename) + 1), filename);
1103 elf_unmap_file(&fmap);
1108 /******************************************************************
1109 * elf_load_file_from_path
1110 * tries to load an ELF file from a set of paths (separated by ':')
1112 static BOOL elf_load_file_from_path(HANDLE hProcess,
1113 const char* filename,
1114 unsigned long load_offset,
1116 struct elf_info* elf_info)
1122 if (!path) return FALSE;
1124 paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1125 for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
1129 fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1133 strcat(fn, filename);
1134 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1135 HeapFree(GetProcessHeap(), 0, fn);
1137 s = (t) ? (t+1) : NULL;
1140 HeapFree(GetProcessHeap(), 0, paths);
1144 /******************************************************************
1145 * elf_load_file_from_dll_path
1147 * Tries to load an ELF file from the dll path
1149 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1150 const char* filename,
1151 unsigned long load_offset,
1152 struct elf_info* elf_info)
1155 unsigned int index = 0;
1158 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1160 char *name = HeapAlloc( GetProcessHeap(), 0, strlen(path) + strlen(filename) + 2 );
1162 strcpy( name, path );
1163 strcat( name, "/" );
1164 strcat( name, filename );
1165 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1166 HeapFree( GetProcessHeap(), 0, name );
1171 /******************************************************************
1172 * elf_search_and_load_file
1174 * lookup a file in standard ELF locations, and if found, load it
1176 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1177 unsigned long load_offset,
1178 struct elf_info* elf_info)
1181 struct module* module;
1183 if (filename == NULL || *filename == '\0') return FALSE;
1184 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1186 elf_info->module = module;
1187 module->elf_info->elf_mark = 1;
1188 return module->module.SymType;
1191 if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1192 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1193 /* if relative pathname, try some absolute base dirs */
1194 if (!ret && !strchr(filename, '/'))
1196 ret = elf_load_file_from_path(pcs, filename, load_offset,
1197 getenv("PATH"), elf_info) ||
1198 elf_load_file_from_path(pcs, filename, load_offset,
1199 getenv("LD_LIBRARY_PATH"), elf_info);
1200 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1206 /******************************************************************
1207 * elf_enum_modules_internal
1209 * Enumerate ELF modules from a running process
1211 static BOOL elf_enum_modules_internal(const struct process* pcs,
1212 const char* main_name,
1213 elf_enum_modules_cb cb, void* user)
1215 struct r_debug dbg_hdr;
1220 if (!pcs->dbg_hdr_addr ||
1221 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1222 &dbg_hdr, sizeof(dbg_hdr), NULL))
1225 /* Now walk the linked list. In all known ELF implementations,
1226 * the dynamic loader maintains this linked list for us. In some
1227 * cases the first entry doesn't appear with a name, in other cases it
1230 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1232 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1235 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1236 lm.l_name != NULL &&
1237 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1239 bufstr[sizeof(bufstr) - 1] = '\0';
1240 if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1241 if (!cb(bufstr, (unsigned long)lm.l_addr, user)) break;
1249 struct process* pcs;
1250 struct elf_info elf_info;
1253 static BOOL elf_enum_sync_cb(const char* name, unsigned long addr, void* user)
1255 struct elf_sync* es = user;
1257 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1261 /******************************************************************
1262 * elf_synchronize_module_list
1264 * this functions rescans the debuggee module's list and synchronizes it with
1265 * the one from 'pcs', ie:
1266 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1267 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1269 BOOL elf_synchronize_module_list(struct process* pcs)
1271 struct module* module;
1274 for (module = pcs->lmodules; module; module = module->next)
1276 if (module->type == DMT_ELF && !module->is_virtual)
1277 module->elf_info->elf_mark = 0;
1281 es.elf_info.flags = ELF_INFO_MODULE;
1282 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1285 module = pcs->lmodules;
1288 if (module->type == DMT_ELF && !module->is_virtual &&
1289 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1291 module_remove(pcs, module);
1292 /* restart all over */
1293 module = pcs->lmodules;
1295 else module = module->next;
1300 /******************************************************************
1303 * Lookup in a running ELF process the loader, and sets its ELF link
1304 * address (for accessing the list of loaded .so libs) in pcs.
1305 * If flags is ELF_INFO_MODULE, the module for the loader is also
1306 * added as a module into pcs.
1308 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1313 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1314 * main executable (either wine-kthread or wine-pthread)
1315 * FIXME: the heuristic used to know whether we need to load wine-pthread
1316 * or wine-kthread is not 100% safe
1318 if ((ptr = getenv("WINELOADER")))
1319 ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1322 ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1323 elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1328 /******************************************************************
1329 * elf_read_wine_loader_dbg_info
1331 * Try to find a decent wine executable which could have loaded the debuggee
1333 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1335 struct elf_info elf_info;
1337 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1338 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1339 elf_info.module->elf_info->elf_loader = 1;
1340 strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
1341 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1344 /******************************************************************
1347 * Enumerates the ELF loaded modules from a running target (hProc)
1348 * This function doesn't require that someone has called SymInitialize
1349 * on this very process.
1351 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1354 struct elf_info elf_info;
1357 memset(&pcs, 0, sizeof(pcs));
1359 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1360 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1361 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1362 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1363 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1369 struct process* pcs;
1370 struct elf_info elf_info;
1375 /******************************************************************
1378 * Callback for elf_load_module, used to walk the list of loaded
1381 static BOOL elf_load_cb(const char* name, unsigned long addr, void* user)
1383 struct elf_load* el = user;
1386 /* memcmp is needed for matches when bufstr contains also version information
1387 * el->name: libc.so, name: libc.so.6.0
1389 p = strrchr(name, '/');
1391 if (!memcmp(p, el->name, strlen(el->name)))
1393 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1399 /******************************************************************
1402 * loads an ELF module and stores it in process' module list
1403 * Also, find module real name and load address from
1404 * the real loaded modules list in pcs address space
1406 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1410 TRACE("(%p %s %08lx)\n", pcs, name, addr);
1412 el.elf_info.flags = ELF_INFO_MODULE;
1415 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1418 /* do only the lookup from the filename, not the path (as we lookup module
1419 * name in the process' loaded module list)
1421 el.name = strrchr(name, '/');
1422 if (!el.name++) el.name = name;
1425 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1430 el.ret = elf_search_and_load_file(pcs, name, addr, &el.elf_info);
1432 if (!el.ret) return NULL;
1433 assert(el.elf_info.module);
1434 return el.elf_info.module;
1437 #else /* !__ELF__ */
1439 BOOL elf_synchronize_module_list(struct process* pcs)
1444 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1445 DWORD* size, DWORD* checksum)
1450 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1455 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1460 struct module* elf_load_module(struct process* pcs, const char* name, DWORD addr)
1465 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1469 #endif /* __ELF__ */