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 WCHAR* 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_fileA(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 static BOOL elf_map_file(const WCHAR* filenameW, struct elf_file_map* fmap)
257 len = WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, NULL, 0, NULL, NULL);
258 if (!(filename = HeapAlloc(GetProcessHeap(), 0, len))) return FALSE;
259 WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, filename, len, NULL, NULL);
260 ret = elf_map_fileA(filename, fmap);
261 HeapFree(GetProcessHeap(), 0, filename);
265 /******************************************************************
268 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
270 static void elf_unmap_file(struct elf_file_map* fmap)
275 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
277 elf_unmap_section(fmap, i);
279 HeapFree(GetProcessHeap(), 0, fmap->sect);
284 /******************************************************************
285 * elf_is_in_thunk_area
287 * Check whether an address lies within one of the thunk area we
290 int elf_is_in_thunk_area(unsigned long addr,
291 const struct elf_thunk_area* thunks)
295 for (i = 0; thunks[i].symname; i++)
297 if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
303 /******************************************************************
306 * creating an internal hash table to ease use ELF symtab information lookup
308 static void elf_hash_symtab(struct module* module, struct pool* pool,
309 struct hash_table* ht_symtab, struct elf_file_map* fmap,
310 int symtab_idx, struct elf_thunk_area* thunks)
315 struct symt_compiland* compiland = NULL;
317 const Elf32_Sym* symp;
318 struct symtab_elt* ste;
320 symp = (const Elf32_Sym*)elf_map_section(fmap, symtab_idx);
321 strp = elf_map_section(fmap, fmap->sect[symtab_idx].shdr.sh_link);
322 if (symp == ELF_NO_MAP || strp == ELF_NO_MAP) return;
324 nsym = elf_get_map_size(fmap, symtab_idx) / sizeof(*symp);
326 for (j = 0; thunks[j].symname; j++)
327 thunks[j].rva_start = thunks[j].rva_end = 0;
329 for (i = 0; i < nsym; i++, symp++)
331 /* Ignore certain types of entries which really aren't of that much
334 if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE &&
335 ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
336 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
337 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
338 symp->st_shndx == SHN_UNDEF)
343 symname = strp + symp->st_name;
345 /* handle some specific symtab (that we'll throw away when done) */
346 switch (ELF32_ST_TYPE(symp->st_info))
350 compiland = symt_new_compiland(module, symp->st_value,
351 source_new(module, NULL, symname));
356 /* we are only interested in wine markers inserted by winebuild */
357 for (j = 0; thunks[j].symname; j++)
359 if (!strcmp(symname, thunks[j].symname))
361 thunks[j].rva_start = symp->st_value;
362 thunks[j].rva_end = symp->st_value + symp->st_size;
369 /* FIXME: we don't need to handle them (GCC internals)
370 * Moreover, they screw up our symbol lookup :-/
372 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
375 ste = pool_alloc(pool, sizeof(*ste));
376 ste->ht_elt.name = symname;
377 /* GCC emits, in some cases, a .<digit>+ suffix.
378 * This is used for static variable inside functions, so
379 * that we can have several such variables with same name in
380 * the same compilation unit
381 * We simply ignore that suffix when present (we also get rid
382 * of it in stabs parsing)
384 ptr = symname + strlen(symname) - 1;
387 while (isdigit(*ptr) && ptr >= symname) ptr--;
388 if (ptr > symname && *ptr == '.')
390 char* n = pool_alloc(pool, ptr - symname + 1);
391 memcpy(n, symname, ptr - symname + 1);
392 n[ptr - symname] = '\0';
393 ste->ht_elt.name = n;
397 ste->compiland = compiland;
399 hash_table_add(ht_symtab, &ste->ht_elt);
401 /* as we added in the ht_symtab pointers to the symbols themselves,
402 * we cannot unmap yet the sections, it will be done when we're over
407 /******************************************************************
410 * lookup a symbol by name in our internal hash table for the symtab
412 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
413 const struct hash_table* ht_symtab,
414 const char* name, struct symt* compiland)
416 struct symtab_elt* weak_result = NULL; /* without compiland name */
417 struct symtab_elt* result = NULL;
418 struct hash_table_iter hti;
419 struct symtab_elt* ste;
420 const char* compiland_name;
421 const char* compiland_basename;
424 /* we need weak match up (at least) when symbols of same name,
425 * defined several times in different compilation units,
426 * are merged in a single one (hence a different filename for c.u.)
430 compiland_name = source_get(module,
431 ((struct symt_compiland*)compiland)->source);
432 compiland_basename = strrchr(compiland_name, '/');
433 if (!compiland_basename++) compiland_basename = compiland_name;
435 else compiland_name = compiland_basename = NULL;
437 hash_table_iter_init(ht_symtab, &hti, name);
438 while ((ste = hash_table_iter_up(&hti)))
440 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
443 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
445 if (ste->compiland && compiland_name)
447 const char* filename = source_get(module, ste->compiland->source);
448 if (strcmp(filename, compiland_name))
450 base = strrchr(filename, '/');
451 if (!base++) base = filename;
452 if (strcmp(base, compiland_basename)) continue;
457 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
458 name, compiland_name,
459 source_get(module, result->compiland->source), result->symp->st_value,
460 source_get(module, ste->compiland->source), ste->symp->st_value);
468 if (!result && !(result = weak_result))
470 FIXME("Couldn't find symbol %s!%s in symtab\n",
471 module->module_name, name);
477 /******************************************************************
478 * elf_finish_stabs_info
480 * - get any relevant information (address & size) from the bits we got from the
481 * stabs debugging information
483 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
485 struct hash_table_iter hti;
488 const Elf32_Sym* symp;
490 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
491 while ((ptr = hash_table_iter_up(&hti)))
493 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
494 switch (sym->symt.tag)
497 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
498 ((struct symt_function*)sym)->size)
502 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
503 ((struct symt_function*)sym)->container);
506 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
507 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
508 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
509 sym, module->module_name, sym->hash_elt.name,
510 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
511 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
512 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
513 sym, module->module_name, sym->hash_elt.name,
514 ((struct symt_function*)sym)->size, symp->st_size);
516 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
518 ((struct symt_function*)sym)->size = symp->st_size;
519 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
522 switch (((struct symt_data*)sym)->kind)
525 case DataIsFileStatic:
526 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr)
528 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
529 ((struct symt_data*)sym)->container);
532 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr &&
533 ((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr + symp->st_value)
534 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
535 sym, module->module_name, sym->hash_elt.name,
536 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
537 ((struct symt_data*)sym)->u.var.offset = module->elf_info->elf_addr +
539 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
540 DataIsFileStatic : DataIsGlobal;
541 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
547 FIXME("Unsupported tag %u\n", sym->symt.tag);
551 /* since we may have changed some addresses & sizes, mark the module to be resorted */
552 module->sortlist_valid = FALSE;
555 /******************************************************************
556 * elf_load_wine_thunks
558 * creating the thunk objects for a wine native DLL
560 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
561 const struct elf_thunk_area* thunks)
564 struct hash_table_iter hti;
565 struct symtab_elt* ste;
567 struct symt_ht* symt;
569 hash_table_iter_init(ht_symtab, &hti, NULL);
570 while ((ste = hash_table_iter_up(&hti)))
572 if (ste->used) continue;
574 addr = module->elf_info->elf_addr + ste->symp->st_value;
576 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
577 if (j >= 0) /* thunk found */
579 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
580 addr, ste->symp->st_size);
586 symt = symt_find_nearest(module, addr);
588 symt_get_info(&symt->symt, TI_GET_ADDRESS, &ref_addr);
589 if (!symt || addr != ref_addr)
591 /* creating public symbols for all the ELF symbols which haven't been
592 * used yet (ie we have no debug information on them)
593 * That's the case, for example, of the .spec.c files
595 switch (ELF32_ST_TYPE(ste->symp->st_info))
598 symt_new_function(module, ste->compiland, ste->ht_elt.name,
599 addr, ste->symp->st_size, NULL);
602 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
603 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
604 addr, ste->symp->st_size, NULL);
607 FIXME("Shouldn't happen\n");
610 /* FIXME: this is a hack !!!
611 * we are adding new symbols, but as we're parsing a symbol table
612 * (hopefully without duplicate symbols) we delay rebuilding the sorted
613 * module table until we're done with the symbol table
614 * Otherwise, as we intertwine symbols's add and lookup, performance
617 module->sortlist_valid = TRUE;
619 else if (strcmp(ste->ht_elt.name, symt->hash_elt.name))
621 ULONG64 xaddr = 0, xsize = 0;
624 symt_get_info(&symt->symt, TI_GET_ADDRESS, &xaddr);
625 symt_get_info(&symt->symt, TI_GET_LENGTH, &xsize);
626 symt_get_info(&symt->symt, TI_GET_DATAKIND, &kind);
628 /* If none of symbols has a correct size, we consider they are both markers
629 * Hence, we can silence this warning
630 * Also, we check that we don't have two symbols, one local, the other
631 * global which is legal
633 if ((xsize || ste->symp->st_size) &&
634 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
635 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
637 ste->ht_elt.name, addr, ste->symp->st_size,
639 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
643 /* see comment above */
644 module->sortlist_valid = FALSE;
648 /******************************************************************
649 * elf_new_public_symbols
651 * Creates a set of public symbols from an ELF symtab
653 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
655 struct hash_table_iter hti;
656 struct symtab_elt* ste;
658 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
660 /* FIXME: we're missing the ELF entry point here */
662 hash_table_iter_init(symtab, &hti, NULL);
663 while ((ste = hash_table_iter_up(&hti)))
665 symt_new_public(module, ste->compiland, ste->ht_elt.name,
666 module->elf_info->elf_addr + ste->symp->st_value,
667 ste->symp->st_size, TRUE /* FIXME */,
668 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
673 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
674 the following calc_crc32 code or tables extracted from it, as desired without
677 /**********************************************************************\
678 |* Demonstration program to compute the 32-bit CRC used as the frame *|
679 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
680 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
681 |* protocol). The 32-bit FCS was added via the Federal Register, *|
682 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
683 |* this polynomial is or will be included in CCITT V.41, which *|
684 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
685 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
686 |* errors by a factor of 10^-5 over 16-bit FCS. *|
687 \**********************************************************************/
689 /* First, the polynomial itself and its table of feedback terms. The */
691 /* 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 */
692 /* Note that we take it "backwards" and put the highest-order term in */
693 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
694 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
695 /* the MSB being 1. */
697 /* Note that the usual hardware shift register implementation, which */
698 /* is what we're using (we're merely optimizing it by doing eight-bit */
699 /* chunks at a time) shifts bits into the lowest-order term. In our */
700 /* implementation, that means shifting towards the right. Why do we */
701 /* do it this way? Because the calculated CRC must be transmitted in */
702 /* order from highest-order term to lowest-order term. UARTs transmit */
703 /* characters in order from LSB to MSB. By storing the CRC this way, */
704 /* we hand it to the UART in the order low-byte to high-byte; the UART */
705 /* sends each low-bit to hight-bit; and the result is transmission bit */
706 /* by bit from highest- to lowest-order term without requiring any bit */
707 /* shuffling on our part. Reception works similarly. */
709 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
711 /* 1. The table can be generated at runtime if desired; code to do so */
712 /* is shown later. It might not be obvious, but the feedback */
713 /* terms simply represent the results of eight shift/xor opera- */
714 /* tions for all combinations of data and CRC register values. */
716 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
717 /* be they sixteen or thirty-two bits wide. You simply choose the */
718 /* appropriate table. Alternatively, because the table can be */
719 /* generated at runtime, you can start by generating the table for */
720 /* the polynomial in question and use exactly the same "updcrc", */
721 /* if your application needn't simultaneously handle two CRC */
722 /* polynomials. (Note, however, that XMODEM is strange.) */
724 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
725 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
727 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
728 /* logic; the shift must be unsigned (bring in zeroes). On some */
729 /* hardware you could probably optimize the shift in assembler by */
730 /* using byte-swap instructions. */
733 static DWORD calc_crc32(struct elf_file_map* fmap)
735 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
736 static const DWORD crc_32_tab[] =
737 { /* CRC polynomial 0xedb88320 */
738 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
739 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
740 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
741 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
742 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
743 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
744 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
745 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
746 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
747 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
748 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
749 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
750 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
751 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
752 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
753 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
754 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
755 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
756 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
757 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
758 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
759 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
760 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
761 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
762 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
763 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
764 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
765 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
766 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
767 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
768 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
769 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
770 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
771 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
772 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
773 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
774 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
775 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
776 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
777 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
778 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
779 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
780 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
783 unsigned char buffer[256];
786 lseek(fmap->fd, 0, SEEK_SET);
787 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
789 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
795 static BOOL elf_load_debug_info_from_map(struct module* module,
796 struct elf_file_map* fmap,
798 struct hash_table* ht_symtab);
800 /******************************************************************
801 * elf_locate_debug_link
803 * Locate a filename from a .gnu_debuglink section, using the same
805 * "If the full name of the directory containing the executable is
806 * execdir, and the executable has a debug link that specifies the
807 * name debugfile, then GDB will automatically search for the
808 * debugging information file in three places:
809 * - the directory containing the executable file (that is, it
810 * will look for a file named `execdir/debugfile',
811 * - a subdirectory of that directory named `.debug' (that is, the
812 * file `execdir/.debug/debugfile', and
813 * - a subdirectory of the global debug file directory that includes
814 * the executable's full path, and the name from the link (that is,
815 * the file `globaldebugdir/execdir/debugfile', where globaldebugdir
816 * is the global debug file directory, and execdir has been turned
817 * into a relative path)." (from GDB manual)
819 static WCHAR* elf_locate_debug_link(const char* filename, const WCHAR* loaded_file,
820 struct elf_file_map* fmap_link)
822 static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
823 static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'};
824 const size_t globalDebugDirLen = sizeof(globalDebugDirW) / sizeof(WCHAR);
829 filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0);
830 p = HeapAlloc(GetProcessHeap(), 0,
831 (globalDebugDirLen + strlenW(loaded_file) + 6 + 1 + filename_len + 1) * sizeof(WCHAR));
832 if (!p) return FALSE;
834 /* we prebuild the string with "execdir" */
835 strcpyW(p, loaded_file);
836 slash = strrchrW(p, '/');
837 if (slash == NULL) slash = p; else slash++;
839 /* testing execdir/filename */
840 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
841 if (elf_map_file(p, fmap_link)) goto found;
843 HeapValidate(GetProcessHeap(), 0, 0);
845 /* testing execdir/.debug/filename */
846 memcpy(slash, dotDebugW, sizeof(dotDebugW));
847 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + sizeof(dotDebugW) / sizeof(WCHAR), filename_len);
848 if (elf_map_file(p, fmap_link)) goto found;
850 /* testing globaldebugdir/execdir/filename */
851 memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR));
852 memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR));
853 slash += globalDebugDirLen;
854 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
855 if (elf_map_file(p, fmap_link)) goto found;
857 /* finally testing filename */
858 if (elf_map_file(slash, fmap_link)) goto found;
860 HeapFree(GetProcessHeap(), 0, p);
862 WARN("Couldn't locate or map %s\n", filename);
866 TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p));
870 /******************************************************************
871 * elf_debuglink_parse
873 * Parses a .gnu_debuglink section and loads the debug info from
874 * the external file specified there.
876 static BOOL elf_debuglink_parse (struct module* module,
878 struct hash_table* ht_symtab,
879 const BYTE* debuglink)
881 /* The content of a debug link section is:
882 * 1/ a NULL terminated string, containing the file name for the
884 * 2/ padding on 4 byte boundary
885 * 3/ CRC of the linked ELF file
888 const char* dbg_link = (char*)debuglink;
889 struct elf_file_map fmap_link;
892 link_file = elf_locate_debug_link(dbg_link, module->module.LoadedImageName, &fmap_link);
896 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
897 fmap_link.with_crc = 1;
898 ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
901 strcpyW(module->module.LoadedPdbName,link_file);
903 WARN("Couldn't load debug information from %s\n", debugstr_w(link_file));
904 elf_unmap_file(&fmap_link);
905 HeapFree(GetProcessHeap(), 0, link_file);
911 /******************************************************************
912 * elf_load_debug_info_from_map
914 * Loads the symbolic information from ELF module which mapping is described
916 * the module has been loaded at 'load_offset' address, so symbols' address
917 * relocation is performed.
918 * CRC is checked if fmap->with_crc is TRUE
920 * 0 if the file doesn't contain symbolic info (or this info cannot be
924 static BOOL elf_load_debug_info_from_map(struct module* module,
925 struct elf_file_map* fmap,
927 struct hash_table* ht_symtab)
929 BOOL ret = FALSE, lret;
930 const char* shstrtab;
932 int symtab_sect, dynsym_sect, stab_sect, stabstr_sect;
933 int debug_sect, debug_str_sect, debug_abbrev_sect;
934 int debug_line_sect, debug_loclist_sect;
936 struct elf_thunk_area thunks[] =
938 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
939 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
940 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
941 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
942 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
943 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
947 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
949 ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
950 debugstr_w(module->module.LoadedImageName), calc_crc32(fmap), fmap->crc);
951 /* we don't tolerate mis-matched files */
956 * Next, we need to find a few of the internal ELF headers within
957 * this thing. We need the main executable header, and the section
960 shstrtab = elf_map_section(fmap, fmap->elfhdr.e_shstrndx);
961 if (shstrtab == ELF_NO_MAP) return FALSE;
963 symtab_sect = dynsym_sect = stab_sect = stabstr_sect = -1;
964 debug_sect = debug_str_sect = debug_abbrev_sect = -1;
965 debug_line_sect = debug_loclist_sect = -1;
968 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
970 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stab") == 0)
972 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".stabstr") == 0)
974 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_info") == 0)
976 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_str") == 0)
978 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_abbrev") == 0)
979 debug_abbrev_sect = i;
980 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_line") == 0)
982 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".debug_loc") == 0)
983 debug_loclist_sect = i;
984 if (strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".gnu_debuglink") == 0)
986 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".symtab") == 0) &&
987 (fmap->sect[i].shdr.sh_type == SHT_SYMTAB))
989 if ((strcmp(shstrtab + fmap->sect[i].shdr.sh_name, ".dynsym") == 0) &&
990 (fmap->sect[i].shdr.sh_type == SHT_DYNSYM))
993 elf_unmap_section(fmap, fmap->elfhdr.e_shstrndx);
996 if (symtab_sect == -1)
998 /* if we don't have a symtab but a dynsym, process the dynsym
999 * section instead. It'll contain less (relevant) information,
1000 * but it'll be better than nothing
1002 if (dynsym_sect == -1) return FALSE;
1003 symtab_sect = dynsym_sect;
1006 module->module.SymType = SymExport;
1008 /* create a hash table for the symtab */
1009 elf_hash_symtab(module, pool, ht_symtab, fmap, symtab_sect, thunks);
1011 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1013 if (stab_sect != -1 && stabstr_sect != -1)
1016 const char* stabstr;
1018 stab = elf_map_section(fmap, stab_sect);
1019 stabstr = elf_map_section(fmap, stabstr_sect);
1020 if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP)
1022 /* OK, now just parse all of the stabs. */
1023 lret = stabs_parse(module, module->elf_info->elf_addr,
1024 stab, elf_get_map_size(fmap, stab_sect),
1025 stabstr, elf_get_map_size(fmap, stabstr_sect));
1027 /* and fill in the missing information for stabs */
1028 elf_finish_stabs_info(module, ht_symtab);
1030 WARN("Couldn't correctly read stabs\n");
1034 elf_unmap_section(fmap, stab_sect);
1035 elf_unmap_section(fmap, stabstr_sect);
1038 if (debug_sect != -1)
1040 /* Dwarf 2 debug information */
1041 const BYTE* dw2_debug;
1042 const BYTE* dw2_debug_abbrev;
1043 const BYTE* dw2_debug_str;
1044 const BYTE* dw2_debug_line;
1045 const BYTE* dw2_debug_loclist;
1047 TRACE("Loading Dwarf2 information for %s\n", module->module_name);
1049 dw2_debug = (const BYTE*) elf_map_section(fmap, debug_sect);
1050 dw2_debug_abbrev = (const BYTE*) elf_map_section(fmap, debug_abbrev_sect);
1051 dw2_debug_str = (const BYTE*) elf_map_section(fmap, debug_str_sect);
1052 dw2_debug_line = (const BYTE*) elf_map_section(fmap, debug_line_sect);
1053 dw2_debug_loclist = (const BYTE*) elf_map_section(fmap, debug_loclist_sect);
1054 if (dw2_debug != ELF_NO_MAP && dw2_debug_abbrev != ELF_NO_MAP && dw2_debug_str != ELF_NO_MAP)
1056 /* OK, now just parse dwarf2 debug infos. */
1057 lret = dwarf2_parse(module, module->elf_info->elf_addr, thunks,
1058 dw2_debug, elf_get_map_size(fmap, debug_sect),
1059 dw2_debug_abbrev, elf_get_map_size(fmap, debug_abbrev_sect),
1060 dw2_debug_str, elf_get_map_size(fmap, debug_str_sect),
1061 dw2_debug_line, elf_get_map_size(fmap, debug_line_sect),
1062 dw2_debug_loclist, elf_get_map_size(fmap, debug_loclist_sect));
1065 WARN("Couldn't correctly read stabs\n");
1068 elf_unmap_section(fmap, debug_sect);
1069 elf_unmap_section(fmap, debug_abbrev_sect);
1070 elf_unmap_section(fmap, debug_str_sect);
1071 elf_unmap_section(fmap, debug_line_sect);
1072 elf_unmap_section(fmap, debug_loclist_sect);
1074 if (debuglink_sect != -1)
1076 const BYTE* dbg_link;
1078 dbg_link = (const BYTE*) elf_map_section(fmap, debuglink_sect);
1079 if (dbg_link != ELF_NO_MAP)
1081 lret = elf_debuglink_parse(module, pool, ht_symtab, dbg_link);
1083 WARN("Couldn't load linked debug file for %s\n",
1084 debugstr_w(module->module.ModuleName));
1087 elf_unmap_section(fmap, debuglink_sect);
1090 if (strstrW(module->module.ModuleName, S_ElfW) ||
1091 !strcmpW(module->module.ModuleName, S_WineLoaderW))
1093 /* add the thunks for native libraries */
1094 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1095 elf_new_wine_thunks(module, ht_symtab, thunks);
1097 /* add all the public symbols from symtab */
1098 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
1103 /******************************************************************
1104 * elf_load_debug_info
1106 * Loads ELF debugging information from the module image file.
1108 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1112 struct hash_table ht_symtab;
1113 struct elf_file_map my_fmap;
1115 if (module->type != DMT_ELF || !module->elf_info)
1117 ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName));
1121 pool_init(&pool, 65536);
1122 hash_table_init(&pool, &ht_symtab, 256);
1127 ret = elf_map_file(module->module.LoadedImageName, fmap);
1130 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
1132 pool_destroy(&pool);
1133 if (fmap == &my_fmap) elf_unmap_file(fmap);
1137 /******************************************************************
1138 * elf_fetch_file_info
1140 * Gathers some more information for an ELF module from a given file
1142 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1143 DWORD* size, DWORD* checksum)
1145 struct elf_file_map fmap;
1147 if (!elf_map_file(name, &fmap)) return FALSE;
1148 if (base) *base = fmap.elf_start;
1149 *size = fmap.elf_size;
1150 *checksum = calc_crc32(&fmap);
1151 elf_unmap_file(&fmap);
1155 /******************************************************************
1158 * Loads the information for ELF module stored in 'filename'
1159 * the module has been loaded at 'load_offset' address
1161 * -1 if the file cannot be found/opened
1162 * 0 if the file doesn't contain symbolic info (or this info cannot be
1166 static BOOL elf_load_file(struct process* pcs, const WCHAR* filename,
1167 unsigned long load_offset, struct elf_info* elf_info)
1170 struct elf_file_map fmap;
1173 TRACE("Processing elf file '%s' at %08lx\n", debugstr_w(filename), load_offset);
1175 if (!elf_map_file(filename, &fmap)) goto leave;
1177 /* Next, we need to find a few of the internal ELF headers within
1178 * this thing. We need the main executable header, and the section
1181 if (!fmap.elf_start && !load_offset)
1182 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1183 debugstr_w(filename));
1184 if (fmap.elf_start && load_offset)
1186 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1187 "Assuming load address is corrupt\n", debugstr_w(filename), load_offset);
1191 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1193 const char* shstrtab = elf_map_section(&fmap, fmap.elfhdr.e_shstrndx);
1194 if (shstrtab == ELF_NO_MAP) goto leave;
1195 for (i = 0; i < fmap.elfhdr.e_shnum; i++)
1197 if (strcmp(shstrtab + fmap.sect[i].shdr.sh_name, ".dynamic") == 0 &&
1198 fmap.sect[i].shdr.sh_type == SHT_DYNAMIC)
1201 char* ptr = (char*)fmap.sect[i].shdr.sh_addr;
1206 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1209 if (dyn.d_tag == DT_DEBUG)
1211 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1215 } while (dyn.d_tag != DT_NULL);
1216 if (dyn.d_tag == DT_NULL) goto leave;
1219 elf_unmap_section(&fmap, fmap.elfhdr.e_shstrndx);
1222 if (elf_info->flags & ELF_INFO_MODULE)
1224 struct elf_module_info *elf_module_info =
1225 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1226 if (!elf_module_info) goto leave;
1227 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1228 (load_offset) ? load_offset : fmap.elf_start,
1229 fmap.elf_size, 0, calc_crc32(&fmap));
1230 if (!elf_info->module)
1232 HeapFree(GetProcessHeap(), 0, elf_module_info);
1235 elf_info->module->elf_info = elf_module_info;
1236 elf_info->module->elf_info->elf_addr = load_offset;
1238 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1240 elf_info->module->module.SymType = SymDeferred;
1243 else ret = elf_load_debug_info(elf_info->module, &fmap);
1245 elf_info->module->elf_info->elf_mark = 1;
1246 elf_info->module->elf_info->elf_loader = 0;
1249 if (elf_info->flags & ELF_INFO_NAME)
1252 ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
1255 strcpyW(ptr, filename);
1256 elf_info->module_name = ptr;
1261 elf_unmap_file(&fmap);
1266 /******************************************************************
1267 * elf_load_file_from_path
1268 * tries to load an ELF file from a set of paths (separated by ':')
1270 static BOOL elf_load_file_from_path(HANDLE hProcess,
1271 const WCHAR* filename,
1272 unsigned long load_offset,
1274 struct elf_info* elf_info)
1278 WCHAR* pathW = NULL;
1281 if (!path) return FALSE;
1283 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1284 pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1285 if (!pathW) return FALSE;
1286 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, pathW, len);
1288 for (s = pathW; s && *s; s = (t) ? (t+1) : NULL)
1290 t = strchrW(s, ':');
1292 fn = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1 + lstrlenW(s) + 1) * sizeof(WCHAR));
1295 strcatW(fn, S_SlashW);
1296 strcatW(fn, filename);
1297 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1298 HeapFree(GetProcessHeap(), 0, fn);
1300 s = (t) ? (t+1) : NULL;
1303 HeapFree(GetProcessHeap(), 0, pathW);
1307 /******************************************************************
1308 * elf_load_file_from_dll_path
1310 * Tries to load an ELF file from the dll path
1312 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1313 const WCHAR* filename,
1314 unsigned long load_offset,
1315 struct elf_info* elf_info)
1318 unsigned int index = 0;
1321 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1326 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1328 name = HeapAlloc( GetProcessHeap(), 0,
1329 (len + lstrlenW(filename) + 2) * sizeof(WCHAR) );
1332 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, name, len);
1333 strcatW( name, S_SlashW );
1334 strcatW( name, filename );
1335 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1336 HeapFree( GetProcessHeap(), 0, name );
1341 /******************************************************************
1342 * elf_search_and_load_file
1344 * lookup a file in standard ELF locations, and if found, load it
1346 static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename,
1347 unsigned long load_offset,
1348 struct elf_info* elf_info)
1351 struct module* module;
1352 static WCHAR S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'};
1354 if (filename == NULL || *filename == '\0') return FALSE;
1355 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1357 elf_info->module = module;
1358 module->elf_info->elf_mark = 1;
1359 return module->module.SymType;
1362 if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */
1363 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1364 /* if relative pathname, try some absolute base dirs */
1365 if (!ret && !strchrW(filename, '/'))
1367 ret = elf_load_file_from_path(pcs, filename, load_offset,
1368 getenv("PATH"), elf_info) ||
1369 elf_load_file_from_path(pcs, filename, load_offset,
1370 getenv("LD_LIBRARY_PATH"), elf_info);
1371 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1377 /******************************************************************
1378 * elf_enum_modules_internal
1380 * Enumerate ELF modules from a running process
1382 static BOOL elf_enum_modules_internal(const struct process* pcs,
1383 const WCHAR* main_name,
1384 elf_enum_modules_cb cb, void* user)
1386 struct r_debug dbg_hdr;
1390 WCHAR bufstrW[MAX_PATH];
1392 if (!pcs->dbg_hdr_addr ||
1393 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1394 &dbg_hdr, sizeof(dbg_hdr), NULL))
1397 /* Now walk the linked list. In all known ELF implementations,
1398 * the dynamic loader maintains this linked list for us. In some
1399 * cases the first entry doesn't appear with a name, in other cases it
1402 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1404 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1407 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1408 lm.l_name != NULL &&
1409 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1411 bufstr[sizeof(bufstr) - 1] = '\0';
1412 MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR));
1413 if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
1414 if (!cb(bufstrW, (unsigned long)lm.l_addr, user)) break;
1422 struct process* pcs;
1423 struct elf_info elf_info;
1426 static BOOL elf_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user)
1428 struct elf_sync* es = user;
1430 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1434 /******************************************************************
1435 * elf_synchronize_module_list
1437 * this functions rescans the debuggee module's list and synchronizes it with
1438 * the one from 'pcs', ie:
1439 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1440 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1442 BOOL elf_synchronize_module_list(struct process* pcs)
1444 struct module* module;
1447 for (module = pcs->lmodules; module; module = module->next)
1449 if (module->type == DMT_ELF && !module->is_virtual)
1450 module->elf_info->elf_mark = 0;
1454 es.elf_info.flags = ELF_INFO_MODULE;
1455 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1458 module = pcs->lmodules;
1461 if (module->type == DMT_ELF && !module->is_virtual &&
1462 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1464 module_remove(pcs, module);
1465 /* restart all over */
1466 module = pcs->lmodules;
1468 else module = module->next;
1473 /******************************************************************
1476 * Lookup in a running ELF process the loader, and sets its ELF link
1477 * address (for accessing the list of loaded .so libs) in pcs.
1478 * If flags is ELF_INFO_MODULE, the module for the loader is also
1479 * added as a module into pcs.
1481 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1486 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1487 * main executable (either wine-kthread or wine-pthread)
1488 * FIXME: the heuristic used to know whether we need to load wine-pthread
1489 * or wine-kthread is not 100% safe
1491 if ((ptr = getenv("WINELOADER")))
1493 WCHAR tmp[MAX_PATH];
1494 MultiByteToWideChar(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp) / sizeof(WCHAR));
1495 ret = elf_search_and_load_file(pcs, tmp, 0, elf_info);
1499 ret = elf_search_and_load_file(pcs, S_WineKThreadW, 0, elf_info) ||
1500 elf_search_and_load_file(pcs, S_WinePThreadW, 0, elf_info);
1505 /******************************************************************
1506 * elf_read_wine_loader_dbg_info
1508 * Try to find a decent wine executable which could have loaded the debuggee
1510 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1512 struct elf_info elf_info;
1514 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1515 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1516 elf_info.module->elf_info->elf_loader = 1;
1517 module_set_module(elf_info.module, S_WineLoaderW);
1518 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1521 /******************************************************************
1524 * Enumerates the ELF loaded modules from a running target (hProc)
1525 * This function doesn't require that someone has called SymInitialize
1526 * on this very process.
1528 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1531 struct elf_info elf_info;
1534 memset(&pcs, 0, sizeof(pcs));
1536 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1537 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1538 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1539 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1540 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1546 struct process* pcs;
1547 struct elf_info elf_info;
1552 /******************************************************************
1555 * Callback for elf_load_module, used to walk the list of loaded
1558 static BOOL elf_load_cb(const WCHAR* name, unsigned long addr, void* user)
1560 struct elf_load* el = user;
1563 /* memcmp is needed for matches when bufstr contains also version information
1564 * el->name: libc.so, name: libc.so.6.0
1566 p = strrchrW(name, '/');
1568 if (!memcmp(p, el->name, lstrlenW(el->name) * sizeof(WCHAR)))
1570 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1576 /******************************************************************
1579 * loads an ELF module and stores it in process' module list
1580 * Also, find module real name and load address from
1581 * the real loaded modules list in pcs address space
1583 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1587 TRACE("(%p %s %08lx)\n", pcs, debugstr_w(name), addr);
1589 el.elf_info.flags = ELF_INFO_MODULE;
1592 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1595 /* do only the lookup from the filename, not the path (as we lookup module
1596 * name in the process' loaded module list)
1598 el.name = strrchrW(name, '/');
1599 if (!el.name++) el.name = name;
1602 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1608 el.ret = elf_search_and_load_file(pcs, el.name, addr, &el.elf_info);
1610 if (!el.ret) return NULL;
1611 assert(el.elf_info.module);
1612 return el.elf_info.module;
1615 #else /* !__ELF__ */
1617 BOOL elf_synchronize_module_list(struct process* pcs)
1622 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1623 DWORD* size, DWORD* checksum)
1628 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1633 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1638 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1643 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1648 int elf_is_in_thunk_area(unsigned long addr,
1649 const struct elf_thunk_area* thunks)
1653 #endif /* __ELF__ */