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
1044 return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM)
1045 #if defined(DT_LOOS) && defined(DT_HIOS)
1046 || (d_tag >= DT_LOOS && d_tag < DT_HIOS)
1048 #if defined(DT_LOPROC) && defined(DT_HIPROC)
1049 || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC)
1054 /******************************************************************
1057 * Loads the information for ELF module stored in 'filename'
1058 * the module has been loaded at 'load_offset' address
1060 * -1 if the file cannot be found/opened
1061 * 0 if the file doesn't contain symbolic info (or this info cannot be
1065 static BOOL elf_load_file(struct process* pcs, const char* filename,
1066 unsigned long load_offset, struct elf_info* elf_info)
1069 struct elf_file_map fmap;
1072 TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1074 if (!elf_map_file(filename, &fmap)) goto leave;
1076 /* Next, we need to find a few of the internal ELF headers within
1077 * this thing. We need the main executable header, and the section
1080 if (!fmap.elf_start && !load_offset)
1081 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1083 if (fmap.elf_start && load_offset)
1085 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1086 "Assuming load address is corrupt\n", filename, load_offset);
1090 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1092 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1093 if (shstrtab == ELF_NO_MAP) goto leave;
1094 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1096 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1097 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1100 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1105 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1106 len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag))
1107 dyn.d_tag = DT_NULL;
1109 } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL);
1110 if (dyn.d_tag == DT_NULL) goto leave;
1111 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1114 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1117 if (elf_info->flags & ELF_INFO_MODULE)
1119 struct elf_module_info *elf_module_info =
1120 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1121 if (!elf_module_info) goto leave;
1122 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1123 (load_offset) ? load_offset : fmap.elf_start,
1124 fmap.elf_size, 0, calc_crc32(&fmap));
1125 if (!elf_info->module)
1127 HeapFree(GetProcessHeap(), 0, elf_module_info);
1130 elf_info->module->elf_info = elf_module_info;
1131 elf_info->module->elf_info->elf_addr = load_offset;
1133 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1135 elf_info->module->module.SymType = SymDeferred;
1138 else ret = elf_load_debug_info(elf_info->module, &fmap);
1140 elf_info->module->elf_info->elf_mark = 1;
1141 elf_info->module->elf_info->elf_loader = 0;
1144 if (elf_info->flags & ELF_INFO_NAME)
1146 elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1147 strlen(filename) + 1), filename);
1150 elf_unmap_file(&fmap);
1155 /******************************************************************
1156 * elf_load_file_from_path
1157 * tries to load an ELF file from a set of paths (separated by ':')
1159 static BOOL elf_load_file_from_path(HANDLE hProcess,
1160 const char* filename,
1161 unsigned long load_offset,
1163 struct elf_info* elf_info)
1169 if (!path) return FALSE;
1171 paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1172 for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
1176 fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1180 strcat(fn, filename);
1181 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1182 HeapFree(GetProcessHeap(), 0, fn);
1184 s = (t) ? (t+1) : NULL;
1187 HeapFree(GetProcessHeap(), 0, paths);
1191 /******************************************************************
1192 * elf_load_file_from_dll_path
1194 * Tries to load an ELF file from the dll path
1196 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1197 const char* filename,
1198 unsigned long load_offset,
1199 struct elf_info* elf_info)
1202 unsigned int index = 0;
1205 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1207 char *name = HeapAlloc( GetProcessHeap(), 0, strlen(path) + strlen(filename) + 2 );
1209 strcpy( name, path );
1210 strcat( name, "/" );
1211 strcat( name, filename );
1212 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1213 HeapFree( GetProcessHeap(), 0, name );
1218 /******************************************************************
1219 * elf_search_and_load_file
1221 * lookup a file in standard ELF locations, and if found, load it
1223 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1224 unsigned long load_offset,
1225 struct elf_info* elf_info)
1228 struct module* module;
1230 if (filename == NULL || *filename == '\0') return FALSE;
1231 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1233 elf_info->module = module;
1234 module->elf_info->elf_mark = 1;
1235 return module->module.SymType;
1238 if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1239 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1240 /* if relative pathname, try some absolute base dirs */
1241 if (!ret && !strchr(filename, '/'))
1243 ret = elf_load_file_from_path(pcs, filename, load_offset,
1244 getenv("PATH"), elf_info) ||
1245 elf_load_file_from_path(pcs, filename, load_offset,
1246 getenv("LD_LIBRARY_PATH"), elf_info);
1247 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1253 /******************************************************************
1254 * elf_enum_modules_internal
1256 * Enumerate ELF modules from a running process
1258 static BOOL elf_enum_modules_internal(const struct process* pcs,
1259 const char* main_name,
1260 elf_enum_modules_cb cb, void* user)
1262 struct r_debug dbg_hdr;
1267 if (!pcs->dbg_hdr_addr ||
1268 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1269 &dbg_hdr, sizeof(dbg_hdr), NULL))
1272 /* Now walk the linked list. In all known ELF implementations,
1273 * the dynamic loader maintains this linked list for us. In some
1274 * cases the first entry doesn't appear with a name, in other cases it
1277 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1279 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1282 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1283 lm.l_name != NULL &&
1284 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1286 bufstr[sizeof(bufstr) - 1] = '\0';
1287 if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1288 if (!cb(bufstr, (unsigned long)lm.l_addr, user)) break;
1296 struct process* pcs;
1297 struct elf_info elf_info;
1300 static BOOL elf_enum_sync_cb(const char* name, unsigned long addr, void* user)
1302 struct elf_sync* es = user;
1304 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1308 /******************************************************************
1309 * elf_synchronize_module_list
1311 * this functions rescans the debuggee module's list and synchronizes it with
1312 * the one from 'pcs', ie:
1313 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1314 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1316 BOOL elf_synchronize_module_list(struct process* pcs)
1318 struct module* module;
1321 for (module = pcs->lmodules; module; module = module->next)
1323 if (module->type == DMT_ELF && !module->is_virtual)
1324 module->elf_info->elf_mark = 0;
1328 es.elf_info.flags = ELF_INFO_MODULE;
1329 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1332 module = pcs->lmodules;
1335 if (module->type == DMT_ELF && !module->is_virtual &&
1336 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1338 module_remove(pcs, module);
1339 /* restart all over */
1340 module = pcs->lmodules;
1342 else module = module->next;
1347 /******************************************************************
1350 * Lookup in a running ELF process the loader, and sets its ELF link
1351 * address (for accessing the list of loaded .so libs) in pcs.
1352 * If flags is ELF_INFO_MODULE, the module for the loader is also
1353 * added as a module into pcs.
1355 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1360 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1361 * main executable (either wine-kthread or wine-pthread)
1362 * FIXME: the heuristic used to know whether we need to load wine-pthread
1363 * or wine-kthread is not 100% safe
1365 if ((ptr = getenv("WINELOADER")))
1366 ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1369 ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1370 elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1375 /******************************************************************
1376 * elf_read_wine_loader_dbg_info
1378 * Try to find a decent wine executable which could have loaded the debuggee
1380 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1382 struct elf_info elf_info;
1384 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1385 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1386 elf_info.module->elf_info->elf_loader = 1;
1387 strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
1388 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1391 /******************************************************************
1394 * Enumerates the ELF loaded modules from a running target (hProc)
1395 * This function doesn't require that someone has called SymInitialize
1396 * on this very process.
1398 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1401 struct elf_info elf_info;
1404 memset(&pcs, 0, sizeof(pcs));
1406 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1407 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1408 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1409 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1410 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1416 struct process* pcs;
1417 struct elf_info elf_info;
1422 /******************************************************************
1425 * Callback for elf_load_module, used to walk the list of loaded
1428 static BOOL elf_load_cb(const char* name, unsigned long addr, void* user)
1430 struct elf_load* el = user;
1433 /* memcmp is needed for matches when bufstr contains also version information
1434 * el->name: libc.so, name: libc.so.6.0
1436 p = strrchr(name, '/');
1438 if (!memcmp(p, el->name, strlen(el->name)))
1440 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1446 /******************************************************************
1449 * loads an ELF module and stores it in process' module list
1450 * Also, find module real name and load address from
1451 * the real loaded modules list in pcs address space
1453 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1457 TRACE("(%p %s %08lx)\n", pcs, name, addr);
1459 el.elf_info.flags = ELF_INFO_MODULE;
1462 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1465 /* do only the lookup from the filename, not the path (as we lookup module
1466 * name in the process' loaded module list)
1468 el.name = strrchr(name, '/');
1469 if (!el.name++) el.name = name;
1472 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1477 el.ret = elf_search_and_load_file(pcs, name, addr, &el.elf_info);
1479 if (!el.ret) return NULL;
1480 assert(el.elf_info.module);
1481 return el.elf_info.module;
1484 #else /* !__ELF__ */
1486 BOOL elf_synchronize_module_list(struct process* pcs)
1491 BOOL elf_fetch_file_info(const char* name, DWORD* base,
1492 DWORD* size, DWORD* checksum)
1497 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1502 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1507 struct module* elf_load_module(struct process* pcs, const char* name, unsigned long addr)
1512 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1517 int elf_is_in_thunk_area(unsigned long addr,
1518 const struct elf_thunk_area* thunks)
1522 #endif /* __ELF__ */