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
117 const char* shstrtab;
118 struct elf_file_map* alternate; /* another ELF file (linked to this one) */
121 struct elf_section_map
123 struct elf_file_map* fmap;
129 struct hash_table_elt ht_elt;
130 const Elf32_Sym* symp;
131 struct symt_compiland* compiland;
135 struct elf_thunk_area
138 THUNK_ORDINAL ordinal;
139 unsigned long rva_start;
140 unsigned long rva_end;
143 /******************************************************************
146 * Maps a single section into memory from an ELF file
148 static const char* elf_map_section(struct elf_section_map* esm)
150 unsigned pgsz = getpagesize();
153 if (esm->sidx < 0 || esm->sidx >= esm->fmap->elfhdr.e_shnum ||
154 esm->fmap->sect[esm->sidx].shdr.sh_type == SHT_NOBITS)
157 /* align required information on page size (we assume pagesize is a power of 2) */
158 ofst = esm->fmap->sect[esm->sidx].shdr.sh_offset & ~(pgsz - 1);
159 size = ((esm->fmap->sect[esm->sidx].shdr.sh_offset +
160 esm->fmap->sect[esm->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst;
161 esm->fmap->sect[esm->sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE,
162 esm->fmap->fd, ofst);
163 if (esm->fmap->sect[esm->sidx].mapped == ELF_NO_MAP) return ELF_NO_MAP;
164 return esm->fmap->sect[esm->sidx].mapped + (esm->fmap->sect[esm->sidx].shdr.sh_offset & (pgsz - 1));
167 /******************************************************************
170 * Finds a section by name (and type) into memory from an ELF file
171 * or its alternate if any
173 static BOOL elf_find_section(struct elf_file_map* fmap, const char* name,
174 unsigned sht, struct elf_section_map* esm)
180 if (fmap->shstrtab == ELF_NO_MAP)
182 struct elf_section_map hdr_esm = {fmap, fmap->elfhdr.e_shstrndx};
183 fmap->shstrtab = elf_map_section(&hdr_esm);
184 if (fmap->shstrtab == ELF_NO_MAP) return FALSE;
186 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
188 if (strcmp(fmap->shstrtab + fmap->sect[i].shdr.sh_name, name) == 0 &&
189 (sht == SHT_NULL || sht == fmap->sect[i].shdr.sh_type))
196 fmap = fmap->alternate;
201 /******************************************************************
204 * Unmaps a single section from memory
206 static void elf_unmap_section(struct elf_section_map* esm)
208 if (esm->sidx >= 0 && esm->sidx < esm->fmap->elfhdr.e_shnum && esm->fmap->sect[esm->sidx].mapped != ELF_NO_MAP)
210 unsigned pgsz = getpagesize();
213 ofst = esm->fmap->sect[esm->sidx].shdr.sh_offset & ~(pgsz - 1);
214 size = ((esm->fmap->sect[esm->sidx].shdr.sh_offset +
215 esm->fmap->sect[esm->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst;
216 if (munmap((char*)esm->fmap->sect[esm->sidx].mapped, size) < 0)
217 WARN("Couldn't unmap the section\n");
218 esm->fmap->sect[esm->sidx].mapped = ELF_NO_MAP;
222 static void elf_end_find(struct elf_file_map* fmap)
224 struct elf_section_map esm;
229 esm.sidx = fmap->elfhdr.e_shstrndx;
230 elf_unmap_section(&esm);
231 fmap->shstrtab = ELF_NO_MAP;
232 fmap = fmap->alternate;
236 /******************************************************************
239 * Get the size of an ELF section
241 static inline unsigned elf_get_map_size(struct elf_section_map* esm)
243 if (esm->sidx < 0 || esm->sidx >= esm->fmap->elfhdr.e_shnum)
245 return esm->fmap->sect[esm->sidx].shdr.sh_size;
248 /******************************************************************
251 * Maps an ELF file into memory (and checks it's a real ELF file)
253 static BOOL elf_map_file(const WCHAR* filenameW, struct elf_file_map* fmap)
255 static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 };
259 unsigned tmp, page_mask = getpagesize() - 1;
264 len = WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, NULL, 0, NULL, NULL);
265 if (!(filename = HeapAlloc(GetProcessHeap(), 0, len))) return FALSE;
266 WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, filename, len, NULL, NULL);
270 fmap->shstrtab = ELF_NO_MAP;
271 fmap->alternate = NULL;
273 /* check that the file exists, and that the module hasn't been loaded yet */
274 if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) goto done;
276 /* Now open the file, so that we can mmap() it. */
277 if ((fmap->fd = open(filename, O_RDONLY)) == -1) goto done;
279 if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr))
281 /* and check for an ELF header */
282 if (memcmp(fmap->elfhdr.e_ident,
283 elf_signature, sizeof(elf_signature))) goto done;
285 fmap->sect = HeapAlloc(GetProcessHeap(), 0,
286 fmap->elfhdr.e_shnum * sizeof(fmap->sect[0]));
287 if (!fmap->sect) goto done;
289 lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET);
290 for (i = 0; i < fmap->elfhdr.e_shnum; i++)
292 read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr));
293 fmap->sect[i].mapped = ELF_NO_MAP;
296 /* grab size of module once loaded in memory */
297 lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET);
299 fmap->elf_start = ~0L;
300 for (i = 0; i < fmap->elfhdr.e_phnum; i++)
302 if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) &&
303 phdr.p_type == PT_LOAD)
305 tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask;
306 if (fmap->elf_size < tmp) fmap->elf_size = tmp;
307 if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr;
310 /* if non relocatable ELF, then remove fixed address from computation
311 * otherwise, all addresses are zero based and start has no effect
313 fmap->elf_size -= fmap->elf_start;
316 HeapFree(GetProcessHeap(), 0, filename);
320 /******************************************************************
323 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
325 static void elf_unmap_file(struct elf_file_map* fmap)
331 struct elf_section_map esm;
333 for (esm.sidx = 0; esm.sidx < fmap->elfhdr.e_shnum; esm.sidx++)
335 elf_unmap_section(&esm);
337 HeapFree(GetProcessHeap(), 0, fmap->sect);
340 fmap = fmap->alternate;
344 /******************************************************************
345 * elf_is_in_thunk_area
347 * Check whether an address lies within one of the thunk area we
350 int elf_is_in_thunk_area(unsigned long addr,
351 const struct elf_thunk_area* thunks)
355 for (i = 0; thunks[i].symname; i++)
357 if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end)
363 /******************************************************************
366 * creating an internal hash table to ease use ELF symtab information lookup
368 static void elf_hash_symtab(struct module* module, struct pool* pool,
369 struct hash_table* ht_symtab, struct elf_file_map* fmap,
370 struct elf_thunk_area* thunks)
375 struct symt_compiland* compiland = NULL;
377 const Elf32_Sym* symp;
378 struct symtab_elt* ste;
379 struct elf_section_map esm, esm_str;
381 if (!elf_find_section(fmap, ".symtab", SHT_SYMTAB, &esm) &&
382 !elf_find_section(fmap, ".dynsym", SHT_DYNSYM, &esm)) return;
383 if ((symp = (const Elf32_Sym*)elf_map_section(&esm)) == ELF_NO_MAP) return;
385 esm_str.sidx = fmap->sect[esm.sidx].shdr.sh_link;
386 if ((strp = elf_map_section(&esm_str)) == ELF_NO_MAP) return;
388 nsym = elf_get_map_size(&esm) / sizeof(*symp);
390 for (j = 0; thunks[j].symname; j++)
391 thunks[j].rva_start = thunks[j].rva_end = 0;
393 for (i = 0; i < nsym; i++, symp++)
395 /* Ignore certain types of entries which really aren't of that much
398 if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE &&
399 ELF32_ST_TYPE(symp->st_info) != STT_FILE &&
400 ELF32_ST_TYPE(symp->st_info) != STT_OBJECT &&
401 ELF32_ST_TYPE(symp->st_info) != STT_FUNC) ||
402 symp->st_shndx == SHN_UNDEF)
407 symname = strp + symp->st_name;
409 /* handle some specific symtab (that we'll throw away when done) */
410 switch (ELF32_ST_TYPE(symp->st_info))
414 compiland = symt_new_compiland(module, symp->st_value,
415 source_new(module, NULL, symname));
420 /* we are only interested in wine markers inserted by winebuild */
421 for (j = 0; thunks[j].symname; j++)
423 if (!strcmp(symname, thunks[j].symname))
425 thunks[j].rva_start = symp->st_value;
426 thunks[j].rva_end = symp->st_value + symp->st_size;
433 /* FIXME: we don't need to handle them (GCC internals)
434 * Moreover, they screw up our symbol lookup :-/
436 if (symname[0] == '.' && symname[1] == 'L' && isdigit(symname[2]))
439 ste = pool_alloc(pool, sizeof(*ste));
440 ste->ht_elt.name = symname;
441 /* GCC emits, in some cases, a .<digit>+ suffix.
442 * This is used for static variable inside functions, so
443 * that we can have several such variables with same name in
444 * the same compilation unit
445 * We simply ignore that suffix when present (we also get rid
446 * of it in stabs parsing)
448 ptr = symname + strlen(symname) - 1;
451 while (isdigit(*ptr) && ptr >= symname) ptr--;
452 if (ptr > symname && *ptr == '.')
454 char* n = pool_alloc(pool, ptr - symname + 1);
455 memcpy(n, symname, ptr - symname + 1);
456 n[ptr - symname] = '\0';
457 ste->ht_elt.name = n;
461 ste->compiland = compiland;
463 hash_table_add(ht_symtab, &ste->ht_elt);
465 /* as we added in the ht_symtab pointers to the symbols themselves,
466 * we cannot unmap yet the sections, it will be done when we're over
471 /******************************************************************
474 * lookup a symbol by name in our internal hash table for the symtab
476 static const Elf32_Sym* elf_lookup_symtab(const struct module* module,
477 const struct hash_table* ht_symtab,
478 const char* name, struct symt* compiland)
480 struct symtab_elt* weak_result = NULL; /* without compiland name */
481 struct symtab_elt* result = NULL;
482 struct hash_table_iter hti;
483 struct symtab_elt* ste;
484 const char* compiland_name;
485 const char* compiland_basename;
488 /* we need weak match up (at least) when symbols of same name,
489 * defined several times in different compilation units,
490 * are merged in a single one (hence a different filename for c.u.)
494 compiland_name = source_get(module,
495 ((struct symt_compiland*)compiland)->source);
496 compiland_basename = strrchr(compiland_name, '/');
497 if (!compiland_basename++) compiland_basename = compiland_name;
499 else compiland_name = compiland_basename = NULL;
501 hash_table_iter_init(ht_symtab, &hti, name);
502 while ((ste = hash_table_iter_up(&hti)))
504 if (ste->used || strcmp(ste->ht_elt.name, name)) continue;
507 if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name))
509 if (ste->compiland && compiland_name)
511 const char* filename = source_get(module, ste->compiland->source);
512 if (strcmp(filename, compiland_name))
514 base = strrchr(filename, '/');
515 if (!base++) base = filename;
516 if (strcmp(base, compiland_basename)) continue;
521 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
522 name, compiland_name,
523 source_get(module, result->compiland->source), result->symp->st_value,
524 source_get(module, ste->compiland->source), ste->symp->st_value);
532 if (!result && !(result = weak_result))
534 FIXME("Couldn't find symbol %s!%s in symtab\n",
535 module->module_name, name);
541 /******************************************************************
542 * elf_finish_stabs_info
544 * - get any relevant information (address & size) from the bits we got from the
545 * stabs debugging information
547 static void elf_finish_stabs_info(struct module* module, struct hash_table* symtab)
549 struct hash_table_iter hti;
552 const Elf32_Sym* symp;
554 hash_table_iter_init(&module->ht_symbols, &hti, NULL);
555 while ((ptr = hash_table_iter_up(&hti)))
557 sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
558 switch (sym->symt.tag)
561 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
562 ((struct symt_function*)sym)->size)
566 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
567 ((struct symt_function*)sym)->container);
570 if (((struct symt_function*)sym)->address != module->elf_info->elf_addr &&
571 ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value)
572 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
573 sym, module->module_name, sym->hash_elt.name,
574 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
575 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
576 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
577 sym, module->module_name, sym->hash_elt.name,
578 ((struct symt_function*)sym)->size, symp->st_size);
580 ((struct symt_function*)sym)->address = module->elf_info->elf_addr +
582 ((struct symt_function*)sym)->size = symp->st_size;
583 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
586 switch (((struct symt_data*)sym)->kind)
589 case DataIsFileStatic:
590 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr)
592 symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name,
593 ((struct symt_data*)sym)->container);
596 if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr &&
597 ((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr + symp->st_value)
598 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
599 sym, module->module_name, sym->hash_elt.name,
600 ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value);
601 ((struct symt_data*)sym)->u.var.offset = module->elf_info->elf_addr +
603 ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ?
604 DataIsFileStatic : DataIsGlobal;
605 } else FIXME("Couldn't find %s!%s\n", module->module_name, sym->hash_elt.name);
611 FIXME("Unsupported tag %u\n", sym->symt.tag);
615 /* since we may have changed some addresses & sizes, mark the module to be resorted */
616 module->sortlist_valid = FALSE;
619 /******************************************************************
620 * elf_load_wine_thunks
622 * creating the thunk objects for a wine native DLL
624 static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab,
625 const struct elf_thunk_area* thunks)
628 struct hash_table_iter hti;
629 struct symtab_elt* ste;
631 struct symt_ht* symt;
633 hash_table_iter_init(ht_symtab, &hti, NULL);
634 while ((ste = hash_table_iter_up(&hti)))
636 if (ste->used) continue;
638 addr = module->elf_info->elf_addr + ste->symp->st_value;
640 j = elf_is_in_thunk_area(ste->symp->st_value, thunks);
641 if (j >= 0) /* thunk found */
643 symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal,
644 addr, ste->symp->st_size);
650 symt = symt_find_nearest(module, addr);
652 symt_get_info(&symt->symt, TI_GET_ADDRESS, &ref_addr);
653 if (!symt || addr != ref_addr)
655 /* creating public symbols for all the ELF symbols which haven't been
656 * used yet (ie we have no debug information on them)
657 * That's the case, for example, of the .spec.c files
659 switch (ELF32_ST_TYPE(ste->symp->st_info))
662 symt_new_function(module, ste->compiland, ste->ht_elt.name,
663 addr, ste->symp->st_size, NULL);
666 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
667 ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL,
668 addr, ste->symp->st_size, NULL);
671 FIXME("Shouldn't happen\n");
674 /* FIXME: this is a hack !!!
675 * we are adding new symbols, but as we're parsing a symbol table
676 * (hopefully without duplicate symbols) we delay rebuilding the sorted
677 * module table until we're done with the symbol table
678 * Otherwise, as we intertwine symbols's add and lookup, performance
681 module->sortlist_valid = TRUE;
683 else if (strcmp(ste->ht_elt.name, symt->hash_elt.name))
685 ULONG64 xaddr = 0, xsize = 0;
688 symt_get_info(&symt->symt, TI_GET_ADDRESS, &xaddr);
689 symt_get_info(&symt->symt, TI_GET_LENGTH, &xsize);
690 symt_get_info(&symt->symt, TI_GET_DATAKIND, &kind);
692 /* If none of symbols has a correct size, we consider they are both markers
693 * Hence, we can silence this warning
694 * Also, we check that we don't have two symbols, one local, the other
695 * global which is legal
697 if ((xsize || ste->symp->st_size) &&
698 (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal))
699 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
701 ste->ht_elt.name, addr, ste->symp->st_size,
703 wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize));
707 /* see comment above */
708 module->sortlist_valid = FALSE;
712 /******************************************************************
713 * elf_new_public_symbols
715 * Creates a set of public symbols from an ELF symtab
717 static int elf_new_public_symbols(struct module* module, struct hash_table* symtab)
719 struct hash_table_iter hti;
720 struct symtab_elt* ste;
722 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
724 /* FIXME: we're missing the ELF entry point here */
726 hash_table_iter_init(symtab, &hti, NULL);
727 while ((ste = hash_table_iter_up(&hti)))
729 symt_new_public(module, ste->compiland, ste->ht_elt.name,
730 module->elf_info->elf_addr + ste->symp->st_value,
731 ste->symp->st_size, TRUE /* FIXME */,
732 ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC);
737 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
738 the following calc_crc32 code or tables extracted from it, as desired without
741 /**********************************************************************\
742 |* Demonstration program to compute the 32-bit CRC used as the frame *|
743 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
744 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
745 |* protocol). The 32-bit FCS was added via the Federal Register, *|
746 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
747 |* this polynomial is or will be included in CCITT V.41, which *|
748 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
749 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
750 |* errors by a factor of 10^-5 over 16-bit FCS. *|
751 \**********************************************************************/
753 /* First, the polynomial itself and its table of feedback terms. The */
755 /* 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 */
756 /* Note that we take it "backwards" and put the highest-order term in */
757 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
758 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
759 /* the MSB being 1. */
761 /* Note that the usual hardware shift register implementation, which */
762 /* is what we're using (we're merely optimizing it by doing eight-bit */
763 /* chunks at a time) shifts bits into the lowest-order term. In our */
764 /* implementation, that means shifting towards the right. Why do we */
765 /* do it this way? Because the calculated CRC must be transmitted in */
766 /* order from highest-order term to lowest-order term. UARTs transmit */
767 /* characters in order from LSB to MSB. By storing the CRC this way, */
768 /* we hand it to the UART in the order low-byte to high-byte; the UART */
769 /* sends each low-bit to hight-bit; and the result is transmission bit */
770 /* by bit from highest- to lowest-order term without requiring any bit */
771 /* shuffling on our part. Reception works similarly. */
773 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
775 /* 1. The table can be generated at runtime if desired; code to do so */
776 /* is shown later. It might not be obvious, but the feedback */
777 /* terms simply represent the results of eight shift/xor opera- */
778 /* tions for all combinations of data and CRC register values. */
780 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
781 /* be they sixteen or thirty-two bits wide. You simply choose the */
782 /* appropriate table. Alternatively, because the table can be */
783 /* generated at runtime, you can start by generating the table for */
784 /* the polynomial in question and use exactly the same "updcrc", */
785 /* if your application needn't simultaneously handle two CRC */
786 /* polynomials. (Note, however, that XMODEM is strange.) */
788 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
789 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
791 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
792 /* logic; the shift must be unsigned (bring in zeroes). On some */
793 /* hardware you could probably optimize the shift in assembler by */
794 /* using byte-swap instructions. */
797 static DWORD calc_crc32(struct elf_file_map* fmap)
799 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
800 static const DWORD crc_32_tab[] =
801 { /* CRC polynomial 0xedb88320 */
802 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
803 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
804 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
805 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
806 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
807 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
808 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
809 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
810 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
811 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
812 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
813 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
814 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
815 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
816 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
817 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
818 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
819 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
820 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
821 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
822 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
823 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
824 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
825 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
826 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
827 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
828 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
829 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
830 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
831 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
832 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
833 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
834 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
835 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
836 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
837 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
838 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
839 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
840 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
841 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
842 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
843 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
844 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
847 unsigned char buffer[256];
850 lseek(fmap->fd, 0, SEEK_SET);
851 while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0)
853 for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc);
859 static BOOL elf_load_debug_info_from_map(struct module* module,
860 struct elf_file_map* fmap,
862 struct hash_table* ht_symtab);
864 /******************************************************************
865 * elf_locate_debug_link
867 * Locate a filename from a .gnu_debuglink section, using the same
869 * "If the full name of the directory containing the executable is
870 * execdir, and the executable has a debug link that specifies the
871 * name debugfile, then GDB will automatically search for the
872 * debugging information file in three places:
873 * - the directory containing the executable file (that is, it
874 * will look for a file named `execdir/debugfile',
875 * - a subdirectory of that directory named `.debug' (that is, the
876 * file `execdir/.debug/debugfile', and
877 * - a subdirectory of the global debug file directory that includes
878 * the executable's full path, and the name from the link (that is,
879 * the file `globaldebugdir/execdir/debugfile', where globaldebugdir
880 * is the global debug file directory, and execdir has been turned
881 * into a relative path)." (from GDB manual)
883 static WCHAR* elf_locate_debug_link(const char* filename, const WCHAR* loaded_file,
884 struct elf_file_map* fmap_link)
886 static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
887 static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'};
888 const size_t globalDebugDirLen = sizeof(globalDebugDirW) / sizeof(WCHAR);
893 filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0);
894 p = HeapAlloc(GetProcessHeap(), 0,
895 (globalDebugDirLen + strlenW(loaded_file) + 6 + 1 + filename_len + 1) * sizeof(WCHAR));
896 if (!p) return FALSE;
898 /* we prebuild the string with "execdir" */
899 strcpyW(p, loaded_file);
900 slash = strrchrW(p, '/');
901 if (slash == NULL) slash = p; else slash++;
903 /* testing execdir/filename */
904 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
905 if (elf_map_file(p, fmap_link)) goto found;
907 HeapValidate(GetProcessHeap(), 0, 0);
909 /* testing execdir/.debug/filename */
910 memcpy(slash, dotDebugW, sizeof(dotDebugW));
911 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + sizeof(dotDebugW) / sizeof(WCHAR), filename_len);
912 if (elf_map_file(p, fmap_link)) goto found;
914 /* testing globaldebugdir/execdir/filename */
915 memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR));
916 memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR));
917 slash += globalDebugDirLen;
918 MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
919 if (elf_map_file(p, fmap_link)) goto found;
921 /* finally testing filename */
922 if (elf_map_file(slash, fmap_link)) goto found;
924 HeapFree(GetProcessHeap(), 0, p);
926 WARN("Couldn't locate or map %s\n", filename);
930 TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p));
934 /******************************************************************
935 * elf_debuglink_parse
937 * Parses a .gnu_debuglink section and loads the debug info from
938 * the external file specified there.
940 static BOOL elf_debuglink_parse (struct module* module,
942 struct hash_table* ht_symtab,
943 const BYTE* debuglink)
945 /* The content of a debug link section is:
946 * 1/ a NULL terminated string, containing the file name for the
948 * 2/ padding on 4 byte boundary
949 * 3/ CRC of the linked ELF file
952 const char* dbg_link = (char*)debuglink;
953 struct elf_file_map fmap_link;
956 link_file = elf_locate_debug_link(dbg_link, module->module.LoadedImageName, &fmap_link);
960 fmap_link.crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
961 fmap_link.with_crc = 1;
962 ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
965 strcpyW(module->module.LoadedPdbName,link_file);
967 WARN("Couldn't load debug information from %s\n", debugstr_w(link_file));
968 elf_unmap_file(&fmap_link);
969 HeapFree(GetProcessHeap(), 0, link_file);
975 /******************************************************************
976 * elf_load_debug_info_from_map
978 * Loads the symbolic information from ELF module which mapping is described
980 * the module has been loaded at 'load_offset' address, so symbols' address
981 * relocation is performed.
982 * CRC is checked if fmap->with_crc is TRUE
984 * 0 if the file doesn't contain symbolic info (or this info cannot be
988 static BOOL elf_load_debug_info_from_map(struct module* module,
989 struct elf_file_map* fmap,
991 struct hash_table* ht_symtab)
993 BOOL ret = FALSE, lret;
994 struct elf_thunk_area thunks[] =
996 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */
997 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
998 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
999 {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */
1000 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
1001 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
1005 if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
1007 ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
1008 debugstr_w(module->module.LoadedImageName), calc_crc32(fmap), fmap->crc);
1009 /* we don't tolerate mis-matched files */
1013 module->module.SymType = SymExport;
1015 /* create a hash table for the symtab */
1016 elf_hash_symtab(module, pool, ht_symtab, fmap, thunks);
1018 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1020 struct elf_section_map stab_sect, stabstr_sect;
1021 struct elf_section_map debug_sect, debug_str_sect, debug_abbrev_sect,
1022 debug_line_sect, debug_loclist_sect;
1023 struct elf_section_map debuglink_sect;
1025 if (elf_find_section(fmap, ".stab", SHT_NULL, &stab_sect) &&
1026 elf_find_section(fmap, ".stabstr", SHT_NULL, &stabstr_sect))
1029 const char* stabstr;
1031 stab = elf_map_section(&stab_sect);
1032 stabstr = elf_map_section(&stabstr_sect);
1033 if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP)
1035 /* OK, now just parse all of the stabs. */
1036 lret = stabs_parse(module, module->elf_info->elf_addr,
1037 stab, elf_get_map_size(&stab_sect),
1038 stabstr, elf_get_map_size(&stabstr_sect));
1040 /* and fill in the missing information for stabs */
1041 elf_finish_stabs_info(module, ht_symtab);
1043 WARN("Couldn't correctly read stabs\n");
1047 elf_unmap_section(&stab_sect);
1048 elf_unmap_section(&stabstr_sect);
1050 if (elf_find_section(fmap, ".debug_info", SHT_NULL, &debug_sect))
1052 /* Dwarf 2 debug information */
1053 const BYTE* dw2_debug;
1054 const BYTE* dw2_debug_abbrev;
1055 const BYTE* dw2_debug_str;
1056 const BYTE* dw2_debug_line;
1057 const BYTE* dw2_debug_loclist;
1059 TRACE("Loading Dwarf2 information for %s\n", module->module_name);
1061 elf_find_section(fmap, ".debug_str", SHT_NULL, &debug_str_sect);
1062 elf_find_section(fmap, ".debug_abbrev", SHT_NULL, &debug_abbrev_sect);
1063 elf_find_section(fmap, ".debug_line", SHT_NULL, &debug_line_sect);
1064 elf_find_section(fmap, ".debug_loc", SHT_NULL, &debug_loclist_sect);
1066 dw2_debug = (const BYTE*)elf_map_section(&debug_sect);
1067 dw2_debug_abbrev = (const BYTE*)elf_map_section(&debug_abbrev_sect);
1068 dw2_debug_str = (const BYTE*)elf_map_section(&debug_str_sect);
1069 dw2_debug_line = (const BYTE*)elf_map_section(&debug_line_sect);
1070 dw2_debug_loclist = (const BYTE*)elf_map_section(&debug_loclist_sect);
1071 if (dw2_debug != ELF_NO_MAP && dw2_debug_abbrev != ELF_NO_MAP && dw2_debug_str != ELF_NO_MAP)
1073 /* OK, now just parse dwarf2 debug infos. */
1074 lret = dwarf2_parse(module, module->elf_info->elf_addr, thunks,
1075 dw2_debug, elf_get_map_size(&debug_sect),
1076 dw2_debug_abbrev, elf_get_map_size(&debug_abbrev_sect),
1077 dw2_debug_str, elf_get_map_size(&debug_str_sect),
1078 dw2_debug_line, elf_get_map_size(&debug_line_sect),
1079 dw2_debug_loclist, elf_get_map_size(&debug_loclist_sect));
1082 WARN("Couldn't correctly read stabs\n");
1085 elf_unmap_section(&debug_sect);
1086 elf_unmap_section(&debug_abbrev_sect);
1087 elf_unmap_section(&debug_str_sect);
1088 elf_unmap_section(&debug_line_sect);
1089 elf_unmap_section(&debug_loclist_sect);
1091 if (elf_find_section(fmap, ".gnu_debuglink", SHT_NULL, &debuglink_sect))
1093 const BYTE* dbg_link;
1095 dbg_link = (const BYTE*)elf_map_section(&debuglink_sect);
1096 if (dbg_link != ELF_NO_MAP)
1098 lret = elf_debuglink_parse(module, pool, ht_symtab, dbg_link);
1100 WARN("Couldn't load linked debug file for %s\n",
1101 debugstr_w(module->module.ModuleName));
1104 elf_unmap_section(&debuglink_sect);
1107 if (strstrW(module->module.ModuleName, S_ElfW) ||
1108 !strcmpW(module->module.ModuleName, S_WineLoaderW))
1110 /* add the thunks for native libraries */
1111 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
1112 elf_new_wine_thunks(module, ht_symtab, thunks);
1114 /* add all the public symbols from symtab */
1115 if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE;
1120 /******************************************************************
1121 * elf_load_debug_info
1123 * Loads ELF debugging information from the module image file.
1125 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1129 struct hash_table ht_symtab;
1130 struct elf_file_map my_fmap;
1132 if (module->type != DMT_ELF || !module->elf_info)
1134 ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName));
1138 pool_init(&pool, 65536);
1139 hash_table_init(&pool, &ht_symtab, 256);
1144 ret = elf_map_file(module->module.LoadedImageName, fmap);
1147 ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
1149 pool_destroy(&pool);
1150 if (fmap == &my_fmap) elf_unmap_file(fmap);
1154 /******************************************************************
1155 * elf_fetch_file_info
1157 * Gathers some more information for an ELF module from a given file
1159 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1160 DWORD* size, DWORD* checksum)
1162 struct elf_file_map fmap;
1164 if (!elf_map_file(name, &fmap)) return FALSE;
1165 if (base) *base = fmap.elf_start;
1166 *size = fmap.elf_size;
1167 *checksum = calc_crc32(&fmap);
1168 elf_unmap_file(&fmap);
1172 /******************************************************************
1175 * Loads the information for ELF module stored in 'filename'
1176 * the module has been loaded at 'load_offset' address
1178 * -1 if the file cannot be found/opened
1179 * 0 if the file doesn't contain symbolic info (or this info cannot be
1183 static BOOL elf_load_file(struct process* pcs, const WCHAR* filename,
1184 unsigned long load_offset, struct elf_info* elf_info)
1187 struct elf_file_map fmap;
1189 TRACE("Processing elf file '%s' at %08lx\n", debugstr_w(filename), load_offset);
1191 if (!elf_map_file(filename, &fmap)) goto leave;
1193 /* Next, we need to find a few of the internal ELF headers within
1194 * this thing. We need the main executable header, and the section
1197 if (!fmap.elf_start && !load_offset)
1198 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1199 debugstr_w(filename));
1200 if (fmap.elf_start && load_offset)
1202 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1203 "Assuming load address is corrupt\n", debugstr_w(filename), load_offset);
1207 if (elf_info->flags & ELF_INFO_DEBUG_HEADER)
1209 struct elf_section_map esm;
1211 if (elf_find_section(&fmap, ".dynamic", SHT_DYNAMIC, &esm))
1214 char* ptr = (char*)fmap.sect[esm.sidx].shdr.sh_addr;
1219 if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) ||
1222 if (dyn.d_tag == DT_DEBUG)
1224 elf_info->dbg_hdr_addr = dyn.d_un.d_ptr;
1228 } while (dyn.d_tag != DT_NULL);
1229 if (dyn.d_tag == DT_NULL) goto leave;
1231 elf_end_find(&fmap);
1234 if (elf_info->flags & ELF_INFO_MODULE)
1236 struct elf_module_info *elf_module_info =
1237 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
1238 if (!elf_module_info) goto leave;
1239 elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
1240 (load_offset) ? load_offset : fmap.elf_start,
1241 fmap.elf_size, 0, calc_crc32(&fmap));
1242 if (!elf_info->module)
1244 HeapFree(GetProcessHeap(), 0, elf_module_info);
1247 elf_info->module->elf_info = elf_module_info;
1248 elf_info->module->elf_info->elf_addr = load_offset;
1250 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
1252 elf_info->module->module.SymType = SymDeferred;
1255 else ret = elf_load_debug_info(elf_info->module, &fmap);
1257 elf_info->module->elf_info->elf_mark = 1;
1258 elf_info->module->elf_info->elf_loader = 0;
1261 if (elf_info->flags & ELF_INFO_NAME)
1264 ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
1267 strcpyW(ptr, filename);
1268 elf_info->module_name = ptr;
1273 elf_unmap_file(&fmap);
1278 /******************************************************************
1279 * elf_load_file_from_path
1280 * tries to load an ELF file from a set of paths (separated by ':')
1282 static BOOL elf_load_file_from_path(HANDLE hProcess,
1283 const WCHAR* filename,
1284 unsigned long load_offset,
1286 struct elf_info* elf_info)
1290 WCHAR* pathW = NULL;
1293 if (!path) return FALSE;
1295 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1296 pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1297 if (!pathW) return FALSE;
1298 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, pathW, len);
1300 for (s = pathW; s && *s; s = (t) ? (t+1) : NULL)
1302 t = strchrW(s, ':');
1304 fn = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1 + lstrlenW(s) + 1) * sizeof(WCHAR));
1307 strcatW(fn, S_SlashW);
1308 strcatW(fn, filename);
1309 ret = elf_load_file(hProcess, fn, load_offset, elf_info);
1310 HeapFree(GetProcessHeap(), 0, fn);
1312 s = (t) ? (t+1) : NULL;
1315 HeapFree(GetProcessHeap(), 0, pathW);
1319 /******************************************************************
1320 * elf_load_file_from_dll_path
1322 * Tries to load an ELF file from the dll path
1324 static BOOL elf_load_file_from_dll_path(HANDLE hProcess,
1325 const WCHAR* filename,
1326 unsigned long load_offset,
1327 struct elf_info* elf_info)
1330 unsigned int index = 0;
1333 while (!ret && (path = wine_dll_enum_load_path( index++ )))
1338 len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1340 name = HeapAlloc( GetProcessHeap(), 0,
1341 (len + lstrlenW(filename) + 2) * sizeof(WCHAR) );
1344 MultiByteToWideChar(CP_UNIXCP, 0, path, -1, name, len);
1345 strcatW( name, S_SlashW );
1346 strcatW( name, filename );
1347 ret = elf_load_file(hProcess, name, load_offset, elf_info);
1348 HeapFree( GetProcessHeap(), 0, name );
1353 /******************************************************************
1354 * elf_search_and_load_file
1356 * lookup a file in standard ELF locations, and if found, load it
1358 static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename,
1359 unsigned long load_offset,
1360 struct elf_info* elf_info)
1363 struct module* module;
1364 static WCHAR S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'};
1366 if (filename == NULL || *filename == '\0') return FALSE;
1367 if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
1369 elf_info->module = module;
1370 module->elf_info->elf_mark = 1;
1371 return module->module.SymType;
1374 if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */
1375 ret = elf_load_file(pcs, filename, load_offset, elf_info);
1376 /* if relative pathname, try some absolute base dirs */
1377 if (!ret && !strchrW(filename, '/'))
1379 ret = elf_load_file_from_path(pcs, filename, load_offset,
1380 getenv("PATH"), elf_info) ||
1381 elf_load_file_from_path(pcs, filename, load_offset,
1382 getenv("LD_LIBRARY_PATH"), elf_info);
1383 if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info);
1389 /******************************************************************
1390 * elf_enum_modules_internal
1392 * Enumerate ELF modules from a running process
1394 static BOOL elf_enum_modules_internal(const struct process* pcs,
1395 const WCHAR* main_name,
1396 elf_enum_modules_cb cb, void* user)
1398 struct r_debug dbg_hdr;
1402 WCHAR bufstrW[MAX_PATH];
1404 if (!pcs->dbg_hdr_addr ||
1405 !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1406 &dbg_hdr, sizeof(dbg_hdr), NULL))
1409 /* Now walk the linked list. In all known ELF implementations,
1410 * the dynamic loader maintains this linked list for us. In some
1411 * cases the first entry doesn't appear with a name, in other cases it
1414 for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next)
1416 if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL))
1419 if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */
1420 lm.l_name != NULL &&
1421 ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL))
1423 bufstr[sizeof(bufstr) - 1] = '\0';
1424 MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR));
1425 if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
1426 if (!cb(bufstrW, (unsigned long)lm.l_addr, user)) break;
1434 struct process* pcs;
1435 struct elf_info elf_info;
1438 static BOOL elf_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user)
1440 struct elf_sync* es = user;
1442 elf_search_and_load_file(es->pcs, name, addr, &es->elf_info);
1446 /******************************************************************
1447 * elf_synchronize_module_list
1449 * this functions rescans the debuggee module's list and synchronizes it with
1450 * the one from 'pcs', ie:
1451 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1452 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1454 BOOL elf_synchronize_module_list(struct process* pcs)
1456 struct module* module;
1459 for (module = pcs->lmodules; module; module = module->next)
1461 if (module->type == DMT_ELF && !module->is_virtual)
1462 module->elf_info->elf_mark = 0;
1466 es.elf_info.flags = ELF_INFO_MODULE;
1467 if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es))
1470 module = pcs->lmodules;
1473 if (module->type == DMT_ELF && !module->is_virtual &&
1474 !module->elf_info->elf_mark && !module->elf_info->elf_loader)
1476 module_remove(pcs, module);
1477 /* restart all over */
1478 module = pcs->lmodules;
1480 else module = module->next;
1485 /******************************************************************
1488 * Lookup in a running ELF process the loader, and sets its ELF link
1489 * address (for accessing the list of loaded .so libs) in pcs.
1490 * If flags is ELF_INFO_MODULE, the module for the loader is also
1491 * added as a module into pcs.
1493 static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info)
1498 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1499 * main executable (either wine-kthread or wine-pthread)
1500 * FIXME: the heuristic used to know whether we need to load wine-pthread
1501 * or wine-kthread is not 100% safe
1503 if ((ptr = getenv("WINELOADER")))
1505 WCHAR tmp[MAX_PATH];
1506 MultiByteToWideChar(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp) / sizeof(WCHAR));
1507 ret = elf_search_and_load_file(pcs, tmp, 0, elf_info);
1511 ret = elf_search_and_load_file(pcs, S_WineKThreadW, 0, elf_info) ||
1512 elf_search_and_load_file(pcs, S_WinePThreadW, 0, elf_info);
1517 /******************************************************************
1518 * elf_read_wine_loader_dbg_info
1520 * Try to find a decent wine executable which could have loaded the debuggee
1522 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1524 struct elf_info elf_info;
1526 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
1527 if (!elf_search_loader(pcs, &elf_info)) return FALSE;
1528 elf_info.module->elf_info->elf_loader = 1;
1529 module_set_module(elf_info.module, S_WineLoaderW);
1530 return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
1533 /******************************************************************
1536 * Enumerates the ELF loaded modules from a running target (hProc)
1537 * This function doesn't require that someone has called SymInitialize
1538 * on this very process.
1540 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1543 struct elf_info elf_info;
1546 memset(&pcs, 0, sizeof(pcs));
1548 elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME;
1549 if (!elf_search_loader(&pcs, &elf_info)) return FALSE;
1550 pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr;
1551 ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user);
1552 HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name);
1558 struct process* pcs;
1559 struct elf_info elf_info;
1564 /******************************************************************
1567 * Callback for elf_load_module, used to walk the list of loaded
1570 static BOOL elf_load_cb(const WCHAR* name, unsigned long addr, void* user)
1572 struct elf_load* el = user;
1575 /* memcmp is needed for matches when bufstr contains also version information
1576 * el->name: libc.so, name: libc.so.6.0
1578 p = strrchrW(name, '/');
1580 if (!memcmp(p, el->name, lstrlenW(el->name) * sizeof(WCHAR)))
1582 el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info);
1588 /******************************************************************
1591 * loads an ELF module and stores it in process' module list
1592 * Also, find module real name and load address from
1593 * the real loaded modules list in pcs address space
1595 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1599 TRACE("(%p %s %08lx)\n", pcs, debugstr_w(name), addr);
1601 el.elf_info.flags = ELF_INFO_MODULE;
1604 if (pcs->dbg_hdr_addr) /* we're debugging a life target */
1607 /* do only the lookup from the filename, not the path (as we lookup module
1608 * name in the process' loaded module list)
1610 el.name = strrchrW(name, '/');
1611 if (!el.name++) el.name = name;
1614 if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el))
1620 el.ret = elf_search_and_load_file(pcs, el.name, addr, &el.elf_info);
1622 if (!el.ret) return NULL;
1623 assert(el.elf_info.module);
1624 return el.elf_info.module;
1627 #else /* !__ELF__ */
1629 BOOL elf_synchronize_module_list(struct process* pcs)
1634 BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base,
1635 DWORD* size, DWORD* checksum)
1640 BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
1645 BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user)
1650 struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1655 BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
1660 int elf_is_in_thunk_area(unsigned long addr,
1661 const struct elf_thunk_area* thunks)
1665 #endif /* __ELF__ */