2 * File elf.c - processing of ELF files
4 * Copyright (C) 1996, Eric Youngdale.
5 * 1999-2007 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 struct elf_module_info
80 unsigned long elf_addr;
81 unsigned short elf_mark : 1,
87 #define ELF_INFO_DEBUG_HEADER 0x0001
88 #define ELF_INFO_MODULE 0x0002
89 #define ELF_INFO_NAME 0x0004
91 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
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)) - ofst;
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 unsigned pgsz = getpagesize();
169 ofst = fmap->sect[sidx].shdr.sh_offset & ~(pgsz - 1);
170 size = ((fmap->sect[sidx].shdr.sh_offset +
171 fmap->sect[sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst;
172 if (munmap((char*)fmap->sect[sidx].mapped, size) < 0)
173 WARN("Couldn't unmap the section\n");
174 fmap->sect[sidx].mapped = ELF_NO_MAP;
178 /******************************************************************
181 * Get the size of an ELF section
183 static inline unsigned elf_get_map_size(struct elf_file_map* fmap, int sidx)
185 if (sidx < 0 || sidx >= fmap->elfhdr.e_shnum)
187 return fmap->sect[sidx].shdr.sh_size;
190 /******************************************************************
193 * Maps an ELF file into memory (and checks it's a real ELF file)
195 static BOOL elf_map_file(const char* filename, struct elf_file_map* fmap)
197 static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
201 unsigned tmp, page_mask = getpagesize() - 1;
207 /* check that the file exists, and that the module hasn't been loaded yet */
208 if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) return FALSE;
210 /* Now open the file, so that we can mmap() it. */
211 if ((fmap->fd = open(filename, O_RDONLY)) == -1) return FALSE;
213 if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr))
215 /* and check for an ELF header */
216 if (memcmp(fmap->elfhdr.e_ident,
217 elf_signature, sizeof(elf_signature))) return FALSE;
219 fmap->sect = HeapAlloc(GetProcessHeap(), 0,
220 fmap->elfhdr.e_shnum * sizeof(fmap->sect[0]));
221 if (!fmap->sect) return FALSE;
223 lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET);
224 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
226 read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr));
227 fmap->sect[i].mapped = ELF_NO_MAP;
230 /* grab size of module once loaded in memory */
231 lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET);
233 fmap->elf_start = ~0L;
234 for (i = 0; i < fmap->elfhdr.e_phnum; i++)
236 if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) &&
237 phdr.p_type == PT_LOAD)
239 tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
240 if (fmap->elf_size < tmp) fmap->elf_size = tmp;
241 if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr;
244 /* if non relocatable ELF, then remove fixed address from computation
245 * otherwise, all addresses are zero based and start has no effect
247 fmap->elf_size -= fmap->elf_start;
251 /******************************************************************
254 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
256 static void elf_unmap_file(struct elf_file_map* fmap)
261 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
263 elf_unmap_section(fmap, i);
265 HeapFree(GetProcessHeap(), 0, fmap->sect);
270 /******************************************************************
271 * elf_is_in_thunk_area
273 * Check whether an address lies within one of the thunk area we
276 int elf_is_in_thunk_area(unsigned long addr,
277 const struct elf_thunk_area* thunks)
281 for (i = 0; thunks[i].symname; i++)
283 if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
289 /******************************************************************
292 * creating an internal hash table to ease use ELF symtab information lookup
294 static void elf_hash_symtab(struct module* module, struct pool* pool,
295 struct hash_table* ht_symtab, struct elf_file_map* fmap,
296 int symtab_idx, struct elf_thunk_area* thunks)
301 struct symt_compiland* compiland = NULL;
303 const Elf32_Sym* symp;
304 struct symtab_elt* ste;
306 symp = (const Elf32_Sym*)elf_map_section(fmap, symtab_idx);
307 strp = elf_map_section(fmap, fmap->sect[symtab_idx].shdr.sh_link);
308 if (symp == ELF_NO_MAP || strp == ELF_NO_MAP) return;
310 nsym = elf_get_map_size(fmap, symtab_idx) / sizeof(*symp);
312 for (j = 0; thunks[j].symname; j++)
313 thunks[j].rva_start = thunks[j].rva_end = 0;
315 for (i = 0; i < nsym; i++, symp++)
317 /* Ignore certain types of entries which really aren't of that much
320 if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE &&
321 ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
322 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
323 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
324 symp->st_shndx == SHN_UNDEF)
329 symname = strp + symp->st_name;
331 /* handle some specific symtab (that we'll throw away when done) */
332 switch (ELF32_ST_TYPE(symp->st_info))
336 compiland = symt_new_compiland(module, symp->st_value,
337 source_new(module, NULL, symname));
342 /* we are only interested in wine markers inserted by winebuild */
343 for (j = 0; thunks[j].symname; j++)
345 if (!strcmp(symname, thunks[j].symname))
347 thunks[j].rva_start = symp->st_value;
348 thunks[j].rva_end = symp->st_value + symp->st_size;
355 /* FIXME: we don't need to handle them (GCC internals)
356 * Moreover, they screw up our symbol lookup :-/
358 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
361 ste = pool_alloc(pool, sizeof(*ste));
362 ste->ht_elt.name = symname;
363 /* GCC emits, in some cases, a .<digit>+ suffix.
364 * This is used for static variable inside functions, so
365 * that we can have several such variables with same name in
366 * the same compilation unit
367 * We simply ignore that suffix when present (we also get rid
368 * of it in stabs parsing)
370 ptr = symname + strlen(symname) - 1;
373 while (isdigit(*ptr) && ptr >= symname) ptr--;
374 if (ptr > symname && *ptr == '.')
376 char* n = pool_alloc(pool, ptr - symname + 1);
377 memcpy(n, symname, ptr - symname + 1);
378 n[ptr - symname] = '\0';
379 ste->ht_elt.name = n;
383 ste->compiland = compiland;
385 hash_table_add(ht_symtab, &ste->ht_elt);
387 /* as we added in the ht_symtab pointers to the symbols themselves,
388 * we cannot unmap yet the sections, it will be done when we're over
393 /******************************************************************
396 * lookup a symbol by name in our internal hash table for the symtab
398 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
399 const struct hash_table* ht_symtab,
400 const char* name, struct symt* compiland)
402 struct symtab_elt* weak_result = NULL; /* without compiland name */
403 struct symtab_elt* result = NULL;
404 struct hash_table_iter hti;
405 struct symtab_elt* ste;
406 const char* compiland_name;
407 const char* compiland_basename;
410 /* we need weak match up (at least) when symbols of same name,
411 * defined several times in different compilation units,
412 * are merged in a single one (hence a different filename for c.u.)
416 compiland_name = source_get(module,
417 ((struct symt_compiland*)compiland)->source);
418 compiland_basename = strrchr(compiland_name, '/');
419 if (!compiland_basename++) compiland_basename = compiland_name;
421 else compiland_name = compiland_basename = NULL;
423 hash_table_iter_init(ht_symtab, &hti, name);
424 while ((ste = hash_table_iter_up(&hti)))
426 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
429 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
431 if (ste->compiland && compiland_name)
433 const char* filename = source_get(module, ste->compiland->source);
434 if (strcmp(filename, compiland_name))
436 base = strrchr(filename, '/');
437 if (!base++) base = filename;
438 if (strcmp(base, compiland_basename)) continue;
443 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
444 name, compiland_name,
445 source_get(module, result->compiland->source), result->symp->st_value,
446 source_get(module, ste->compiland->source), ste->symp->st_value);
454 if (!result && !(result = weak_result))
456 FIXME("Couldn't find symbol %s!%s in symtab\n",
457 module->module_name, name);
463 /******************************************************************
464 * elf_finish_stabs_info
466 * - get any relevant information (address & size) from the bits we got from the
467 * stabs debugging information
469 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
471 struct hash_table_iter hti;
474 const Elf32_Sym* symp;
476 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
477 while ((ptr = hash_table_iter_up(&hti)))
479 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
480 switch (sym->symt.tag)
483 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
484 ((struct symt_function*)sym)->size)
488 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
489 ((struct symt_function*)sym)->container);
492 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
493 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
494 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
495 sym, module->module_name, sym->hash_elt.name,
496 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
497 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
498 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
499 sym, module->module_name, sym->hash_elt.name,
500 ((struct symt_function*)sym)->size, symp->st_size);
502 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
504 ((struct symt_function*)sym)->size = symp->st_size;
505 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
508 switch (((struct symt_data*)sym)->kind)
511 case DataIsFileStatic:
512 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr)
514 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
515 ((struct symt_data*)sym)->container);
518 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr &&
519 ((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr + symp->st_value)
520 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
521 sym, module->module_name, sym->hash_elt.name,
522 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
523 ((struct symt_data*)sym)->u.var.offset = module->elf_info->elf_addr +
525 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
526 DataIsFileStatic : DataIsGlobal;
527 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
533 FIXME("Unsupported tag %u\n", sym->symt.tag);
537 /* since we may have changed some addresses & sizes, mark the module to be resorted */
538 module->sortlist_valid = FALSE;
541 /******************************************************************
542 * elf_load_wine_thunks
544 * creating the thunk objects for a wine native DLL
546 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
547 const struct elf_thunk_area* thunks)
550 struct hash_table_iter hti;
551 struct symtab_elt* ste;
553 struct symt_ht* symt;
555 hash_table_iter_init(ht_symtab, &hti, NULL);
556 while ((ste = hash_table_iter_up(&hti)))
558 if (ste->used) continue;
560 addr = module->elf_info->elf_addr + ste->symp->st_value;
562 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
563 if (j >= 0) /* thunk found */
565 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
566 addr, ste->symp->st_size);
572 symt = symt_find_nearest(module, addr);
574 symt_get_info(&symt->symt, TI_GET_ADDRESS, &ref_addr);
575 if (!symt || addr != ref_addr)
577 /* creating public symbols for all the ELF symbols which haven't been
578 * used yet (ie we have no debug information on them)
579 * That's the case, for example, of the .spec.c files
581 switch (ELF32_ST_TYPE(ste->symp->st_info))
584 symt_new_function(module, ste->compiland, ste->ht_elt.name,
585 addr, ste->symp->st_size, NULL);
588 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
589 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
590 addr, ste->symp->st_size, NULL);
593 FIXME("Shouldn't happen\n");
596 /* FIXME: this is a hack !!!
597 * we are adding new symbols, but as we're parsing a symbol table
598 * (hopefully without duplicate symbols) we delay rebuilding the sorted
599 * module table until we're done with the symbol table
600 * Otherwise, as we intertwine symbols's add and lookup, performance
603 module->sortlist_valid = TRUE;
605 else if (strcmp(ste->ht_elt.name, symt->hash_elt.name))
607 ULONG64 xaddr = 0, xsize = 0;
610 symt_get_info(&symt->symt, TI_GET_ADDRESS, &xaddr);
611 symt_get_info(&symt->symt, TI_GET_LENGTH, &xsize);
612 symt_get_info(&symt->symt, TI_GET_DATAKIND, &kind);
614 /* If none of symbols has a correct size, we consider they are both markers
615 * Hence, we can silence this warning
616 * Also, we check that we don't have two symbols, one local, the other
617 * global which is legal
619 if ((xsize || ste->symp->st_size) &&
620 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
621 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
623 ste->ht_elt.name, addr, ste->symp->st_size,
625 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
629 /* see comment above */
630 module->sortlist_valid = FALSE;
634 /******************************************************************
635 * elf_new_public_symbols
637 * Creates a set of public symbols from an ELF symtab
639 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
641 struct hash_table_iter hti;
642 struct symtab_elt* ste;
644 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
646 /* FIXME: we're missing the ELF entry point here */
648 hash_table_iter_init(symtab, &hti, NULL);
649 while ((ste = hash_table_iter_up(&hti)))
651 symt_new_public(module, ste->compiland, ste->ht_elt.name,
652 module->elf_info->elf_addr + ste->symp->st_value,
653 ste->symp->st_size, TRUE /* FIXME */,
654 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
659 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
660 the following calc_crc32 code or tables extracted from it, as desired without
663 /**********************************************************************\
664 |* Demonstration program to compute the 32-bit CRC used as the frame *|
665 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
666 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
667 |* protocol). The 32-bit FCS was added via the Federal Register, *|
668 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
669 |* this polynomial is or will be included in CCITT V.41, which *|
670 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
671 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
672 |* errors by a factor of 10^-5 over 16-bit FCS. *|
673 \**********************************************************************/
675 /* First, the polynomial itself and its table of feedback terms. The */
677 /* 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 */
678 /* Note that we take it "backwards" and put the highest-order term in */
679 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
680 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
681 /* the MSB being 1. */
683 /* Note that the usual hardware shift register implementation, which */
684 /* is what we're using (we're merely optimizing it by doing eight-bit */
685 /* chunks at a time) shifts bits into the lowest-order term. In our */
686 /* implementation, that means shifting towards the right. Why do we */
687 /* do it this way? Because the calculated CRC must be transmitted in */
688 /* order from highest-order term to lowest-order term. UARTs transmit */
689 /* characters in order from LSB to MSB. By storing the CRC this way, */
690 /* we hand it to the UART in the order low-byte to high-byte; the UART */
691 /* sends each low-bit to hight-bit; and the result is transmission bit */
692 /* by bit from highest- to lowest-order term without requiring any bit */
693 /* shuffling on our part. Reception works similarly. */
695 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
697 /* 1. The table can be generated at runtime if desired; code to do so */
698 /* is shown later. It might not be obvious, but the feedback */
699 /* terms simply represent the results of eight shift/xor opera- */
700 /* tions for all combinations of data and CRC register values. */
702 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
703 /* be they sixteen or thirty-two bits wide. You simply choose the */
704 /* appropriate table. Alternatively, because the table can be */
705 /* generated at runtime, you can start by generating the table for */
706 /* the polynomial in question and use exactly the same "updcrc", */
707 /* if your application needn't simultaneously handle two CRC */
708 /* polynomials. (Note, however, that XMODEM is strange.) */
710 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
711 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
713 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
714 /* logic; the shift must be unsigned (bring in zeroes). On some */
715 /* hardware you could probably optimize the shift in assembler by */
716 /* using byte-swap instructions. */
719 static DWORD calc_crc32(struct elf_file_map* fmap)
721 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
722 static const DWORD crc_32_tab[] =
723 { /* CRC polynomial 0xedb88320 */
724 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
725 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
726 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
727 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
728 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
729 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
730 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
731 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
732 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
733 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
734 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
735 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
736 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
737 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
738 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
739 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
740 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
741 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
742 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
743 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
744 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
745 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
746 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
747 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
748 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
749 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
750 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
751 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
752 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
753 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
754 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
755 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
756 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
757 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
758 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
759 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
760 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
761 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
762 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
763 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
764 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
765 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
766 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
769 unsigned char buffer[256];
772 lseek(fmap->fd, 0, SEEK_SET);
773 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
775 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
781 static BOOL elf_load_debug_info_from_map(struct module* module,
782 struct elf_file_map* fmap,
784 struct hash_table* ht_symtab);
786 /******************************************************************
787 * elf_locate_debug_link
789 * Locate a filename from a .gnu_debuglink section, using the same
791 * "If the full name of the directory containing the executable is
792 * execdir, and the executable has a debug link that specifies the
793 * name debugfile, then GDB will automatically search for the
794 * debugging information file in three places:
795 * - the directory containing the executable file (that is, it
796 * will look for a file named `execdir/debugfile',
797 * - a subdirectory of that directory named `.debug' (that is, the
798 * file `execdir/.debug/debugfile', and
799 * - a subdirectory of the global debug file directory that includes
800 * the executable's full path, and the name from the link (that is,
801 * the file `globaldebugdir/execdir/debugfile', where globaldebugdir
802 * is the global debug file directory, and execdir has been turned
803 * into a relative path)." (from GDB manual)
805 static char* elf_locate_debug_link(const char* filename, const WCHAR* loaded_file,
806 struct elf_file_map* fmap_link)
808 static const char globalDebugDir[] = "/usr/lib/debug/";
809 const size_t globalDebugDirLen = strlen(globalDebugDir);
810 size_t loaded_file_len;
814 loaded_file_len = WideCharToMultiByte(CP_UNIXCP, 0, loaded_file, -1, NULL, 0, NULL, NULL);
815 p = HeapAlloc(GetProcessHeap(), 0,
816 globalDebugDirLen + loaded_file_len + 6 + 1 + strlen(filename) + 1);
818 if (!p) return FALSE;
820 /* we prebuild the string with "execdir" */
821 WideCharToMultiByte(CP_UNIXCP, 0, loaded_file, -1, p, loaded_file_len, NULL, NULL);
822 slash = strrchr(p, '/');
823 if (slash == NULL) slash = p; else slash++;
825 /* testing execdir/filename */
826 strcpy(slash, filename);
827 if (elf_map_file(p, fmap_link)) goto found;
829 /* testing execdir/.debug/filename */
830 sprintf(slash, ".debug/%s", filename);
831 if (elf_map_file(p, fmap_link)) goto found;
833 /* testing globaldebugdir/execdir/filename */
834 memmove(p + globalDebugDirLen, p, slash - p);
835 memcpy(p, globalDebugDir, globalDebugDirLen);
836 slash += globalDebugDirLen;
837 strcpy(slash, filename);
838 if (elf_map_file(p, fmap_link)) goto found;
841 if (elf_map_file(p, fmap_link)) goto found;
843 HeapFree(GetProcessHeap(), 0, p);
845 WARN("Couldn't locate or map %s\n", filename);
849 TRACE("Located debug information file %s at %s\n", filename, p);
853 /******************************************************************
854 * elf_debuglink_parse
856 * Parses a .gnu_debuglink section and loads the debug info from
857 * the external file specified there.
859 static BOOL elf_debuglink_parse (struct module* module,
861 struct hash_table* ht_symtab,
862 const BYTE* debuglink)
864 /* The content of a debug link section is:
865 * 1/ a NULL terminated string, containing the file name for the
867 * 2/ padding on 4 byte boundary
868 * 3/ CRC of the linked ELF file
871 const char* dbg_link = (char*)debuglink;
872 struct elf_file_map fmap_link;
875 link_file = elf_locate_debug_link(dbg_link, module->module.LoadedImageName, &fmap_link);
879 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
880 fmap_link.with_crc = 1;
881 ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
884 MultiByteToWideChar(CP_ACP, 0, link_file, -1,
885 module->module.LoadedPdbName,
886 sizeof(module->module.LoadedPdbName));
888 WARN("Couldn't load debug information from %s\n", link_file);
889 elf_unmap_file(&fmap_link);
890 HeapFree(GetProcessHeap(), 0, link_file);
896 /******************************************************************
897 * elf_load_debug_info_from_map
899 * Loads the symbolic information from ELF module which mapping is described
901 * the module has been loaded at 'load_offset' address, so symbols' address
902 * relocation is performed.
903 * CRC is checked if fmap->with_crc is TRUE
905 * 0 if the file doesn't contain symbolic info (or this info cannot be
909 static BOOL elf_load_debug_info_from_map(struct module* module,
910 struct elf_file_map* fmap,
912 struct hash_table* ht_symtab)
914 BOOL ret = FALSE, lret;
915 const char* shstrtab;
917 int symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
918 int debug_sect, debug_str_sect, debug_abbrev_sect;
919 int debug_line_sect, debug_loclist_sect;
921 struct elf_thunk_area thunks[] =
923 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
924 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
925 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
926 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
927 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
928 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
932 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
934 ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
935 debugstr_w(module->module.LoadedImageName), calc_crc32(fmap), fmap->crc);
936 /* we don't tolerate mis-matched files */
941 * Next, we need to find a few of the internal ELF headers within
942 * this thing. We need the main executable header, and the section
945 shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
946 if (shstrtab == ELF_NO_MAP) return FALSE;
948 symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
949 debug_sect = debug_str_sect = debug_abbrev_sect = -1;
950 debug_line_sect = debug_loclist_sect = -1;
953 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
955 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
957 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
959 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
961 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
963 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
964 debug_abbrev_sect = i;
965 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
967 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_loc") == 0)
968 debug_loclist_sect = i;
969 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
971 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
972 (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
974 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
975 (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
978 elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
981 if (symtab_sect == -1)
983 /* if we don't have a symtab but a dynsym, process the dynsym
984 * section instead. It'll contain less (relevant) information,
985 * but it'll be better than nothing
987 if (dynsym_sect == -1) return FALSE;
988 symtab_sect = dynsym_sect;
991 module->module.SymType = SymExport;
993 /* create a hash table for the symtab */
994 elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
996 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
998 if (stab_sect != -1 && stabstr_sect != -1)
1001 const char* stabstr;
1003 stab = elf_map_section(fmap, stab_sect);
1004 stabstr = elf_map_section(fmap, stabstr_sect);
1005 if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP)
1007 /* OK, now just parse all of the stabs. */
1008 lret = stabs_parse(module, module->elf_info->elf_addr,
1009 stab, elf_get_map_size(fmap, stab_sect),
1010 stabstr, elf_get_map_size(fmap, stabstr_sect));
1012 /* and fill in the missing information for stabs */
1013 elf_finish_stabs_info(module, ht_symtab);
1015 WARN("Couldn't correctly read stabs\n");
1019 elf_unmap_section(fmap, stab_sect);
1020 elf_unmap_section(fmap, stabstr_sect);
1023 if (debug_sect != -1)
1025 /* Dwarf 2 debug information */
1026 const BYTE* dw2_debug;
1027 const BYTE* dw2_debug_abbrev;
1028 const BYTE* dw2_debug_str;
1029 const BYTE* dw2_debug_line;
1030 const BYTE* dw2_debug_loclist;
1032 TRACE("Loading Dwarf2 information for %s\n", module->module_name);
1034 dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
1035 dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
1036 dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
1037 dw2_debug_line = (const BYTE*) elf_map_section(fmap, debug_line_sect);
1038 dw2_debug_loclist = (const BYTE*) elf_map_section(fmap, debug_loclist_sect);
1039 if (dw2_debug != ELF_NO_MAP && dw2_debug_abbrev != ELF_NO_MAP && dw2_debug_str != ELF_NO_MAP)
1041 /* OK, now just parse dwarf2 debug infos. */
1042 lret = dwarf2_parse(module, module->elf_info->elf_addr, thunks,
1043 dw2_debug, elf_get_map_size(fmap, debug_sect),
1044 dw2_debug_abbrev, elf_get_map_size(fmap, debug_abbrev_sect),
1045 dw2_debug_str, elf_get_map_size(fmap, debug_str_sect),
1046 dw2_debug_line, elf_get_map_size(fmap, debug_line_sect),
1047 dw2_debug_loclist, elf_get_map_size(fmap, debug_loclist_sect));
1050 WARN("Couldn't correctly read stabs\n");
1053 elf_unmap_section(fmap, debug_sect);
1054 elf_unmap_section(fmap, debug_abbrev_sect);
1055 elf_unmap_section(fmap, debug_str_sect);
1056 elf_unmap_section(fmap, debug_line_sect);
1057 elf_unmap_section(fmap, debug_loclist_sect);
1059 if (debuglink_sect != -1)
1061 const BYTE* dbg_link;
1063 dbg_link = (const BYTE*) elf_map_section(fmap, debuglink_sect);
1064 if (dbg_link != ELF_NO_MAP)
1066 lret = elf_debuglink_parse(module, pool, ht_symtab, dbg_link);
1068 WARN("Couldn't load linked debug file for %s\n",
1069 debugstr_w(module->module.ModuleName));
1072 elf_unmap_section(fmap, debuglink_sect);
1075 if (strstrW(module->module.ModuleName, S_ElfW) ||
1076 !strcmpW(module->module.ModuleName, S_WineLoaderW))
1078 /* add the thunks for native libraries */
1079 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1080 elf_new_wine_thunks(module, ht_symtab, thunks);
1082 /* add all the public symbols from symtab */
1083 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
1088 /******************************************************************
1089 * elf_load_debug_info
1091 * Loads ELF debugging information from the module image file.
1093 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1097 struct hash_table ht_symtab;
1098 struct elf_file_map my_fmap;
1100 if (module->type != DMT_ELF || !module->elf_info)
1102 ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName));
1106 pool_init(&pool, 65536);
1107 hash_table_init(&pool, &ht_symtab, 256);
1111 char LoadedImageName[MAX_PATH];
1114 WideCharToMultiByte(CP_UNIXCP, 0, module->module.LoadedImageName, -1,
1115 LoadedImageName, MAX_PATH, NULL, NULL);
1116 ret = elf_map_file(LoadedImageName, fmap);
1119 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
1121 pool_destroy(&pool);
1122 if (fmap == &my_fmap) elf_unmap_file(fmap);
1126 /******************************************************************
1127 * elf_fetch_file_info
1129 * Gathers some more information for an ELF module from a given file
1131 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1132 DWORD* size, DWORD* checksum)
1134 struct elf_file_map fmap;
1137 WideCharToMultiByte(CP_UNIXCP, 0, name, -1, tmp, sizeof(tmp), 0, 0);
1138 if (!elf_map_file(tmp, &fmap)) return FALSE;
1139 if (base) *base = fmap.elf_start;
1140 *size = fmap.elf_size;
1141 *checksum = calc_crc32(&fmap);
1142 elf_unmap_file(&fmap);
1146 /******************************************************************
1149 * Loads the information for ELF module stored in 'filename'
1150 * the module has been loaded at 'load_offset' address
1152 * -1 if the file cannot be found/opened
1153 * 0 if the file doesn't contain symbolic info (or this info cannot be
1157 static BOOL elf_load_file(struct process* pcs, const char* filename,
1158 unsigned long load_offset, struct elf_info* elf_info)
1161 struct elf_file_map fmap;
1164 TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset);
1166 if (!elf_map_file(filename, &fmap)) goto leave;
1168 /* Next, we need to find a few of the internal ELF headers within
1169 * this thing. We need the main executable header, and the section
1172 if (!fmap.elf_start && !load_offset)
1173 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1175 if (fmap.elf_start && load_offset)
1177 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1178 "Assuming load address is corrupt\n", filename, load_offset);
1182 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1184 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1185 if (shstrtab == ELF_NO_MAP) goto leave;
1186 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1188 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1189 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1192 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1197 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1200 if (dyn.d_tag == DT_DEBUG)
1202 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1206 } while (dyn.d_tag != DT_NULL);
1207 if (dyn.d_tag == DT_NULL) goto leave;
1210 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1213 if (elf_info->flags & ELF_INFO_MODULE)
1215 WCHAR wfilename[MAX_PATH];
1216 struct elf_module_info *elf_module_info =
1217 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1218 if (!elf_module_info) goto leave;
1219 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, wfilename, sizeof(wfilename) / sizeof(WCHAR));
1220 elf_info->module = module_new(pcs, wfilename, DMT_ELF, FALSE,
1221 (load_offset) ? load_offset : fmap.elf_start,
1222 fmap.elf_size, 0, calc_crc32(&fmap));
1223 if (!elf_info->module)
1225 HeapFree(GetProcessHeap(), 0, elf_module_info);
1228 elf_info->module->elf_info = elf_module_info;
1229 elf_info->module->elf_info->elf_addr = load_offset;
1231 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1233 elf_info->module->module.SymType = SymDeferred;
1236 else ret = elf_load_debug_info(elf_info->module, &fmap);
1238 elf_info->module->elf_info->elf_mark = 1;
1239 elf_info->module->elf_info->elf_loader = 0;
1242 if (elf_info->flags & ELF_INFO_NAME)
1244 elf_info->module_name = strcpy(HeapAlloc(GetProcessHeap(), 0,
1245 strlen(filename) + 1), filename);
1248 elf_unmap_file(&fmap);
1253 /******************************************************************
1254 * elf_load_file_from_path
1255 * tries to load an ELF file from a set of paths (separated by ':')
1257 static BOOL elf_load_file_from_path(HANDLE hProcess,
1258 const char* filename,
1259 unsigned long load_offset,
1261 struct elf_info* elf_info)
1267 if (!path) return FALSE;
1269 paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path);
1270 for (s = paths; s && *s; s = (t) ? (t+1) : NULL)
1274 fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1);
1278 strcat(fn, filename);
1279 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1280 HeapFree(GetProcessHeap(), 0, fn);
1282 s = (t) ? (t+1) : NULL;
1285 HeapFree(GetProcessHeap(), 0, paths);
1289 /******************************************************************
1290 * elf_load_file_from_dll_path
1292 * Tries to load an ELF file from the dll path
1294 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1295 const char* filename,
1296 unsigned long load_offset,
1297 struct elf_info* elf_info)
1300 unsigned int index = 0;
1303 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1305 char *name = HeapAlloc( GetProcessHeap(), 0, strlen(path) + strlen(filename) + 2 );
1307 strcpy( name, path );
1308 strcat( name, "/" );
1309 strcat( name, filename );
1310 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1311 HeapFree( GetProcessHeap(), 0, name );
1316 /******************************************************************
1317 * elf_search_and_load_file
1319 * lookup a file in standard ELF locations, and if found, load it
1321 static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
1322 unsigned long load_offset,
1323 struct elf_info* elf_info)
1326 struct module* module;
1328 if (filename == NULL || *filename == '\0') return FALSE;
1329 if ((module = module_find_by_nameA(pcs, filename, DMT_ELF)))
1331 elf_info->module = module;
1332 module->elf_info->elf_mark = 1;
1333 return module->module.SymType;
1336 if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */
1337 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1338 /* if relative pathname, try some absolute base dirs */
1339 if (!ret && !strchr(filename, '/'))
1341 ret = elf_load_file_from_path(pcs, filename, load_offset,
1342 getenv("PATH"), elf_info) ||
1343 elf_load_file_from_path(pcs, filename, load_offset,
1344 getenv("LD_LIBRARY_PATH"), elf_info);
1345 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1351 /******************************************************************
1352 * elf_enum_modules_internal
1354 * Enumerate ELF modules from a running process
1356 static BOOL elf_enum_modules_internal(const struct process* pcs,
1357 const char* main_name,
1358 elf_enum_modules_cb cb, void* user)
1360 struct r_debug dbg_hdr;
1364 WCHAR bufstrW[MAX_PATH];
1366 if (!pcs->dbg_hdr_addr ||
1367 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1368 &dbg_hdr, sizeof(dbg_hdr), NULL))
1371 /* Now walk the linked list. In all known ELF implementations,
1372 * the dynamic loader maintains this linked list for us. In some
1373 * cases the first entry doesn't appear with a name, in other cases it
1376 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1378 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1381 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1382 lm.l_name != NULL &&
1383 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1385 bufstr[sizeof(bufstr) - 1] = '\0';
1386 if (main_name && !bufstr[0]) strcpy(bufstr, main_name);
1387 MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR));
1388 if (!cb(bufstrW, (unsigned long)lm.l_addr, user)) break;
1396 struct process* pcs;
1397 struct elf_info elf_info;
1400 static BOOL elf_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user)
1402 struct elf_sync* es = user;
1405 WideCharToMultiByte(CP_UNIXCP, 0, name, -1, tmp, sizeof(tmp), 0, 0);
1406 elf_search_and_load_file(es->pcs, tmp, addr, &es->elf_info);
1410 /******************************************************************
1411 * elf_synchronize_module_list
1413 * this functions rescans the debuggee module's list and synchronizes it with
1414 * the one from 'pcs', ie:
1415 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1416 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1418 BOOL elf_synchronize_module_list(struct process* pcs)
1420 struct module* module;
1423 for (module = pcs->lmodules; module; module = module->next)
1425 if (module->type == DMT_ELF && !module->is_virtual)
1426 module->elf_info->elf_mark = 0;
1430 es.elf_info.flags = ELF_INFO_MODULE;
1431 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1434 module = pcs->lmodules;
1437 if (module->type == DMT_ELF && !module->is_virtual &&
1438 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1440 module_remove(pcs, module);
1441 /* restart all over */
1442 module = pcs->lmodules;
1444 else module = module->next;
1449 /******************************************************************
1452 * Lookup in a running ELF process the loader, and sets its ELF link
1453 * address (for accessing the list of loaded .so libs) in pcs.
1454 * If flags is ELF_INFO_MODULE, the module for the loader is also
1455 * added as a module into pcs.
1457 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1462 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1463 * main executable (either wine-kthread or wine-pthread)
1464 * FIXME: the heuristic used to know whether we need to load wine-pthread
1465 * or wine-kthread is not 100% safe
1467 if ((ptr = getenv("WINELOADER")))
1468 ret = elf_search_and_load_file(pcs, ptr, 0, elf_info);
1471 ret = elf_search_and_load_file(pcs, "wine-kthread", 0, elf_info) ||
1472 elf_search_and_load_file(pcs, "wine-pthread", 0, elf_info);
1477 /******************************************************************
1478 * elf_read_wine_loader_dbg_info
1480 * Try to find a decent wine executable which could have loaded the debuggee
1482 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1484 struct elf_info elf_info;
1486 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1487 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1488 elf_info.module->elf_info->elf_loader = 1;
1489 module_set_module(elf_info.module, S_WineLoaderW);
1490 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1493 /******************************************************************
1496 * Enumerates the ELF loaded modules from a running target (hProc)
1497 * This function doesn't require that someone has called SymInitialize
1498 * on this very process.
1500 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1503 struct elf_info elf_info;
1506 memset(&pcs, 0, sizeof(pcs));
1508 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1509 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1510 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1511 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1512 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1518 struct process* pcs;
1519 struct elf_info elf_info;
1520 char name[MAX_PATH];
1524 /******************************************************************
1527 * Callback for elf_load_module, used to walk the list of loaded
1530 static BOOL elf_load_cb(const WCHAR* nameW, unsigned long addr, void* user)
1532 struct elf_load* el = user;
1534 char name[MAX_PATH];
1536 WideCharToMultiByte(CP_UNIXCP, 0, nameW, -1, name, sizeof(name), 0, 0);
1538 /* memcmp is needed for matches when bufstr contains also version information
1539 * el->name: libc.so, name: libc.so.6.0
1541 p = strrchr(name, '/');
1543 if (!memcmp(p, el->name, strlen(el->name)))
1545 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1551 /******************************************************************
1554 * loads an ELF module and stores it in process' module list
1555 * Also, find module real name and load address from
1556 * the real loaded modules list in pcs address space
1558 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1562 TRACE("(%p %s %08lx)\n", pcs, debugstr_w(name), addr);
1564 el.elf_info.flags = ELF_INFO_MODULE;
1567 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1572 /* do only the lookup from the filename, not the path (as we lookup module
1573 * name in the process' loaded module list)
1575 ptr = strrchrW(name, '/');
1576 if (!ptr++) ptr = name;
1577 WideCharToMultiByte(CP_UNIXCP, 0, ptr, -1, el.name, sizeof(el.name), NULL, NULL);
1580 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1585 WideCharToMultiByte(CP_UNIXCP, 0, name, -1, el.name, sizeof(el.name), NULL, NULL);
1586 el.ret = elf_search_and_load_file(pcs, el.name, addr, &el.elf_info);
1588 if (!el.ret) return NULL;
1589 assert(el.elf_info.module);
1590 return el.elf_info.module;
1593 #else /* !__ELF__ */
1595 BOOL elf_synchronize_module_list(struct process* pcs)
1600 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1601 DWORD* size, DWORD* checksum)
1606 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1611 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1616 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1621 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1626 int elf_is_in_thunk_area(unsigned long addr,
1627 const struct elf_thunk_area* thunks)
1631 #endif /* __ELF__ */