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))
328 compiland = symname ? symt_new_compiland(module, source_new(module, NULL, symname)) : NULL;
331 /* we are only interested in wine markers inserted by winebuild */
332 for (j = 0; thunks[j].symname; j++)
334 if (!strcmp(symname, thunks[j].symname))
336 thunks[j].rva_start = symp->st_value;
337 thunks[j].rva_end = symp->st_value + symp->st_size;
344 /* FIXME: we don't need to handle them (GCC internals)
345 * Moreover, they screw up our symbol lookup :-/
347 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
350 ste = pool_alloc(pool, sizeof(*ste));
351 ste->ht_elt.name = symname;
352 /* GCC emits, in some cases, a .<digit>+ suffix.
353 * This is used for static variable inside functions, so
354 * that we can have several such variables with same name in
355 * the same compilation unit
356 * We simply ignore that suffix when present (we also get rid
357 * of it in stabs parsing)
359 ptr = symname + strlen(symname) - 1;
362 while (isdigit(*ptr) && ptr >= symname) ptr--;
363 if (ptr > symname && *ptr == '.')
365 char* n = pool_alloc(pool, ptr - symname + 1);
366 memcpy(n, symname, ptr - symname + 1);
367 n[ptr - symname] = '\0';
368 ste->ht_elt.name = n;
372 ste->compiland = compiland;
374 hash_table_add(ht_symtab, &ste->ht_elt);
376 /* as we added in the ht_symtab pointers to the symbols themselves,
377 * we cannot unmap yet the sections, it will be done when we're over
382 /******************************************************************
385 * lookup a symbol by name in our internal hash table for the symtab
387 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
388 const struct hash_table* ht_symtab,
389 const char* name, struct symt* compiland)
391 struct symtab_elt* weak_result = NULL; /* without compiland name */
392 struct symtab_elt* result = NULL;
393 struct hash_table_iter hti;
394 struct symtab_elt* ste;
395 const char* compiland_name;
396 const char* compiland_basename;
399 /* we need weak match up (at least) when symbols of same name,
400 * defined several times in different compilation units,
401 * are merged in a single one (hence a different filename for c.u.)
405 compiland_name = source_get(module,
406 ((struct symt_compiland*)compiland)->source);
407 compiland_basename = strrchr(compiland_name, '/');
408 if (!compiland_basename++) compiland_basename = compiland_name;
410 else compiland_name = compiland_basename = NULL;
412 hash_table_iter_init(ht_symtab, &hti, name);
413 while ((ste = hash_table_iter_up(&hti)))
415 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
418 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
420 if (ste->compiland && compiland_name)
422 const char* filename = source_get(module, ste->compiland->source);
423 if (strcmp(filename, compiland_name))
425 base = strrchr(filename, '/');
426 if (!base++) base = filename;
427 if (strcmp(base, compiland_basename)) continue;
432 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
433 name, compiland_name,
434 source_get(module, result->compiland->source), result->symp->st_value,
435 source_get(module, ste->compiland->source), ste->symp->st_value);
443 if (!result && !(result = weak_result))
445 FIXME("Couldn't find symbol %s!%s in symtab\n",
446 module->module.ModuleName, name);
452 /******************************************************************
453 * elf_finish_stabs_info
455 * - get any relevant information (address & size) from the bits we got from the
456 * stabs debugging information
458 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
460 struct hash_table_iter hti;
463 const Elf32_Sym* symp;
465 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
466 while ((ptr = hash_table_iter_up(&hti)))
468 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
469 switch (sym->symt.tag)
472 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
473 ((struct symt_function*)sym)->size)
477 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
478 ((struct symt_function*)sym)->container);
481 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
482 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
483 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
484 sym, module->module.ModuleName, sym->hash_elt.name,
485 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
486 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
487 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
488 sym, module->module.ModuleName, sym->hash_elt.name,
489 ((struct symt_function*)sym)->size, symp->st_size);
491 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
493 ((struct symt_function*)sym)->size = symp->st_size;
494 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
497 switch (((struct symt_data*)sym)->kind)
500 case DataIsFileStatic:
501 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr)
503 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
504 ((struct symt_data*)sym)->container);
507 if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr &&
508 ((struct symt_data*)sym)->u.address != module->elf_info->elf_addr + symp->st_value)
509 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
510 sym, module->module.ModuleName, sym->hash_elt.name,
511 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
512 ((struct symt_data*)sym)->u.address = module->elf_info->elf_addr +
514 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
515 DataIsFileStatic : DataIsGlobal;
516 } else FIXME("Couldn't find %s!%s\n", module->module.ModuleName, sym->hash_elt.name);
522 FIXME("Unsupported tag %u\n", sym->symt.tag);
526 /* since we may have changed some addresses & sizes, mark the module to be resorted */
527 module->sortlist_valid = FALSE;
530 /******************************************************************
531 * elf_load_wine_thunks
533 * creating the thunk objects for a wine native DLL
535 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
536 const struct elf_thunk_area* thunks)
539 struct hash_table_iter hti;
540 struct symtab_elt* ste;
544 hash_table_iter_init(ht_symtab, &hti, NULL);
545 while ((ste = hash_table_iter_up(&hti)))
547 if (ste->used) continue;
549 addr = module->elf_info->elf_addr + ste->symp->st_value;
551 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
552 if (j >= 0) /* thunk found */
554 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
555 addr, ste->symp->st_size);
561 idx = symt_find_nearest(module, addr);
563 symt_get_info(&module->addr_sorttab[idx]->symt,
564 TI_GET_ADDRESS, &ref_addr);
565 if (idx == -1 || addr != ref_addr)
567 /* creating public symbols for all the ELF symbols which haven't been
568 * used yet (ie we have no debug information on them)
569 * That's the case, for example, of the .spec.c files
571 switch (ELF32_ST_TYPE(ste->symp->st_info))
574 symt_new_function(module, ste->compiland, ste->ht_elt.name,
575 addr, ste->symp->st_size, NULL);
578 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
579 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
580 addr, ste->symp->st_size, NULL);
583 FIXME("Shouldn't happen\n");
586 /* FIXME: this is a hack !!!
587 * we are adding new symbols, but as we're parsing a symbol table
588 * (hopefully without duplicate symbols) we delay rebuilding the sorted
589 * module table until we're done with the symbol table
590 * Otherwise, as we intertwine symbols's add and lookup, performance
593 module->sortlist_valid = TRUE;
595 else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name))
597 ULONG64 xaddr = 0, xsize = 0;
600 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr);
601 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize);
602 symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind);
604 /* If none of symbols has a correct size, we consider they are both markers
605 * Hence, we can silence this warning
606 * Also, we check that we don't have two symbols, one local, the other
607 * global which is legal
609 if ((xsize || ste->symp->st_size) &&
610 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
611 FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%s>\n",
612 module->module.ModuleName,
613 ste->ht_elt.name, addr, ste->symp->st_size,
614 module->addr_sorttab[idx]->hash_elt.name,
615 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
619 /* see comment above */
620 module->sortlist_valid = FALSE;
624 /******************************************************************
625 * elf_new_public_symbols
627 * Creates a set of public symbols from an ELF symtab
629 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
631 struct hash_table_iter hti;
632 struct symtab_elt* ste;
634 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
636 /* FIXME: we're missing the ELF entry point here */
638 hash_table_iter_init(symtab, &hti, NULL);
639 while ((ste = hash_table_iter_up(&hti)))
641 symt_new_public(module, ste->compiland, ste->ht_elt.name,
642 module->elf_info->elf_addr + ste->symp->st_value,
643 ste->symp->st_size, TRUE /* FIXME */,
644 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
649 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
650 the following calc_crc32 code or tables extracted from it, as desired without
653 /**********************************************************************\
654 |* Demonstration program to compute the 32-bit CRC used as the frame *|
655 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
656 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
657 |* protocol). The 32-bit FCS was added via the Federal Register, *|
658 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
659 |* this polynomial is or will be included in CCITT V.41, which *|
660 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
661 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
662 |* errors by a factor of 10^-5 over 16-bit FCS. *|
663 \**********************************************************************/
665 /* First, the polynomial itself and its table of feedback terms. The */
667 /* 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 */
668 /* Note that we take it "backwards" and put the highest-order term in */
669 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
670 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
671 /* the MSB being 1. */
673 /* Note that the usual hardware shift register implementation, which */
674 /* is what we're using (we're merely optimizing it by doing eight-bit */
675 /* chunks at a time) shifts bits into the lowest-order term. In our */
676 /* implementation, that means shifting towards the right. Why do we */
677 /* do it this way? Because the calculated CRC must be transmitted in */
678 /* order from highest-order term to lowest-order term. UARTs transmit */
679 /* characters in order from LSB to MSB. By storing the CRC this way, */
680 /* we hand it to the UART in the order low-byte to high-byte; the UART */
681 /* sends each low-bit to hight-bit; and the result is transmission bit */
682 /* by bit from highest- to lowest-order term without requiring any bit */
683 /* shuffling on our part. Reception works similarly. */
685 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
687 /* 1. The table can be generated at runtime if desired; code to do so */
688 /* is shown later. It might not be obvious, but the feedback */
689 /* terms simply represent the results of eight shift/xor opera- */
690 /* tions for all combinations of data and CRC register values. */
692 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
693 /* be they sixteen or thirty-two bits wide. You simply choose the */
694 /* appropriate table. Alternatively, because the table can be */
695 /* generated at runtime, you can start by generating the table for */
696 /* the polynomial in question and use exactly the same "updcrc", */
697 /* if your application needn't simultaneously handle two CRC */
698 /* polynomials. (Note, however, that XMODEM is strange.) */
700 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
701 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
703 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
704 /* logic; the shift must be unsigned (bring in zeroes). On some */
705 /* hardware you could probably optimize the shift in assembler by */
706 /* using byte-swap instructions. */
709 static DWORD calc_crc32(struct elf_file_map* fmap)
711 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
712 static const DWORD crc_32_tab[] =
713 { /* CRC polynomial 0xedb88320 */
714 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
715 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
716 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
717 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
718 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
719 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
720 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
721 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
722 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
723 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
724 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
725 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
726 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
727 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
728 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
729 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
730 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
731 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
732 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
733 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
734 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
735 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
736 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
737 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
738 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
739 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
740 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
741 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
742 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
743 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
744 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
745 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
746 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
747 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
748 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
749 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
750 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
751 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
752 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
753 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
754 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
755 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
756 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
759 unsigned char buffer[256];
762 lseek(fmap->fd, 0, SEEK_SET);
763 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
765 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
771 /******************************************************************
772 * elf_load_debug_info_from_map
774 * Loads the symbolic information from ELF module which mapping is described
776 * the module has been loaded at 'load_offset' address, so symbols' address
777 * relocation is performed.
778 * CRC is checked if fmap->with_crc is TRUE
780 * 0 if the file doesn't contain symbolic info (or this info cannot be
784 static BOOL elf_load_debug_info_from_map(struct module* module,
785 struct elf_file_map* fmap,
787 struct hash_table* ht_symtab)
789 BOOL ret = FALSE, lret;
790 const char* shstrtab;
792 int symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
793 int debug_sect, debug_str_sect, debug_abbrev_sect, debug_line_sect;
795 struct elf_thunk_area thunks[] =
797 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
798 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
799 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
800 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
801 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
802 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
806 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
808 ERR("Bad CRC for module %s (got %08lx while expecting %08lx)\n",
809 module->module.ImageName, calc_crc32(fmap), fmap->crc);
810 /* we don't tolerate mis-matched files */
815 * Next, we need to find a few of the internal ELF headers within
816 * this thing. We need the main executable header, and the section
819 shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
820 if (shstrtab == ELF_NO_MAP) return FALSE;
822 symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
823 debug_sect = debug_str_sect = debug_abbrev_sect = debug_line_sect = -1;
826 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
828 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
830 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
832 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
834 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
836 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
837 debug_abbrev_sect = i;
838 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
840 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
842 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
843 (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
845 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
846 (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
849 elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
852 if (symtab_sect == -1)
854 /* if we don't have a symtab but a dynsym, process the dynsym
855 * section instead. It'll contain less (relevant) information,
856 * but it'll be better than nothing
858 if (dynsym_sect == -1) return FALSE;
859 symtab_sect = dynsym_sect;
862 module->module.SymType = SymExport;
864 /* create a hash table for the symtab */
865 elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
867 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
869 if (stab_sect != -1 && stabstr_sect != -1)
874 stab = elf_map_section(fmap, stab_sect);
875 stabstr = elf_map_section(fmap, stabstr_sect);
876 if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP)
878 /* OK, now just parse all of the stabs. */
879 lret = stabs_parse(module, module->elf_info->elf_addr,
880 stab, elf_get_map_size(fmap, stab_sect),
881 stabstr, elf_get_map_size(fmap, stabstr_sect));
883 /* and fill in the missing information for stabs */
884 elf_finish_stabs_info(module, ht_symtab);
886 WARN("Couldn't correctly read stabs\n");
890 elf_unmap_section(fmap, stab_sect);
891 elf_unmap_section(fmap, stabstr_sect);
894 if (debug_sect != -1)
896 /* Dwarf 2 debug information */
897 const BYTE* dw2_debug;
898 const BYTE* dw2_debug_abbrev;
899 const BYTE* dw2_debug_str;
900 const BYTE* dw2_debug_line;
902 FIXME("Alpha-support for Dwarf2 information for %s\n", module->module.ModuleName);
904 dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
905 dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
906 dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
907 dw2_debug_line = (const BYTE*) elf_map_section(fmap, debug_line_sect);
908 if (dw2_debug != ELF_NO_MAP && ELF_NO_MAP != dw2_debug_abbrev && dw2_debug_str != ELF_NO_MAP)
910 /* OK, now just parse dwarf2 debug infos. */
911 lret = dwarf2_parse(module, module->elf_info->elf_addr, thunks,
912 dw2_debug, elf_get_map_size(fmap, debug_sect),
913 dw2_debug_abbrev, elf_get_map_size(fmap, debug_abbrev_sect),
914 dw2_debug_str, elf_get_map_size(fmap, debug_str_sect),
915 dw2_debug_line, elf_get_map_size(fmap, debug_line_sect));
917 WARN("Couldn't correctly read stabs\n");
920 elf_unmap_section(fmap, debug_sect);
921 elf_unmap_section(fmap, debug_abbrev_sect);
922 elf_unmap_section(fmap, debug_str_sect);
923 elf_unmap_section(fmap, debug_line_sect);
925 if (debuglink_sect != -1)
927 const char* dbg_link;
928 struct elf_file_map fmap_link;
930 dbg_link = elf_map_section(fmap, debuglink_sect);
931 /* The content of a debug link section is:
932 * 1/ a NULL terminated string, containing the file name for the
934 * 2/ padding on 4 byte boundary
935 * 3/ CRC of the linked ELF file
937 if (dbg_link != ELF_NO_MAP && elf_map_file(dbg_link, &fmap_link))
939 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
940 fmap_link.with_crc = 1;
941 lret = elf_load_debug_info_from_map(module, &fmap_link, pool,
944 strcpy(module->module.LoadedPdbName, dbg_link);
946 WARN("Couldn't load debug information from %s\n", dbg_link);
950 WARN("Couldn't load linked debug file for %s\n",
951 module->module.ModuleName);
952 elf_unmap_file(&fmap_link);
955 if (strstr(module->module.ModuleName, "<elf>") ||
956 !strcmp(module->module.ModuleName, "<wine-loader>"))
958 /* add the thunks for native libraries */
959 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
960 elf_new_wine_thunks(module, ht_symtab, thunks);
962 /* add all the public symbols from symtab */
963 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
968 /******************************************************************
969 * elf_load_debug_info
971 * Loads ELF debugging information from the module image file.
973 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
977 struct hash_table ht_symtab;
978 struct elf_file_map my_fmap;
980 if (module->type != DMT_ELF || !module->elf_info)
982 ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
986 pool_init(&pool, 65536);
987 hash_table_init(&pool, &ht_symtab, 256);
992 ret = elf_map_file(module->module.LoadedImageName, fmap);
995 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
998 if (fmap == &my_fmap) elf_unmap_file(fmap);
1002 /******************************************************************
1003 * elf_fetch_file_info
1005 * Gathers some more information for an ELF module from a given file
1007 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1008 DWORD* size, DWORD* checksum)
1010 struct elf_file_map fmap;
1011 if (!elf_map_file(name, &fmap)) return FALSE;
1012 if (base) *base = fmap.elf_start;
1013 *size = fmap.elf_size;
1014 *checksum = calc_crc32(&fmap);
1015 elf_unmap_file(&fmap);
1019 /******************************************************************
1021 * returns true iff the section tag is valid
1023 static unsigned is_dt_flag_valid(unsigned d_tag)
1026 #define DT_PROCNUM 0
1029 #define DT_EXTRANUM 0
1031 return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
1032 #if defined(DT_LOOS) && defined(DT_HIOS)
1033 || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
1035 #if defined(DT_LOPROC) && defined(DT_HIPROC)
1036 || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
1041 /******************************************************************
1044 * Loads the information for ELF module stored in 'filename'
1045 * the module has been loaded at 'load_offset' address
1047 * -1 if the file cannot be found/opened
1048 * 0 if the file doesn't contain symbolic info (or this info cannot be
1052 static BOOL elf_load_file(struct process* pcs, const char* filename,
1053 unsigned long load_offset, struct elf_info* elf_info)
1056 struct elf_file_map fmap;
1059 TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1061 if (!elf_map_file(filename, &fmap)) goto leave;
1063 /* Next, we need to find a few of the internal ELF headers within
1064 * this thing. We need the main executable header, and the section
1067 if (!fmap.elf_start && !load_offset)
1068 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1070 if (fmap.elf_start && load_offset)
1072 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1073 "Assuming load address is corrupt\n", filename, load_offset);
1077 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1079 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1080 if (shstrtab == ELF_NO_MAP) goto leave;
1081 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1083 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1084 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1087 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1092 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1093 len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
1094 dyn.d_tag = DT_NULL;
1096 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1097 if (dyn.d_tag == DT_NULL) goto leave;
1098 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1101 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1104 if (elf_info->flags & ELF_INFO_MODULE)
1106 struct elf_module_info *elf_module_info =
1107 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1108 if (!elf_module_info) goto leave;
1109 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1110 (load_offset) ? load_offset : fmap.elf_start,
1111 fmap.elf_size, 0, calc_crc32(&fmap));
1112 if (!elf_info->module)
1114 HeapFree(GetProcessHeap(), 0, elf_module_info);
1117 elf_info->module->elf_info = elf_module_info;
1118 elf_info->module->elf_info->elf_addr = load_offset;
1120 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1122 elf_info->module->module.SymType = SymDeferred;
1125 else ret = elf_load_debug_info(elf_info->module, &fmap);
1127 elf_info->module->elf_info->elf_mark = 1;
1128 elf_info->module->elf_info->elf_loader = 0;
1131 if (elf_info->flags & ELF_INFO_NAME)
1133 elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1134 strlen(filename) + 1), filename);
1137 elf_unmap_file(&fmap);
1142 /******************************************************************
1143 * elf_load_file_from_path
1144 * tries to load an ELF file from a set of paths (separated by ':')
1146 static BOOL elf_load_file_from_path(HANDLE hProcess,
1147 const char* filename,
1148 unsigned long load_offset,
1150 struct elf_info* elf_info)
1156 if (!path) return FALSE;
1158 paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1159 for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
1163 fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1167 strcat(fn, filename);
1168 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1169 HeapFree(GetProcessHeap(), 0, fn);
1171 s = (t) ? (t+1) : NULL;
1174 HeapFree(GetProcessHeap(), 0, paths);
1178 /******************************************************************
1179 * elf_load_file_from_dll_path
1181 * Tries to load an ELF file from the dll path
1183 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1184 const char* filename,
1185 unsigned long load_offset,
1186 struct elf_info* elf_info)
1189 unsigned int index = 0;
1192 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1194 char *name = HeapAlloc( GetProcessHeap(), 0, strlen(path) + strlen(filename) + 2 );
1196 strcpy( name, path );
1197 strcat( name, "/" );
1198 strcat( name, filename );
1199 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1200 HeapFree( GetProcessHeap(), 0, name );
1205 /******************************************************************
1206 * elf_search_and_load_file
1208 * lookup a file in standard ELF locations, and if found, load it
1210 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1211 unsigned long load_offset,
1212 struct elf_info* elf_info)
1215 struct module* module;
1217 if (filename == NULL || *filename == '\0') return FALSE;
1218 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1220 elf_info->module = module;
1221 module->elf_info->elf_mark = 1;
1222 return module->module.SymType;
1225 if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1226 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1227 /* if relative pathname, try some absolute base dirs */
1228 if (!ret && !strchr(filename, '/'))
1230 ret = elf_load_file_from_path(pcs, filename, load_offset,
1231 getenv("PATH"), elf_info) ||
1232 elf_load_file_from_path(pcs, filename, load_offset,
1233 getenv("LD_LIBRARY_PATH"), elf_info);
1234 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1240 /******************************************************************
1241 * elf_enum_modules_internal
1243 * Enumerate ELF modules from a running process
1245 static BOOL elf_enum_modules_internal(const struct process* pcs,
1246 const char* main_name,
1247 elf_enum_modules_cb cb, void* user)
1249 struct r_debug dbg_hdr;
1254 if (!pcs->dbg_hdr_addr ||
1255 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1256 &dbg_hdr, sizeof(dbg_hdr), NULL))
1259 /* Now walk the linked list. In all known ELF implementations,
1260 * the dynamic loader maintains this linked list for us. In some
1261 * cases the first entry doesn't appear with a name, in other cases it
1264 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1266 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1269 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1270 lm.l_name != NULL &&
1271 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1273 bufstr[sizeof(bufstr) - 1] = '\0';
1274 if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1275 if (!cb(bufstr, (unsigned long)lm.l_addr, user)) break;
1283 struct process* pcs;
1284 struct elf_info elf_info;
1287 static BOOL elf_enum_sync_cb(const char* name, unsigned long addr, void* user)
1289 struct elf_sync* es = user;
1291 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1295 /******************************************************************
1296 * elf_synchronize_module_list
1298 * this functions rescans the debuggee module's list and synchronizes it with
1299 * the one from 'pcs', ie:
1300 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1301 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1303 BOOL elf_synchronize_module_list(struct process* pcs)
1305 struct module* module;
1308 for (module = pcs->lmodules; module; module = module->next)
1310 if (module->type == DMT_ELF && !module->is_virtual)
1311 module->elf_info->elf_mark = 0;
1315 es.elf_info.flags = ELF_INFO_MODULE;
1316 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1319 module = pcs->lmodules;
1322 if (module->type == DMT_ELF && !module->is_virtual &&
1323 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1325 module_remove(pcs, module);
1326 /* restart all over */
1327 module = pcs->lmodules;
1329 else module = module->next;
1334 /******************************************************************
1337 * Lookup in a running ELF process the loader, and sets its ELF link
1338 * address (for accessing the list of loaded .so libs) in pcs.
1339 * If flags is ELF_INFO_MODULE, the module for the loader is also
1340 * added as a module into pcs.
1342 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1347 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1348 * main executable (either wine-kthread or wine-pthread)
1349 * FIXME: the heuristic used to know whether we need to load wine-pthread
1350 * or wine-kthread is not 100% safe
1352 if ((ptr = getenv("WINELOADER")))
1353 ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1356 ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1357 elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1362 /******************************************************************
1363 * elf_read_wine_loader_dbg_info
1365 * Try to find a decent wine executable which could have loaded the debuggee
1367 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1369 struct elf_info elf_info;
1371 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1372 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1373 elf_info.module->elf_info->elf_loader = 1;
1374 strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
1375 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1378 /******************************************************************
1381 * Enumerates the ELF loaded modules from a running target (hProc)
1382 * This function doesn't require that someone has called SymInitialize
1383 * on this very process.
1385 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1388 struct elf_info elf_info;
1391 memset(&pcs, 0, sizeof(pcs));
1393 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1394 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1395 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1396 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1397 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1403 struct process* pcs;
1404 struct elf_info elf_info;
1409 /******************************************************************
1412 * Callback for elf_load_module, used to walk the list of loaded
1415 static BOOL elf_load_cb(const char* name, unsigned long addr, void* user)
1417 struct elf_load* el = user;
1420 /* memcmp is needed for matches when bufstr contains also version information
1421 * el->name: libc.so, name: libc.so.6.0
1423 p = strrchr(name, '/');
1425 if (!memcmp(p, el->name, strlen(el->name)))
1427 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1433 /******************************************************************
1436 * loads an ELF module and stores it in process' module list
1437 * Also, find module real name and load address from
1438 * the real loaded modules list in pcs address space
1440 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1444 TRACE("(%p %s %08lx)\n", pcs, name, addr);
1446 el.elf_info.flags = ELF_INFO_MODULE;
1449 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1452 /* do only the lookup from the filename, not the path (as we lookup module
1453 * name in the process' loaded module list)
1455 el.name = strrchr(name, '/');
1456 if (!el.name++) el.name = name;
1459 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1464 el.ret = elf_search_and_load_file(pcs, name, addr, &el.elf_info);
1466 if (!el.ret) return NULL;
1467 assert(el.elf_info.module);
1468 return el.elf_info.module;
1471 #else /* !__ELF__ */
1473 BOOL elf_synchronize_module_list(struct process* pcs)
1478 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1479 DWORD* size, DWORD* checksum)
1484 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1489 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1494 struct module* elf_load_module(struct process* pcs, const char* name, DWORD addr)
1499 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1504 int elf_is_in_thunk_area(unsigned long addr,
1505 const struct elf_thunk_area* thunks)
1509 #endif /* __ELF__ */