2 * File elf.c - processing of ELF files
4 * Copyright (C) 1996, Eric Youngdale.
5 * 1999-2004 Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
25 #if defined(__svr4__) || defined(__sun)
27 /* large files are not supported by libelf */
28 #undef _FILE_OFFSET_BITS
29 #define _FILE_OFFSET_BITS 32
35 #ifdef HAVE_SYS_STAT_H
36 # include <sys/stat.h>
39 #ifdef HAVE_SYS_MMAN_H
46 #define PATH_MAX MAX_PATH
49 #include "dbghelp_private.h"
54 #ifdef HAVE_SYS_ELF32_H
55 # include <sys/elf32.h>
57 #ifdef HAVE_SYS_EXEC_ELF_H
58 # include <sys/exec_elf.h>
61 # if defined(DT_COUNT)
62 # define DT_NUM DT_COUNT
64 /* this seems to be a satisfactory value on Solaris, which doesn't support this AFAICT */
71 #ifdef HAVE_SYS_LINK_H
72 # include <sys/link.h>
75 #include "wine/library.h"
76 #include "wine/debug.h"
78 struct elf_module_info
80 unsigned long elf_addr
;
81 unsigned short elf_mark
: 1,
87 #define ELF_INFO_DEBUG_HEADER 0x0001
88 #define ELF_INFO_MODULE 0x0002
89 #define ELF_INFO_NAME 0x0004
91 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
95 unsigned flags
; /* IN one (or several) of the ELF_INFO constants */
96 unsigned long dbg_hdr_addr
; /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
97 struct module
* module
; /* OUT loaded module (if ELF_INFO_MODULE is set) */
98 const char* module_name
; /* OUT found module name (if ELF_INFO_NAME is set) */
101 /* structure holding information while handling an ELF image
102 * allows one by one section mapping for memory savings
121 struct hash_table_elt ht_elt
;
122 const Elf32_Sym
* symp
;
123 struct symt_compiland
* compiland
;
127 struct elf_thunk_area
130 THUNK_ORDINAL ordinal
;
131 unsigned long rva_start
;
132 unsigned long rva_end
;
135 /******************************************************************
138 * Maps a single section into memory from an ELF file
140 static const char* elf_map_section(struct elf_file_map
* fmap
, int sidx
)
142 unsigned pgsz
= getpagesize();
145 if (sidx
< 0 || sidx
>= fmap
->elfhdr
.e_shnum
||
146 fmap
->sect
[sidx
].shdr
.sh_type
== SHT_NOBITS
)
148 /* align required information on page size (we assume pagesize is a power of 2) */
149 ofst
= fmap
->sect
[sidx
].shdr
.sh_offset
& ~(pgsz
- 1);
150 size
= ((fmap
->sect
[sidx
].shdr
.sh_offset
+
151 fmap
->sect
[sidx
].shdr
.sh_size
+ pgsz
- 1) & ~(pgsz
- 1)) - ofst
;
152 fmap
->sect
[sidx
].mapped
= mmap(NULL
, size
, PROT_READ
, MAP_PRIVATE
, fmap
->fd
, ofst
);
153 if (fmap
->sect
[sidx
].mapped
== ELF_NO_MAP
) return ELF_NO_MAP
;
154 return fmap
->sect
[sidx
].mapped
+ (fmap
->sect
[sidx
].shdr
.sh_offset
& (pgsz
- 1));
157 /******************************************************************
160 * Unmaps a single section from memory
162 static void elf_unmap_section(struct elf_file_map
* fmap
, int sidx
)
164 if (sidx
>= 0 && sidx
< fmap
->elfhdr
.e_shnum
&& fmap
->sect
[sidx
].mapped
!= ELF_NO_MAP
)
166 unsigned pgsz
= getpagesize();
169 ofst
= fmap
->sect
[sidx
].shdr
.sh_offset
& ~(pgsz
- 1);
170 size
= ((fmap
->sect
[sidx
].shdr
.sh_offset
+
171 fmap
->sect
[sidx
].shdr
.sh_size
+ pgsz
- 1) & ~(pgsz
- 1)) - ofst
;
172 if (munmap((char*)fmap
->sect
[sidx
].mapped
, size
) < 0)
173 WARN("Couldn't unmap the section\n");
174 fmap
->sect
[sidx
].mapped
= ELF_NO_MAP
;
178 /******************************************************************
181 * Get the size of an ELF section
183 static inline unsigned elf_get_map_size(struct elf_file_map
* fmap
, int sidx
)
185 if (sidx
< 0 || sidx
>= fmap
->elfhdr
.e_shnum
)
187 return fmap
->sect
[sidx
].shdr
.sh_size
;
190 /******************************************************************
193 * Maps an ELF file into memory (and checks it's a real ELF file)
195 static BOOL
elf_map_file(const char* filename
, struct elf_file_map
* fmap
)
197 static const BYTE elf_signature
[4] = { ELFMAG0
, ELFMAG1
, ELFMAG2
, ELFMAG3
};
201 unsigned tmp
, page_mask
= getpagesize() - 1;
207 /* check that the file exists, and that the module hasn't been loaded yet */
208 if (stat(filename
, &statbuf
) == -1 || S_ISDIR(statbuf
.st_mode
)) return FALSE
;
210 /* Now open the file, so that we can mmap() it. */
211 if ((fmap
->fd
= open(filename
, O_RDONLY
)) == -1) return FALSE
;
213 if (read(fmap
->fd
, &fmap
->elfhdr
, sizeof(fmap
->elfhdr
)) != sizeof(fmap
->elfhdr
))
215 /* and check for an ELF header */
216 if (memcmp(fmap
->elfhdr
.e_ident
,
217 elf_signature
, sizeof(elf_signature
))) return FALSE
;
219 fmap
->sect
= HeapAlloc(GetProcessHeap(), 0,
220 fmap
->elfhdr
.e_shnum
* sizeof(fmap
->sect
[0]));
221 if (!fmap
->sect
) return FALSE
;
223 lseek(fmap
->fd
, fmap
->elfhdr
.e_shoff
, SEEK_SET
);
224 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
226 read(fmap
->fd
, &fmap
->sect
[i
].shdr
, sizeof(fmap
->sect
[i
].shdr
));
227 fmap
->sect
[i
].mapped
= ELF_NO_MAP
;
230 /* grab size of module once loaded in memory */
231 lseek(fmap
->fd
, fmap
->elfhdr
.e_phoff
, SEEK_SET
);
233 fmap
->elf_start
= ~0L;
234 for (i
= 0; i
< fmap
->elfhdr
.e_phnum
; i
++)
236 if (read(fmap
->fd
, &phdr
, sizeof(phdr
)) == sizeof(phdr
) &&
237 phdr
.p_type
== PT_LOAD
)
239 tmp
= (phdr
.p_vaddr
+ phdr
.p_memsz
+ page_mask
) & ~page_mask
;
240 if (fmap
->elf_size
< tmp
) fmap
->elf_size
= tmp
;
241 if (phdr
.p_vaddr
< fmap
->elf_start
) fmap
->elf_start
= phdr
.p_vaddr
;
244 /* if non relocatable ELF, then remove fixed address from computation
245 * otherwise, all addresses are zero based and start has no effect
247 fmap
->elf_size
-= fmap
->elf_start
;
251 /******************************************************************
254 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
256 static void elf_unmap_file(struct elf_file_map
* fmap
)
261 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
263 elf_unmap_section(fmap
, i
);
265 HeapFree(GetProcessHeap(), 0, fmap
->sect
);
270 /******************************************************************
271 * elf_is_in_thunk_area
273 * Check whether an address lies within one of the thunk area we
276 int elf_is_in_thunk_area(unsigned long addr
,
277 const struct elf_thunk_area
* thunks
)
281 for (i
= 0; thunks
[i
].symname
; i
++)
283 if (addr
>= thunks
[i
].rva_start
&& addr
< thunks
[i
].rva_end
)
289 /******************************************************************
292 * creating an internal hash table to ease use ELF symtab information lookup
294 static void elf_hash_symtab(struct module
* module
, struct pool
* pool
,
295 struct hash_table
* ht_symtab
, struct elf_file_map
* fmap
,
296 int symtab_idx
, struct elf_thunk_area
* thunks
)
301 struct symt_compiland
* compiland
= NULL
;
303 const Elf32_Sym
* symp
;
304 struct symtab_elt
* ste
;
306 symp
= (const Elf32_Sym
*)elf_map_section(fmap
, symtab_idx
);
307 strp
= elf_map_section(fmap
, fmap
->sect
[symtab_idx
].shdr
.sh_link
);
308 if (symp
== ELF_NO_MAP
|| strp
== ELF_NO_MAP
) return;
310 nsym
= elf_get_map_size(fmap
, symtab_idx
) / sizeof(*symp
);
312 for (j
= 0; thunks
[j
].symname
; j
++)
313 thunks
[j
].rva_start
= thunks
[j
].rva_end
= 0;
315 for (i
= 0; i
< nsym
; i
++, symp
++)
317 /* Ignore certain types of entries which really aren't of that much
320 if ((ELF32_ST_TYPE(symp
->st_info
) != STT_NOTYPE
&&
321 ELF32_ST_TYPE(symp
->st_info
) != STT_FILE
&&
322 ELF32_ST_TYPE(symp
->st_info
) != STT_OBJECT
&&
323 ELF32_ST_TYPE(symp
->st_info
) != STT_FUNC
) ||
324 symp
->st_shndx
== SHN_UNDEF
)
329 symname
= strp
+ symp
->st_name
;
331 /* handle some specific symtab (that we'll throw away when done) */
332 switch (ELF32_ST_TYPE(symp
->st_info
))
336 compiland
= symt_new_compiland(module
, symp
->st_value
,
337 source_new(module
, NULL
, symname
));
342 /* we are only interested in wine markers inserted by winebuild */
343 for (j
= 0; thunks
[j
].symname
; j
++)
345 if (!strcmp(symname
, thunks
[j
].symname
))
347 thunks
[j
].rva_start
= symp
->st_value
;
348 thunks
[j
].rva_end
= symp
->st_value
+ symp
->st_size
;
355 /* FIXME: we don't need to handle them (GCC internals)
356 * Moreover, they screw up our symbol lookup :-/
358 if (symname
[0] == '.' && symname
[1] == 'L' && isdigit(symname
[2]))
361 ste
= pool_alloc(pool
, sizeof(*ste
));
362 ste
->ht_elt
.name
= symname
;
363 /* GCC emits, in some cases, a .<digit>+ suffix.
364 * This is used for static variable inside functions, so
365 * that we can have several such variables with same name in
366 * the same compilation unit
367 * We simply ignore that suffix when present (we also get rid
368 * of it in stabs parsing)
370 ptr
= symname
+ strlen(symname
) - 1;
373 while (isdigit(*ptr
) && ptr
>= symname
) ptr
--;
374 if (ptr
> symname
&& *ptr
== '.')
376 char* n
= pool_alloc(pool
, ptr
- symname
+ 1);
377 memcpy(n
, symname
, ptr
- symname
+ 1);
378 n
[ptr
- symname
] = '\0';
379 ste
->ht_elt
.name
= n
;
383 ste
->compiland
= compiland
;
385 hash_table_add(ht_symtab
, &ste
->ht_elt
);
387 /* as we added in the ht_symtab pointers to the symbols themselves,
388 * we cannot unmap yet the sections, it will be done when we're over
393 /******************************************************************
396 * lookup a symbol by name in our internal hash table for the symtab
398 static const Elf32_Sym
* elf_lookup_symtab(const struct module
* module
,
399 const struct hash_table
* ht_symtab
,
400 const char* name
, struct symt
* compiland
)
402 struct symtab_elt
* weak_result
= NULL
; /* without compiland name */
403 struct symtab_elt
* result
= NULL
;
404 struct hash_table_iter hti
;
405 struct symtab_elt
* ste
;
406 const char* compiland_name
;
407 const char* compiland_basename
;
410 /* we need weak match up (at least) when symbols of same name,
411 * defined several times in different compilation units,
412 * are merged in a single one (hence a different filename for c.u.)
416 compiland_name
= source_get(module
,
417 ((struct symt_compiland
*)compiland
)->source
);
418 compiland_basename
= strrchr(compiland_name
, '/');
419 if (!compiland_basename
++) compiland_basename
= compiland_name
;
421 else compiland_name
= compiland_basename
= NULL
;
423 hash_table_iter_init(ht_symtab
, &hti
, name
);
424 while ((ste
= hash_table_iter_up(&hti
)))
426 if (ste
->used
|| strcmp(ste
->ht_elt
.name
, name
)) continue;
429 if ((ste
->compiland
&& !compiland_name
) || (!ste
->compiland
&& compiland_name
))
431 if (ste
->compiland
&& compiland_name
)
433 const char* filename
= source_get(module
, ste
->compiland
->source
);
434 if (strcmp(filename
, compiland_name
))
436 base
= strrchr(filename
, '/');
437 if (!base
++) base
= filename
;
438 if (strcmp(base
, compiland_basename
)) continue;
443 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
444 name
, compiland_name
,
445 source_get(module
, result
->compiland
->source
), result
->symp
->st_value
,
446 source_get(module
, ste
->compiland
->source
), ste
->symp
->st_value
);
454 if (!result
&& !(result
= weak_result
))
456 FIXME("Couldn't find symbol %s!%s in symtab\n",
457 module
->module
.ModuleName
, name
);
463 /******************************************************************
464 * elf_finish_stabs_info
466 * - get any relevant information (address & size) from the bits we got from the
467 * stabs debugging information
469 static void elf_finish_stabs_info(struct module
* module
, struct hash_table
* symtab
)
471 struct hash_table_iter hti
;
474 const Elf32_Sym
* symp
;
476 hash_table_iter_init(&module
->ht_symbols
, &hti
, NULL
);
477 while ((ptr
= hash_table_iter_up(&hti
)))
479 sym
= GET_ENTRY(ptr
, struct symt_ht
, hash_elt
);
480 switch (sym
->symt
.tag
)
483 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
484 ((struct symt_function
*)sym
)->size
)
488 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
489 ((struct symt_function
*)sym
)->container
);
492 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
493 ((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
+ symp
->st_value
)
494 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
495 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
496 ((struct symt_function
*)sym
)->address
, module
->elf_info
->elf_addr
+ symp
->st_value
);
497 if (((struct symt_function
*)sym
)->size
&& ((struct symt_function
*)sym
)->size
!= symp
->st_size
)
498 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
499 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
500 ((struct symt_function
*)sym
)->size
, symp
->st_size
);
502 ((struct symt_function
*)sym
)->address
= module
->elf_info
->elf_addr
+
504 ((struct symt_function
*)sym
)->size
= symp
->st_size
;
505 } else FIXME("Couldn't find %s!%s\n", module
->module
.ModuleName
, sym
->hash_elt
.name
);
508 switch (((struct symt_data
*)sym
)->kind
)
511 case DataIsFileStatic
:
512 if (((struct symt_data
*)sym
)->u
.var
.offset
!= module
->elf_info
->elf_addr
)
514 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
515 ((struct symt_data
*)sym
)->container
);
518 if (((struct symt_data
*)sym
)->u
.var
.offset
!= module
->elf_info
->elf_addr
&&
519 ((struct symt_data
*)sym
)->u
.var
.offset
!= module
->elf_info
->elf_addr
+ symp
->st_value
)
520 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
521 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
522 ((struct symt_function
*)sym
)->address
, module
->elf_info
->elf_addr
+ symp
->st_value
);
523 ((struct symt_data
*)sym
)->u
.var
.offset
= module
->elf_info
->elf_addr
+
525 ((struct symt_data
*)sym
)->kind
= (ELF32_ST_BIND(symp
->st_info
) == STB_LOCAL
) ?
526 DataIsFileStatic
: DataIsGlobal
;
527 } else FIXME("Couldn't find %s!%s\n", module
->module
.ModuleName
, sym
->hash_elt
.name
);
533 FIXME("Unsupported tag %u\n", sym
->symt
.tag
);
537 /* since we may have changed some addresses & sizes, mark the module to be resorted */
538 module
->sortlist_valid
= FALSE
;
541 /******************************************************************
542 * elf_load_wine_thunks
544 * creating the thunk objects for a wine native DLL
546 static int elf_new_wine_thunks(struct module
* module
, struct hash_table
* ht_symtab
,
547 const struct elf_thunk_area
* thunks
)
550 struct hash_table_iter hti
;
551 struct symtab_elt
* ste
;
553 struct symt_ht
* symt
;
555 hash_table_iter_init(ht_symtab
, &hti
, NULL
);
556 while ((ste
= hash_table_iter_up(&hti
)))
558 if (ste
->used
) continue;
560 addr
= module
->elf_info
->elf_addr
+ ste
->symp
->st_value
;
562 j
= elf_is_in_thunk_area(ste
->symp
->st_value
, thunks
);
563 if (j
>= 0) /* thunk found */
565 symt_new_thunk(module
, ste
->compiland
, ste
->ht_elt
.name
, thunks
[j
].ordinal
,
566 addr
, ste
->symp
->st_size
);
572 symt
= symt_find_nearest(module
, addr
);
574 symt_get_info(&symt
->symt
, TI_GET_ADDRESS
, &ref_addr
);
575 if (!symt
|| addr
!= ref_addr
)
577 /* creating public symbols for all the ELF symbols which haven't been
578 * used yet (ie we have no debug information on them)
579 * That's the case, for example, of the .spec.c files
581 switch (ELF32_ST_TYPE(ste
->symp
->st_info
))
584 symt_new_function(module
, ste
->compiland
, ste
->ht_elt
.name
,
585 addr
, ste
->symp
->st_size
, NULL
);
588 symt_new_global_variable(module
, ste
->compiland
, ste
->ht_elt
.name
,
589 ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
,
590 addr
, ste
->symp
->st_size
, NULL
);
593 FIXME("Shouldn't happen\n");
596 /* FIXME: this is a hack !!!
597 * we are adding new symbols, but as we're parsing a symbol table
598 * (hopefully without duplicate symbols) we delay rebuilding the sorted
599 * module table until we're done with the symbol table
600 * Otherwise, as we intertwine symbols's add and lookup, performance
603 module
->sortlist_valid
= TRUE
;
605 else if (strcmp(ste
->ht_elt
.name
, symt
->hash_elt
.name
))
607 ULONG64 xaddr
= 0, xsize
= 0;
610 symt_get_info(&symt
->symt
, TI_GET_ADDRESS
, &xaddr
);
611 symt_get_info(&symt
->symt
, TI_GET_LENGTH
, &xsize
);
612 symt_get_info(&symt
->symt
, TI_GET_DATAKIND
, &kind
);
614 /* If none of symbols has a correct size, we consider they are both markers
615 * Hence, we can silence this warning
616 * Also, we check that we don't have two symbols, one local, the other
617 * global which is legal
619 if ((xsize
|| ste
->symp
->st_size
) &&
620 (kind
== (ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
) ? DataIsFileStatic
: DataIsGlobal
))
621 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
622 module
->module
.ModuleName
,
623 ste
->ht_elt
.name
, addr
, ste
->symp
->st_size
,
625 wine_dbgstr_longlong(xaddr
), wine_dbgstr_longlong(xsize
));
629 /* see comment above */
630 module
->sortlist_valid
= FALSE
;
634 /******************************************************************
635 * elf_new_public_symbols
637 * Creates a set of public symbols from an ELF symtab
639 static int elf_new_public_symbols(struct module
* module
, struct hash_table
* symtab
)
641 struct hash_table_iter hti
;
642 struct symtab_elt
* ste
;
644 if (dbghelp_options
& SYMOPT_NO_PUBLICS
) return TRUE
;
646 /* FIXME: we're missing the ELF entry point here */
648 hash_table_iter_init(symtab
, &hti
, NULL
);
649 while ((ste
= hash_table_iter_up(&hti
)))
651 symt_new_public(module
, ste
->compiland
, ste
->ht_elt
.name
,
652 module
->elf_info
->elf_addr
+ ste
->symp
->st_value
,
653 ste
->symp
->st_size
, TRUE
/* FIXME */,
654 ELF32_ST_TYPE(ste
->symp
->st_info
) == STT_FUNC
);
659 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
660 the following calc_crc32 code or tables extracted from it, as desired without
663 /**********************************************************************\
664 |* Demonstration program to compute the 32-bit CRC used as the frame *|
665 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
666 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
667 |* protocol). The 32-bit FCS was added via the Federal Register, *|
668 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
669 |* this polynomial is or will be included in CCITT V.41, which *|
670 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
671 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
672 |* errors by a factor of 10^-5 over 16-bit FCS. *|
673 \**********************************************************************/
675 /* First, the polynomial itself and its table of feedback terms. The */
677 /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
678 /* Note that we take it "backwards" and put the highest-order term in */
679 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
680 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
681 /* the MSB being 1. */
683 /* Note that the usual hardware shift register implementation, which */
684 /* is what we're using (we're merely optimizing it by doing eight-bit */
685 /* chunks at a time) shifts bits into the lowest-order term. In our */
686 /* implementation, that means shifting towards the right. Why do we */
687 /* do it this way? Because the calculated CRC must be transmitted in */
688 /* order from highest-order term to lowest-order term. UARTs transmit */
689 /* characters in order from LSB to MSB. By storing the CRC this way, */
690 /* we hand it to the UART in the order low-byte to high-byte; the UART */
691 /* sends each low-bit to hight-bit; and the result is transmission bit */
692 /* by bit from highest- to lowest-order term without requiring any bit */
693 /* shuffling on our part. Reception works similarly. */
695 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
697 /* 1. The table can be generated at runtime if desired; code to do so */
698 /* is shown later. It might not be obvious, but the feedback */
699 /* terms simply represent the results of eight shift/xor opera- */
700 /* tions for all combinations of data and CRC register values. */
702 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
703 /* be they sixteen or thirty-two bits wide. You simply choose the */
704 /* appropriate table. Alternatively, because the table can be */
705 /* generated at runtime, you can start by generating the table for */
706 /* the polynomial in question and use exactly the same "updcrc", */
707 /* if your application needn't simultaneously handle two CRC */
708 /* polynomials. (Note, however, that XMODEM is strange.) */
710 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
711 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
713 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
714 /* logic; the shift must be unsigned (bring in zeroes). On some */
715 /* hardware you could probably optimize the shift in assembler by */
716 /* using byte-swap instructions. */
719 static DWORD
calc_crc32(struct elf_file_map
* fmap
)
721 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
722 static const DWORD crc_32_tab
[] =
723 { /* CRC polynomial 0xedb88320 */
724 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
725 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
726 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
727 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
728 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
729 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
730 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
731 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
732 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
733 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
734 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
735 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
736 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
737 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
738 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
739 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
740 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
741 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
742 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
743 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
744 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
745 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
746 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
747 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
748 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
749 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
750 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
751 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
752 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
753 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
754 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
755 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
756 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
757 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
758 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
759 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
760 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
761 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
762 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
763 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
764 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
765 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
766 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
769 unsigned char buffer
[256];
772 lseek(fmap
->fd
, 0, SEEK_SET
);
773 while ((r
= read(fmap
->fd
, buffer
, sizeof(buffer
))) > 0)
775 for (i
= 0; i
< r
; i
++) crc
= UPDC32(buffer
[i
], crc
);
781 /******************************************************************
782 * elf_load_debug_info_from_map
784 * Loads the symbolic information from ELF module which mapping is described
786 * the module has been loaded at 'load_offset' address, so symbols' address
787 * relocation is performed.
788 * CRC is checked if fmap->with_crc is TRUE
790 * 0 if the file doesn't contain symbolic info (or this info cannot be
794 static BOOL
elf_load_debug_info_from_map(struct module
* module
,
795 struct elf_file_map
* fmap
,
797 struct hash_table
* ht_symtab
)
799 BOOL ret
= FALSE
, lret
;
800 const char* shstrtab
;
802 int symtab_sect
, dynsym_sect
, stab_sect
, stabstr_sect
;
803 int debug_sect
, debug_str_sect
, debug_abbrev_sect
;
804 int debug_line_sect
, debug_loclist_sect
;
806 struct elf_thunk_area thunks
[] =
808 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE
, 0, 0}, /* inter DLL calls */
809 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
810 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
811 {"__wine_delay_load", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
812 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
813 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
817 if (fmap
->with_crc
&& (fmap
->crc
!= calc_crc32(fmap
)))
819 ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
820 module
->module
.ImageName
, calc_crc32(fmap
), fmap
->crc
);
821 /* we don't tolerate mis-matched files */
826 * Next, we need to find a few of the internal ELF headers within
827 * this thing. We need the main executable header, and the section
830 shstrtab
= elf_map_section(fmap
, fmap
->elfhdr
.e_shstrndx
);
831 if (shstrtab
== ELF_NO_MAP
) return FALSE
;
833 symtab_sect
= dynsym_sect
= stab_sect
= stabstr_sect
= -1;
834 debug_sect
= debug_str_sect
= debug_abbrev_sect
= -1;
835 debug_line_sect
= debug_loclist_sect
= -1;
838 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
840 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".stab") == 0)
842 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".stabstr") == 0)
844 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_info") == 0)
846 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_str") == 0)
848 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_abbrev") == 0)
849 debug_abbrev_sect
= i
;
850 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_line") == 0)
852 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_loc") == 0)
853 debug_loclist_sect
= i
;
854 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".gnu_debuglink") == 0)
856 if ((strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".symtab") == 0) &&
857 (fmap
->sect
[i
].shdr
.sh_type
== SHT_SYMTAB
))
859 if ((strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".dynsym") == 0) &&
860 (fmap
->sect
[i
].shdr
.sh_type
== SHT_DYNSYM
))
863 elf_unmap_section(fmap
, fmap
->elfhdr
.e_shstrndx
);
866 if (symtab_sect
== -1)
868 /* if we don't have a symtab but a dynsym, process the dynsym
869 * section instead. It'll contain less (relevant) information,
870 * but it'll be better than nothing
872 if (dynsym_sect
== -1) return FALSE
;
873 symtab_sect
= dynsym_sect
;
876 module
->module
.SymType
= SymExport
;
878 /* create a hash table for the symtab */
879 elf_hash_symtab(module
, pool
, ht_symtab
, fmap
, symtab_sect
, thunks
);
881 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
883 if (stab_sect
!= -1 && stabstr_sect
!= -1)
888 stab
= elf_map_section(fmap
, stab_sect
);
889 stabstr
= elf_map_section(fmap
, stabstr_sect
);
890 if (stab
!= ELF_NO_MAP
&& stabstr
!= ELF_NO_MAP
)
892 /* OK, now just parse all of the stabs. */
893 lret
= stabs_parse(module
, module
->elf_info
->elf_addr
,
894 stab
, elf_get_map_size(fmap
, stab_sect
),
895 stabstr
, elf_get_map_size(fmap
, stabstr_sect
));
897 /* and fill in the missing information for stabs */
898 elf_finish_stabs_info(module
, ht_symtab
);
900 WARN("Couldn't correctly read stabs\n");
904 elf_unmap_section(fmap
, stab_sect
);
905 elf_unmap_section(fmap
, stabstr_sect
);
908 if (debug_sect
!= -1)
910 /* Dwarf 2 debug information */
911 const BYTE
* dw2_debug
;
912 const BYTE
* dw2_debug_abbrev
;
913 const BYTE
* dw2_debug_str
;
914 const BYTE
* dw2_debug_line
;
915 const BYTE
* dw2_debug_loclist
;
917 TRACE("Loading Dwarf2 information for %s\n", module
->module
.ModuleName
);
919 dw2_debug
= (const BYTE
*) elf_map_section(fmap
, debug_sect
);
920 dw2_debug_abbrev
= (const BYTE
*) elf_map_section(fmap
, debug_abbrev_sect
);
921 dw2_debug_str
= (const BYTE
*) elf_map_section(fmap
, debug_str_sect
);
922 dw2_debug_line
= (const BYTE
*) elf_map_section(fmap
, debug_line_sect
);
923 dw2_debug_loclist
= (const BYTE
*) elf_map_section(fmap
, debug_loclist_sect
);
924 if (dw2_debug
!= ELF_NO_MAP
&& dw2_debug_abbrev
!= ELF_NO_MAP
&& dw2_debug_str
!= ELF_NO_MAP
)
926 /* OK, now just parse dwarf2 debug infos. */
927 lret
= dwarf2_parse(module
, module
->elf_info
->elf_addr
, thunks
,
928 dw2_debug
, elf_get_map_size(fmap
, debug_sect
),
929 dw2_debug_abbrev
, elf_get_map_size(fmap
, debug_abbrev_sect
),
930 dw2_debug_str
, elf_get_map_size(fmap
, debug_str_sect
),
931 dw2_debug_line
, elf_get_map_size(fmap
, debug_line_sect
),
932 dw2_debug_loclist
, elf_get_map_size(fmap
, debug_loclist_sect
));
935 WARN("Couldn't correctly read stabs\n");
938 elf_unmap_section(fmap
, debug_sect
);
939 elf_unmap_section(fmap
, debug_abbrev_sect
);
940 elf_unmap_section(fmap
, debug_str_sect
);
941 elf_unmap_section(fmap
, debug_line_sect
);
942 elf_unmap_section(fmap
, debug_loclist_sect
);
944 if (debuglink_sect
!= -1)
946 const char* dbg_link
;
947 struct elf_file_map fmap_link
;
949 dbg_link
= elf_map_section(fmap
, debuglink_sect
);
950 /* The content of a debug link section is:
951 * 1/ a NULL terminated string, containing the file name for the
953 * 2/ padding on 4 byte boundary
954 * 3/ CRC of the linked ELF file
956 if (dbg_link
!= ELF_NO_MAP
&& elf_map_file(dbg_link
, &fmap_link
))
958 fmap_link
.crc
= *(const DWORD
*)(dbg_link
+ ((DWORD_PTR
)(strlen(dbg_link
) + 4) & ~3));
959 fmap_link
.with_crc
= 1;
960 lret
= elf_load_debug_info_from_map(module
, &fmap_link
, pool
,
963 strcpy(module
->module
.LoadedPdbName
, dbg_link
);
965 WARN("Couldn't load debug information from %s\n", dbg_link
);
967 elf_unmap_file(&fmap_link
);
970 WARN("Couldn't load linked debug file for %s\n",
971 module
->module
.ModuleName
);
974 if (strstr(module
->module
.ModuleName
, "<elf>") ||
975 !strcmp(module
->module
.ModuleName
, "<wine-loader>"))
977 /* add the thunks for native libraries */
978 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
979 elf_new_wine_thunks(module
, ht_symtab
, thunks
);
981 /* add all the public symbols from symtab */
982 if (elf_new_public_symbols(module
, ht_symtab
) && !ret
) ret
= TRUE
;
987 /******************************************************************
988 * elf_load_debug_info
990 * Loads ELF debugging information from the module image file.
992 BOOL
elf_load_debug_info(struct module
* module
, struct elf_file_map
* fmap
)
996 struct hash_table ht_symtab
;
997 struct elf_file_map my_fmap
;
999 if (module
->type
!= DMT_ELF
|| !module
->elf_info
)
1001 ERR("Bad elf module '%s'\n", module
->module
.LoadedImageName
);
1005 pool_init(&pool
, 65536);
1006 hash_table_init(&pool
, &ht_symtab
, 256);
1011 ret
= elf_map_file(module
->module
.LoadedImageName
, fmap
);
1014 ret
= elf_load_debug_info_from_map(module
, fmap
, &pool
, &ht_symtab
);
1016 pool_destroy(&pool
);
1017 if (fmap
== &my_fmap
) elf_unmap_file(fmap
);
1021 /******************************************************************
1022 * elf_fetch_file_info
1024 * Gathers some more information for an ELF module from a given file
1026 BOOL
elf_fetch_file_info(const char* name
, DWORD
* base
,
1027 DWORD
* size
, DWORD
* checksum
)
1029 struct elf_file_map fmap
;
1030 if (!elf_map_file(name
, &fmap
)) return FALSE
;
1031 if (base
) *base
= fmap
.elf_start
;
1032 *size
= fmap
.elf_size
;
1033 *checksum
= calc_crc32(&fmap
);
1034 elf_unmap_file(&fmap
);
1038 /******************************************************************
1041 * Loads the information for ELF module stored in 'filename'
1042 * the module has been loaded at 'load_offset' address
1044 * -1 if the file cannot be found/opened
1045 * 0 if the file doesn't contain symbolic info (or this info cannot be
1049 static BOOL
elf_load_file(struct process
* pcs
, const char* filename
,
1050 unsigned long load_offset
, struct elf_info
* elf_info
)
1053 struct elf_file_map fmap
;
1056 TRACE("Processing elf file '%s' at %08lx\n", filename
, load_offset
);
1058 if (!elf_map_file(filename
, &fmap
)) goto leave
;
1060 /* Next, we need to find a few of the internal ELF headers within
1061 * this thing. We need the main executable header, and the section
1064 if (!fmap
.elf_start
&& !load_offset
)
1065 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1067 if (fmap
.elf_start
&& load_offset
)
1069 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1070 "Assuming load address is corrupt\n", filename
, load_offset
);
1074 if (elf_info
->flags
& ELF_INFO_DEBUG_HEADER
)
1076 const char* shstrtab
= elf_map_section(&fmap
, fmap
.elfhdr
.e_shstrndx
);
1077 if (shstrtab
== ELF_NO_MAP
) goto leave
;
1078 for (i
= 0; i
< fmap
.elfhdr
.e_shnum
; i
++)
1080 if (strcmp(shstrtab
+ fmap
.sect
[i
].shdr
.sh_name
, ".dynamic") == 0 &&
1081 fmap
.sect
[i
].shdr
.sh_type
== SHT_DYNAMIC
)
1084 char* ptr
= (char*)fmap
.sect
[i
].shdr
.sh_addr
;
1089 if (!ReadProcessMemory(pcs
->handle
, ptr
, &dyn
, sizeof(dyn
), &len
) ||
1092 if (dyn
.d_tag
== DT_DEBUG
)
1094 elf_info
->dbg_hdr_addr
= dyn
.d_un
.d_ptr
;
1098 } while (dyn
.d_tag
!= DT_NULL
);
1099 if (dyn
.d_tag
== DT_NULL
) goto leave
;
1102 elf_unmap_section(&fmap
, fmap
.elfhdr
.e_shstrndx
);
1105 if (elf_info
->flags
& ELF_INFO_MODULE
)
1107 struct elf_module_info
*elf_module_info
=
1108 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info
));
1109 if (!elf_module_info
) goto leave
;
1110 elf_info
->module
= module_new(pcs
, filename
, DMT_ELF
, FALSE
,
1111 (load_offset
) ? load_offset
: fmap
.elf_start
,
1112 fmap
.elf_size
, 0, calc_crc32(&fmap
));
1113 if (!elf_info
->module
)
1115 HeapFree(GetProcessHeap(), 0, elf_module_info
);
1118 elf_info
->module
->elf_info
= elf_module_info
;
1119 elf_info
->module
->elf_info
->elf_addr
= load_offset
;
1121 if (dbghelp_options
& SYMOPT_DEFERRED_LOADS
)
1123 elf_info
->module
->module
.SymType
= SymDeferred
;
1126 else ret
= elf_load_debug_info(elf_info
->module
, &fmap
);
1128 elf_info
->module
->elf_info
->elf_mark
= 1;
1129 elf_info
->module
->elf_info
->elf_loader
= 0;
1132 if (elf_info
->flags
& ELF_INFO_NAME
)
1134 elf_info
->module_name
= strcpy(HeapAlloc(GetProcessHeap(), 0,
1135 strlen(filename
) + 1), filename
);
1138 elf_unmap_file(&fmap
);
1143 /******************************************************************
1144 * elf_load_file_from_path
1145 * tries to load an ELF file from a set of paths (separated by ':')
1147 static BOOL
elf_load_file_from_path(HANDLE hProcess
,
1148 const char* filename
,
1149 unsigned long load_offset
,
1151 struct elf_info
* elf_info
)
1157 if (!path
) return FALSE
;
1159 paths
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path
) + 1), path
);
1160 for (s
= paths
; s
&& *s
; s
= (t
) ? (t
+1) : NULL
)
1164 fn
= HeapAlloc(GetProcessHeap(), 0, strlen(filename
) + 1 + strlen(s
) + 1);
1168 strcat(fn
, filename
);
1169 ret
= elf_load_file(hProcess
, fn
, load_offset
, elf_info
);
1170 HeapFree(GetProcessHeap(), 0, fn
);
1172 s
= (t
) ? (t
+1) : NULL
;
1175 HeapFree(GetProcessHeap(), 0, paths
);
1179 /******************************************************************
1180 * elf_load_file_from_dll_path
1182 * Tries to load an ELF file from the dll path
1184 static BOOL
elf_load_file_from_dll_path(HANDLE hProcess
,
1185 const char* filename
,
1186 unsigned long load_offset
,
1187 struct elf_info
* elf_info
)
1190 unsigned int index
= 0;
1193 while (!ret
&& (path
= wine_dll_enum_load_path( index
++ )))
1195 char *name
= HeapAlloc( GetProcessHeap(), 0, strlen(path
) + strlen(filename
) + 2 );
1197 strcpy( name
, path
);
1198 strcat( name
, "/" );
1199 strcat( name
, filename
);
1200 ret
= elf_load_file(hProcess
, name
, load_offset
, elf_info
);
1201 HeapFree( GetProcessHeap(), 0, name
);
1206 /******************************************************************
1207 * elf_search_and_load_file
1209 * lookup a file in standard ELF locations, and if found, load it
1211 static BOOL
elf_search_and_load_file(struct process
* pcs
, const char* filename
,
1212 unsigned long load_offset
,
1213 struct elf_info
* elf_info
)
1216 struct module
* module
;
1218 if (filename
== NULL
|| *filename
== '\0') return FALSE
;
1219 if ((module
= module_find_by_name(pcs
, filename
, DMT_ELF
)))
1221 elf_info
->module
= module
;
1222 module
->elf_info
->elf_mark
= 1;
1223 return module
->module
.SymType
;
1226 if (strstr(filename
, "libstdc++")) return FALSE
; /* We know we can't do it */
1227 ret
= elf_load_file(pcs
, filename
, load_offset
, elf_info
);
1228 /* if relative pathname, try some absolute base dirs */
1229 if (!ret
&& !strchr(filename
, '/'))
1231 ret
= elf_load_file_from_path(pcs
, filename
, load_offset
,
1232 getenv("PATH"), elf_info
) ||
1233 elf_load_file_from_path(pcs
, filename
, load_offset
,
1234 getenv("LD_LIBRARY_PATH"), elf_info
);
1235 if (!ret
) ret
= elf_load_file_from_dll_path(pcs
, filename
, load_offset
, elf_info
);
1241 /******************************************************************
1242 * elf_enum_modules_internal
1244 * Enumerate ELF modules from a running process
1246 static BOOL
elf_enum_modules_internal(const struct process
* pcs
,
1247 const char* main_name
,
1248 elf_enum_modules_cb cb
, void* user
)
1250 struct r_debug dbg_hdr
;
1255 if (!pcs
->dbg_hdr_addr
||
1256 !ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
,
1257 &dbg_hdr
, sizeof(dbg_hdr
), NULL
))
1260 /* Now walk the linked list. In all known ELF implementations,
1261 * the dynamic loader maintains this linked list for us. In some
1262 * cases the first entry doesn't appear with a name, in other cases it
1265 for (lm_addr
= (void*)dbg_hdr
.r_map
; lm_addr
; lm_addr
= (void*)lm
.l_next
)
1267 if (!ReadProcessMemory(pcs
->handle
, lm_addr
, &lm
, sizeof(lm
), NULL
))
1270 if (lm
.l_prev
!= NULL
&& /* skip first entry, normally debuggee itself */
1271 lm
.l_name
!= NULL
&&
1272 ReadProcessMemory(pcs
->handle
, lm
.l_name
, bufstr
, sizeof(bufstr
), NULL
))
1274 bufstr
[sizeof(bufstr
) - 1] = '\0';
1275 if (main_name
&& !bufstr
[0]) strcpy(bufstr
, main_name
);
1276 if (!cb(bufstr
, (unsigned long)lm
.l_addr
, user
)) break;
1284 struct process
* pcs
;
1285 struct elf_info elf_info
;
1288 static BOOL
elf_enum_sync_cb(const char* name
, unsigned long addr
, void* user
)
1290 struct elf_sync
* es
= user
;
1292 elf_search_and_load_file(es
->pcs
, name
, addr
, &es
->elf_info
);
1296 /******************************************************************
1297 * elf_synchronize_module_list
1299 * this functions rescans the debuggee module's list and synchronizes it with
1300 * the one from 'pcs', ie:
1301 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1302 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1304 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1306 struct module
* module
;
1309 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1311 if (module
->type
== DMT_ELF
&& !module
->is_virtual
)
1312 module
->elf_info
->elf_mark
= 0;
1316 es
.elf_info
.flags
= ELF_INFO_MODULE
;
1317 if (!elf_enum_modules_internal(pcs
, NULL
, elf_enum_sync_cb
, &es
))
1320 module
= pcs
->lmodules
;
1323 if (module
->type
== DMT_ELF
&& !module
->is_virtual
&&
1324 !module
->elf_info
->elf_mark
&& !module
->elf_info
->elf_loader
)
1326 module_remove(pcs
, module
);
1327 /* restart all over */
1328 module
= pcs
->lmodules
;
1330 else module
= module
->next
;
1335 /******************************************************************
1338 * Lookup in a running ELF process the loader, and sets its ELF link
1339 * address (for accessing the list of loaded .so libs) in pcs.
1340 * If flags is ELF_INFO_MODULE, the module for the loader is also
1341 * added as a module into pcs.
1343 static BOOL
elf_search_loader(struct process
* pcs
, struct elf_info
* elf_info
)
1348 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1349 * main executable (either wine-kthread or wine-pthread)
1350 * FIXME: the heuristic used to know whether we need to load wine-pthread
1351 * or wine-kthread is not 100% safe
1353 if ((ptr
= getenv("WINELOADER")))
1354 ret
= elf_search_and_load_file(pcs
, ptr
, 0, elf_info
);
1357 ret
= elf_search_and_load_file(pcs
, "wine-kthread", 0, elf_info
) ||
1358 elf_search_and_load_file(pcs
, "wine-pthread", 0, elf_info
);
1363 /******************************************************************
1364 * elf_read_wine_loader_dbg_info
1366 * Try to find a decent wine executable which could have loaded the debuggee
1368 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1370 struct elf_info elf_info
;
1372 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_MODULE
;
1373 if (!elf_search_loader(pcs
, &elf_info
)) return FALSE
;
1374 elf_info
.module
->elf_info
->elf_loader
= 1;
1375 strcpy(elf_info
.module
->module
.ModuleName
, "<wine-loader>");
1376 return (pcs
->dbg_hdr_addr
= elf_info
.dbg_hdr_addr
) != 0;
1379 /******************************************************************
1382 * Enumerates the ELF loaded modules from a running target (hProc)
1383 * This function doesn't require that someone has called SymInitialize
1384 * on this very process.
1386 BOOL
elf_enum_modules(HANDLE hProc
, elf_enum_modules_cb cb
, void* user
)
1389 struct elf_info elf_info
;
1392 memset(&pcs
, 0, sizeof(pcs
));
1394 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_NAME
;
1395 if (!elf_search_loader(&pcs
, &elf_info
)) return FALSE
;
1396 pcs
.dbg_hdr_addr
= elf_info
.dbg_hdr_addr
;
1397 ret
= elf_enum_modules_internal(&pcs
, elf_info
.module_name
, cb
, user
);
1398 HeapFree(GetProcessHeap(), 0, (char*)elf_info
.module_name
);
1404 struct process
* pcs
;
1405 struct elf_info elf_info
;
1410 /******************************************************************
1413 * Callback for elf_load_module, used to walk the list of loaded
1416 static BOOL
elf_load_cb(const char* name
, unsigned long addr
, void* user
)
1418 struct elf_load
* el
= user
;
1421 /* memcmp is needed for matches when bufstr contains also version information
1422 * el->name: libc.so, name: libc.so.6.0
1424 p
= strrchr(name
, '/');
1426 if (!memcmp(p
, el
->name
, strlen(el
->name
)))
1428 el
->ret
= elf_search_and_load_file(el
->pcs
, name
, addr
, &el
->elf_info
);
1434 /******************************************************************
1437 * loads an ELF module and stores it in process' module list
1438 * Also, find module real name and load address from
1439 * the real loaded modules list in pcs address space
1441 struct module
* elf_load_module(struct process
* pcs
, const char* name
, unsigned long addr
)
1445 TRACE("(%p %s %08lx)\n", pcs
, name
, addr
);
1447 el
.elf_info
.flags
= ELF_INFO_MODULE
;
1450 if (pcs
->dbg_hdr_addr
) /* we're debugging a life target */
1453 /* do only the lookup from the filename, not the path (as we lookup module
1454 * name in the process' loaded module list)
1456 el
.name
= strrchr(name
, '/');
1457 if (!el
.name
++) el
.name
= name
;
1460 if (!elf_enum_modules_internal(pcs
, NULL
, elf_load_cb
, &el
))
1465 el
.ret
= elf_search_and_load_file(pcs
, name
, addr
, &el
.elf_info
);
1467 if (!el
.ret
) return NULL
;
1468 assert(el
.elf_info
.module
);
1469 return el
.elf_info
.module
;
1472 #else /* !__ELF__ */
1474 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1479 BOOL
elf_fetch_file_info(const char* name
, DWORD
* base
,
1480 DWORD
* size
, DWORD
* checksum
)
1485 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1490 BOOL
elf_enum_modules(HANDLE hProc
, elf_enum_modules_cb cb
, void* user
)
1495 struct module
* elf_load_module(struct process
* pcs
, const char* name
, unsigned long addr
)
1500 BOOL
elf_load_debug_info(struct module
* module
, struct elf_file_map
* fmap
)
1505 int elf_is_in_thunk_area(unsigned long addr
,
1506 const struct elf_thunk_area
* thunks
)
1510 #endif /* __ELF__ */