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
115 const char* shstrtab
;
116 struct elf_file_map
* alternate
; /* another ELF file (linked to this one) */
119 struct elf_section_map
121 struct elf_file_map
* fmap
;
127 struct hash_table_elt ht_elt
;
128 const Elf32_Sym
* symp
;
129 struct symt_compiland
* compiland
;
133 struct elf_thunk_area
136 THUNK_ORDINAL ordinal
;
137 unsigned long rva_start
;
138 unsigned long rva_end
;
141 /******************************************************************
144 * Maps a single section into memory from an ELF file
146 static const char* elf_map_section(struct elf_section_map
* esm
)
148 unsigned pgsz
= getpagesize();
151 if (esm
->sidx
< 0 || esm
->sidx
>= esm
->fmap
->elfhdr
.e_shnum
||
152 esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_type
== SHT_NOBITS
)
155 /* align required information on page size (we assume pagesize is a power of 2) */
156 ofst
= esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_offset
& ~(pgsz
- 1);
157 size
= ((esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_offset
+
158 esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_size
+ pgsz
- 1) & ~(pgsz
- 1)) - ofst
;
159 esm
->fmap
->sect
[esm
->sidx
].mapped
= mmap(NULL
, size
, PROT_READ
, MAP_PRIVATE
,
160 esm
->fmap
->fd
, ofst
);
161 if (esm
->fmap
->sect
[esm
->sidx
].mapped
== ELF_NO_MAP
) return ELF_NO_MAP
;
162 return esm
->fmap
->sect
[esm
->sidx
].mapped
+ (esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_offset
& (pgsz
- 1));
165 /******************************************************************
168 * Finds a section by name (and type) into memory from an ELF file
169 * or its alternate if any
171 static BOOL
elf_find_section(struct elf_file_map
* fmap
, const char* name
,
172 unsigned sht
, struct elf_section_map
* esm
)
178 if (fmap
->shstrtab
== ELF_NO_MAP
)
180 struct elf_section_map hdr_esm
= {fmap
, fmap
->elfhdr
.e_shstrndx
};
181 if ((fmap
->shstrtab
= elf_map_section(&hdr_esm
)) == ELF_NO_MAP
) break;
183 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
185 if (strcmp(fmap
->shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, name
) == 0 &&
186 (sht
== SHT_NULL
|| sht
== fmap
->sect
[i
].shdr
.sh_type
))
193 fmap
= fmap
->alternate
;
200 /******************************************************************
203 * Unmaps a single section from memory
205 static void elf_unmap_section(struct elf_section_map
* esm
)
207 if (esm
->sidx
>= 0 && esm
->sidx
< esm
->fmap
->elfhdr
.e_shnum
&& esm
->fmap
->sect
[esm
->sidx
].mapped
!= ELF_NO_MAP
)
209 unsigned pgsz
= getpagesize();
212 ofst
= esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_offset
& ~(pgsz
- 1);
213 size
= ((esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_offset
+
214 esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_size
+ pgsz
- 1) & ~(pgsz
- 1)) - ofst
;
215 if (munmap((char*)esm
->fmap
->sect
[esm
->sidx
].mapped
, size
) < 0)
216 WARN("Couldn't unmap the section\n");
217 esm
->fmap
->sect
[esm
->sidx
].mapped
= ELF_NO_MAP
;
221 static void elf_end_find(struct elf_file_map
* fmap
)
223 struct elf_section_map esm
;
228 esm
.sidx
= fmap
->elfhdr
.e_shstrndx
;
229 elf_unmap_section(&esm
);
230 fmap
->shstrtab
= ELF_NO_MAP
;
231 fmap
= fmap
->alternate
;
235 /******************************************************************
238 * Get the size of an ELF section
240 static inline unsigned elf_get_map_size(const struct elf_section_map
* esm
)
242 if (esm
->sidx
< 0 || esm
->sidx
>= esm
->fmap
->elfhdr
.e_shnum
)
244 return esm
->fmap
->sect
[esm
->sidx
].shdr
.sh_size
;
247 /******************************************************************
250 * Maps an ELF file into memory (and checks it's a real ELF file)
252 static BOOL
elf_map_file(const WCHAR
* filenameW
, struct elf_file_map
* fmap
)
254 static const BYTE elf_signature
[4] = { ELFMAG0
, ELFMAG1
, ELFMAG2
, ELFMAG3
};
258 unsigned tmp
, page_mask
= getpagesize() - 1;
263 len
= WideCharToMultiByte(CP_UNIXCP
, 0, filenameW
, -1, NULL
, 0, NULL
, NULL
);
264 if (!(filename
= HeapAlloc(GetProcessHeap(), 0, len
))) return FALSE
;
265 WideCharToMultiByte(CP_UNIXCP
, 0, filenameW
, -1, filename
, len
, NULL
, NULL
);
268 fmap
->shstrtab
= ELF_NO_MAP
;
269 fmap
->alternate
= NULL
;
271 /* check that the file exists, and that the module hasn't been loaded yet */
272 if (stat(filename
, &statbuf
) == -1 || S_ISDIR(statbuf
.st_mode
)) goto done
;
274 /* Now open the file, so that we can mmap() it. */
275 if ((fmap
->fd
= open(filename
, O_RDONLY
)) == -1) goto done
;
277 if (read(fmap
->fd
, &fmap
->elfhdr
, sizeof(fmap
->elfhdr
)) != sizeof(fmap
->elfhdr
))
279 /* and check for an ELF header */
280 if (memcmp(fmap
->elfhdr
.e_ident
,
281 elf_signature
, sizeof(elf_signature
))) goto done
;
283 fmap
->sect
= HeapAlloc(GetProcessHeap(), 0,
284 fmap
->elfhdr
.e_shnum
* sizeof(fmap
->sect
[0]));
285 if (!fmap
->sect
) goto done
;
287 lseek(fmap
->fd
, fmap
->elfhdr
.e_shoff
, SEEK_SET
);
288 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
290 read(fmap
->fd
, &fmap
->sect
[i
].shdr
, sizeof(fmap
->sect
[i
].shdr
));
291 fmap
->sect
[i
].mapped
= ELF_NO_MAP
;
294 /* grab size of module once loaded in memory */
295 lseek(fmap
->fd
, fmap
->elfhdr
.e_phoff
, SEEK_SET
);
297 fmap
->elf_start
= ~0L;
298 for (i
= 0; i
< fmap
->elfhdr
.e_phnum
; i
++)
300 if (read(fmap
->fd
, &phdr
, sizeof(phdr
)) == sizeof(phdr
) &&
301 phdr
.p_type
== PT_LOAD
)
303 tmp
= (phdr
.p_vaddr
+ phdr
.p_memsz
+ page_mask
) & ~page_mask
;
304 if (fmap
->elf_size
< tmp
) fmap
->elf_size
= tmp
;
305 if (phdr
.p_vaddr
< fmap
->elf_start
) fmap
->elf_start
= phdr
.p_vaddr
;
308 /* if non relocatable ELF, then remove fixed address from computation
309 * otherwise, all addresses are zero based and start has no effect
311 fmap
->elf_size
-= fmap
->elf_start
;
314 HeapFree(GetProcessHeap(), 0, filename
);
318 /******************************************************************
321 * Unmaps an ELF file from memory (previously mapped with elf_map_file)
323 static void elf_unmap_file(struct elf_file_map
* fmap
)
329 struct elf_section_map esm
;
331 for (esm
.sidx
= 0; esm
.sidx
< fmap
->elfhdr
.e_shnum
; esm
.sidx
++)
333 elf_unmap_section(&esm
);
335 HeapFree(GetProcessHeap(), 0, fmap
->sect
);
338 fmap
= fmap
->alternate
;
342 /******************************************************************
343 * elf_is_in_thunk_area
345 * Check whether an address lies within one of the thunk area we
348 int elf_is_in_thunk_area(unsigned long addr
,
349 const struct elf_thunk_area
* thunks
)
353 for (i
= 0; thunks
[i
].symname
; i
++)
355 if (addr
>= thunks
[i
].rva_start
&& addr
< thunks
[i
].rva_end
)
361 /******************************************************************
364 * creating an internal hash table to ease use ELF symtab information lookup
366 static void elf_hash_symtab(struct module
* module
, struct pool
* pool
,
367 struct hash_table
* ht_symtab
, struct elf_file_map
* fmap
,
368 struct elf_thunk_area
* thunks
)
373 struct symt_compiland
* compiland
= NULL
;
375 const Elf32_Sym
* symp
;
376 struct symtab_elt
* ste
;
377 struct elf_section_map esm
, esm_str
;
379 if (!elf_find_section(fmap
, ".symtab", SHT_SYMTAB
, &esm
) &&
380 !elf_find_section(fmap
, ".dynsym", SHT_DYNSYM
, &esm
)) return;
381 if ((symp
= (const Elf32_Sym
*)elf_map_section(&esm
)) == ELF_NO_MAP
) return;
383 esm_str
.sidx
= fmap
->sect
[esm
.sidx
].shdr
.sh_link
;
384 if ((strp
= elf_map_section(&esm_str
)) == ELF_NO_MAP
) return;
386 nsym
= elf_get_map_size(&esm
) / sizeof(*symp
);
388 for (j
= 0; thunks
[j
].symname
; j
++)
389 thunks
[j
].rva_start
= thunks
[j
].rva_end
= 0;
391 for (i
= 0; i
< nsym
; i
++, symp
++)
393 /* Ignore certain types of entries which really aren't of that much
396 if ((ELF32_ST_TYPE(symp
->st_info
) != STT_NOTYPE
&&
397 ELF32_ST_TYPE(symp
->st_info
) != STT_FILE
&&
398 ELF32_ST_TYPE(symp
->st_info
) != STT_OBJECT
&&
399 ELF32_ST_TYPE(symp
->st_info
) != STT_FUNC
) ||
400 symp
->st_shndx
== SHN_UNDEF
)
405 symname
= strp
+ symp
->st_name
;
407 /* handle some specific symtab (that we'll throw away when done) */
408 switch (ELF32_ST_TYPE(symp
->st_info
))
412 compiland
= symt_new_compiland(module
, symp
->st_value
,
413 source_new(module
, NULL
, symname
));
418 /* we are only interested in wine markers inserted by winebuild */
419 for (j
= 0; thunks
[j
].symname
; j
++)
421 if (!strcmp(symname
, thunks
[j
].symname
))
423 thunks
[j
].rva_start
= symp
->st_value
;
424 thunks
[j
].rva_end
= symp
->st_value
+ symp
->st_size
;
431 /* FIXME: we don't need to handle them (GCC internals)
432 * Moreover, they screw up our symbol lookup :-/
434 if (symname
[0] == '.' && symname
[1] == 'L' && isdigit(symname
[2]))
437 ste
= pool_alloc(pool
, sizeof(*ste
));
438 ste
->ht_elt
.name
= symname
;
439 /* GCC emits, in some cases, a .<digit>+ suffix.
440 * This is used for static variable inside functions, so
441 * that we can have several such variables with same name in
442 * the same compilation unit
443 * We simply ignore that suffix when present (we also get rid
444 * of it in stabs parsing)
446 ptr
= symname
+ strlen(symname
) - 1;
449 while (isdigit(*ptr
) && ptr
>= symname
) ptr
--;
450 if (ptr
> symname
&& *ptr
== '.')
452 char* n
= pool_alloc(pool
, ptr
- symname
+ 1);
453 memcpy(n
, symname
, ptr
- symname
+ 1);
454 n
[ptr
- symname
] = '\0';
455 ste
->ht_elt
.name
= n
;
459 ste
->compiland
= compiland
;
461 hash_table_add(ht_symtab
, &ste
->ht_elt
);
463 /* as we added in the ht_symtab pointers to the symbols themselves,
464 * we cannot unmap yet the sections, it will be done when we're over
469 /******************************************************************
472 * lookup a symbol by name in our internal hash table for the symtab
474 static const Elf32_Sym
* elf_lookup_symtab(const struct module
* module
,
475 const struct hash_table
* ht_symtab
,
476 const char* name
, const struct symt
* compiland
)
478 struct symtab_elt
* weak_result
= NULL
; /* without compiland name */
479 struct symtab_elt
* result
= NULL
;
480 struct hash_table_iter hti
;
481 struct symtab_elt
* ste
;
482 const char* compiland_name
;
483 const char* compiland_basename
;
486 /* we need weak match up (at least) when symbols of same name,
487 * defined several times in different compilation units,
488 * are merged in a single one (hence a different filename for c.u.)
492 compiland_name
= source_get(module
,
493 ((const struct symt_compiland
*)compiland
)->source
);
494 compiland_basename
= strrchr(compiland_name
, '/');
495 if (!compiland_basename
++) compiland_basename
= compiland_name
;
497 else compiland_name
= compiland_basename
= NULL
;
499 hash_table_iter_init(ht_symtab
, &hti
, name
);
500 while ((ste
= hash_table_iter_up(&hti
)))
502 if (ste
->used
|| strcmp(ste
->ht_elt
.name
, name
)) continue;
505 if ((ste
->compiland
&& !compiland_name
) || (!ste
->compiland
&& compiland_name
))
507 if (ste
->compiland
&& compiland_name
)
509 const char* filename
= source_get(module
, ste
->compiland
->source
);
510 if (strcmp(filename
, compiland_name
))
512 base
= strrchr(filename
, '/');
513 if (!base
++) base
= filename
;
514 if (strcmp(base
, compiland_basename
)) continue;
519 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
520 name
, compiland_name
,
521 source_get(module
, result
->compiland
->source
), (unsigned int)result
->symp
->st_value
,
522 source_get(module
, ste
->compiland
->source
), (unsigned int)ste
->symp
->st_value
);
530 if (!result
&& !(result
= weak_result
))
532 FIXME("Couldn't find symbol %s!%s in symtab\n",
533 debugstr_w(module
->module
.ModuleName
), name
);
539 /******************************************************************
540 * elf_finish_stabs_info
542 * - get any relevant information (address & size) from the bits we got from the
543 * stabs debugging information
545 static void elf_finish_stabs_info(struct module
* module
, const struct hash_table
* symtab
)
547 struct hash_table_iter hti
;
550 const Elf32_Sym
* symp
;
552 hash_table_iter_init(&module
->ht_symbols
, &hti
, NULL
);
553 while ((ptr
= hash_table_iter_up(&hti
)))
555 sym
= GET_ENTRY(ptr
, struct symt_ht
, hash_elt
);
556 switch (sym
->symt
.tag
)
559 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
560 ((struct symt_function
*)sym
)->size
)
564 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
565 ((struct symt_function
*)sym
)->container
);
568 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
569 ((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
+ symp
->st_value
)
570 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
571 sym
, debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
,
572 ((struct symt_function
*)sym
)->address
, module
->elf_info
->elf_addr
+ symp
->st_value
);
573 if (((struct symt_function
*)sym
)->size
&& ((struct symt_function
*)sym
)->size
!= symp
->st_size
)
574 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
575 sym
, debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
,
576 ((struct symt_function
*)sym
)->size
, (unsigned int)symp
->st_size
);
578 ((struct symt_function
*)sym
)->address
= module
->elf_info
->elf_addr
+
580 ((struct symt_function
*)sym
)->size
= symp
->st_size
;
582 FIXME("Couldn't find %s!%s\n",
583 debugstr_w(module
->module
.ModuleName
), 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
, debugstr_w(module
->module
.ModuleName
), 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
;
606 FIXME("Couldn't find %s!%s\n",
607 debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
);
613 FIXME("Unsupported tag %u\n", sym
->symt
.tag
);
617 /* since we may have changed some addresses & sizes, mark the module to be resorted */
618 module
->sortlist_valid
= FALSE
;
621 /******************************************************************
622 * elf_load_wine_thunks
624 * creating the thunk objects for a wine native DLL
626 static int elf_new_wine_thunks(struct module
* module
, const struct hash_table
* ht_symtab
,
627 const struct elf_thunk_area
* thunks
)
630 struct hash_table_iter hti
;
631 struct symtab_elt
* ste
;
633 struct symt_ht
* symt
;
635 hash_table_iter_init(ht_symtab
, &hti
, NULL
);
636 while ((ste
= hash_table_iter_up(&hti
)))
638 if (ste
->used
) continue;
640 addr
= module
->elf_info
->elf_addr
+ ste
->symp
->st_value
;
642 j
= elf_is_in_thunk_area(ste
->symp
->st_value
, thunks
);
643 if (j
>= 0) /* thunk found */
645 symt_new_thunk(module
, ste
->compiland
, ste
->ht_elt
.name
, thunks
[j
].ordinal
,
646 addr
, ste
->symp
->st_size
);
652 symt
= symt_find_nearest(module
, addr
);
653 if (symt
&& !symt_get_info(&symt
->symt
, TI_GET_ADDRESS
, &ref_addr
))
655 if (!symt
|| addr
!= ref_addr
)
657 /* creating public symbols for all the ELF symbols which haven't been
658 * used yet (ie we have no debug information on them)
659 * That's the case, for example, of the .spec.c files
661 switch (ELF32_ST_TYPE(ste
->symp
->st_info
))
664 symt_new_function(module
, ste
->compiland
, ste
->ht_elt
.name
,
665 addr
, ste
->symp
->st_size
, NULL
);
668 symt_new_global_variable(module
, ste
->compiland
, ste
->ht_elt
.name
,
669 ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
,
670 addr
, ste
->symp
->st_size
, NULL
);
673 FIXME("Shouldn't happen\n");
676 /* FIXME: this is a hack !!!
677 * we are adding new symbols, but as we're parsing a symbol table
678 * (hopefully without duplicate symbols) we delay rebuilding the sorted
679 * module table until we're done with the symbol table
680 * Otherwise, as we intertwine symbols's add and lookup, performance
683 module
->sortlist_valid
= TRUE
;
685 else if (strcmp(ste
->ht_elt
.name
, symt
->hash_elt
.name
))
687 ULONG64 xaddr
= 0, xsize
= 0;
690 symt_get_info(&symt
->symt
, TI_GET_ADDRESS
, &xaddr
);
691 symt_get_info(&symt
->symt
, TI_GET_LENGTH
, &xsize
);
692 symt_get_info(&symt
->symt
, TI_GET_DATAKIND
, &kind
);
694 /* If none of symbols has a correct size, we consider they are both markers
695 * Hence, we can silence this warning
696 * Also, we check that we don't have two symbols, one local, the other
697 * global which is legal
699 if ((xsize
|| ste
->symp
->st_size
) &&
700 (kind
== (ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
) ? DataIsFileStatic
: DataIsGlobal
))
701 FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n",
702 debugstr_w(module
->module
.ModuleName
),
703 ste
->ht_elt
.name
, addr
, (unsigned int)ste
->symp
->st_size
,
705 wine_dbgstr_longlong(xaddr
), wine_dbgstr_longlong(xsize
));
709 /* see comment above */
710 module
->sortlist_valid
= FALSE
;
714 /******************************************************************
715 * elf_new_public_symbols
717 * Creates a set of public symbols from an ELF symtab
719 static int elf_new_public_symbols(struct module
* module
, const struct hash_table
* symtab
)
721 struct hash_table_iter hti
;
722 struct symtab_elt
* ste
;
724 if (dbghelp_options
& SYMOPT_NO_PUBLICS
) return TRUE
;
726 /* FIXME: we're missing the ELF entry point here */
728 hash_table_iter_init(symtab
, &hti
, NULL
);
729 while ((ste
= hash_table_iter_up(&hti
)))
731 symt_new_public(module
, ste
->compiland
, ste
->ht_elt
.name
,
732 module
->elf_info
->elf_addr
+ ste
->symp
->st_value
,
733 ste
->symp
->st_size
, TRUE
/* FIXME */,
734 ELF32_ST_TYPE(ste
->symp
->st_info
) == STT_FUNC
);
739 static BOOL
elf_check_debug_link(const WCHAR
* file
, struct elf_file_map
* fmap
, DWORD crc
)
742 if (!elf_map_file(file
, fmap
)) return FALSE
;
743 if (!(ret
= crc
== calc_crc32(fmap
->fd
)))
745 WARN("Bad CRC for file %s (got %08x while expecting %08x)\n",
746 debugstr_w(file
), calc_crc32(fmap
->fd
), crc
);
747 elf_unmap_file(fmap
);
752 /******************************************************************
753 * elf_locate_debug_link
755 * Locate a filename from a .gnu_debuglink section, using the same
757 * "If the full name of the directory containing the executable is
758 * execdir, and the executable has a debug link that specifies the
759 * name debugfile, then GDB will automatically search for the
760 * debugging information file in three places:
761 * - the directory containing the executable file (that is, it
762 * will look for a file named `execdir/debugfile',
763 * - a subdirectory of that directory named `.debug' (that is, the
764 * file `execdir/.debug/debugfile', and
765 * - a subdirectory of the global debug file directory that includes
766 * the executable's full path, and the name from the link (that is,
767 * the file `globaldebugdir/execdir/debugfile', where globaldebugdir
768 * is the global debug file directory, and execdir has been turned
769 * into a relative path)." (from GDB manual)
771 static BOOL
elf_locate_debug_link(struct elf_file_map
* fmap
, const char* filename
,
772 const WCHAR
* loaded_file
, DWORD crc
)
774 static const WCHAR globalDebugDirW
[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
775 static const WCHAR dotDebugW
[] = {'.','d','e','b','u','g','/'};
776 const size_t globalDebugDirLen
= sizeof(globalDebugDirW
) / sizeof(WCHAR
);
780 struct elf_file_map
* fmap_link
= NULL
;
782 fmap_link
= HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link
));
783 if (!fmap_link
) return FALSE
;
785 filename_len
= MultiByteToWideChar(CP_UNIXCP
, 0, filename
, -1, NULL
, 0);
786 p
= HeapAlloc(GetProcessHeap(), 0,
787 (globalDebugDirLen
+ strlenW(loaded_file
) + 6 + 1 + filename_len
+ 1) * sizeof(WCHAR
));
790 /* we prebuild the string with "execdir" */
791 strcpyW(p
, loaded_file
);
792 slash
= strrchrW(p
, '/');
793 if (slash
== NULL
) slash
= p
; else slash
++;
795 /* testing execdir/filename */
796 MultiByteToWideChar(CP_UNIXCP
, 0, filename
, -1, slash
, filename_len
);
797 if (elf_check_debug_link(p
, fmap_link
, crc
)) goto found
;
799 /* testing execdir/.debug/filename */
800 memcpy(slash
, dotDebugW
, sizeof(dotDebugW
));
801 MultiByteToWideChar(CP_UNIXCP
, 0, filename
, -1, slash
+ sizeof(dotDebugW
) / sizeof(WCHAR
), filename_len
);
802 if (elf_check_debug_link(p
, fmap_link
, crc
)) goto found
;
804 /* testing globaldebugdir/execdir/filename */
805 memmove(p
+ globalDebugDirLen
, p
, (slash
- p
) * sizeof(WCHAR
));
806 memcpy(p
, globalDebugDirW
, globalDebugDirLen
* sizeof(WCHAR
));
807 slash
+= globalDebugDirLen
;
808 MultiByteToWideChar(CP_UNIXCP
, 0, filename
, -1, slash
, filename_len
);
809 if (elf_check_debug_link(p
, fmap_link
, crc
)) goto found
;
811 /* finally testing filename */
812 if (elf_check_debug_link(slash
, fmap_link
, crc
)) goto found
;
815 WARN("Couldn't locate or map %s\n", filename
);
816 HeapFree(GetProcessHeap(), 0, p
);
817 HeapFree(GetProcessHeap(), 0, fmap_link
);
821 TRACE("Located debug information file %s at %s\n", filename
, debugstr_w(p
));
822 HeapFree(GetProcessHeap(), 0, p
);
823 fmap
->alternate
= fmap_link
;
827 /******************************************************************
828 * elf_debuglink_parse
830 * Parses a .gnu_debuglink section and loads the debug info from
831 * the external file specified there.
833 static BOOL
elf_debuglink_parse(struct elf_file_map
* fmap
, const struct module
* module
,
834 const BYTE
* debuglink
)
836 /* The content of a debug link section is:
837 * 1/ a NULL terminated string, containing the file name for the
839 * 2/ padding on 4 byte boundary
840 * 3/ CRC of the linked ELF file
842 const char* dbg_link
= (const char*)debuglink
;
845 crc
= *(const DWORD
*)(dbg_link
+ ((DWORD_PTR
)(strlen(dbg_link
) + 4) & ~3));
846 return elf_locate_debug_link(fmap
, dbg_link
, module
->module
.LoadedImageName
, crc
);
849 /******************************************************************
850 * elf_load_debug_info_from_map
852 * Loads the symbolic information from ELF module which mapping is described
854 * the module has been loaded at 'load_offset' address, so symbols' address
855 * relocation is performed.
856 * CRC is checked if fmap->with_crc is TRUE
858 * 0 if the file doesn't contain symbolic info (or this info cannot be
862 static BOOL
elf_load_debug_info_from_map(struct module
* module
,
863 struct elf_file_map
* fmap
,
865 struct hash_table
* ht_symtab
)
867 BOOL ret
= FALSE
, lret
;
868 struct elf_thunk_area thunks
[] =
870 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE
, 0, 0}, /* inter DLL calls */
871 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
872 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
873 {"__wine_delay_load", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
874 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
875 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
879 module
->module
.SymType
= SymExport
;
881 /* create a hash table for the symtab */
882 elf_hash_symtab(module
, pool
, ht_symtab
, fmap
, thunks
);
884 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
886 struct elf_section_map stab_sect
, stabstr_sect
;
887 struct elf_section_map debug_sect
, debug_str_sect
, debug_abbrev_sect
,
888 debug_line_sect
, debug_loclist_sect
;
889 struct elf_section_map debuglink_sect
;
891 /* if present, add the .gnu_debuglink file as an alternate to current one */
892 if (elf_find_section(fmap
, ".gnu_debuglink", SHT_NULL
, &debuglink_sect
))
894 const BYTE
* dbg_link
;
896 dbg_link
= (const BYTE
*)elf_map_section(&debuglink_sect
);
897 if (dbg_link
!= ELF_NO_MAP
)
899 lret
= elf_debuglink_parse(fmap
, module
, dbg_link
);
901 WARN("Couldn't load linked debug file for %s\n",
902 debugstr_w(module
->module
.ModuleName
));
905 elf_unmap_section(&debuglink_sect
);
907 if (elf_find_section(fmap
, ".stab", SHT_NULL
, &stab_sect
) &&
908 elf_find_section(fmap
, ".stabstr", SHT_NULL
, &stabstr_sect
))
913 stab
= elf_map_section(&stab_sect
);
914 stabstr
= elf_map_section(&stabstr_sect
);
915 if (stab
!= ELF_NO_MAP
&& stabstr
!= ELF_NO_MAP
)
917 /* OK, now just parse all of the stabs. */
918 lret
= stabs_parse(module
, module
->elf_info
->elf_addr
,
919 stab
, elf_get_map_size(&stab_sect
),
920 stabstr
, elf_get_map_size(&stabstr_sect
),
923 /* and fill in the missing information for stabs */
924 elf_finish_stabs_info(module
, ht_symtab
);
926 WARN("Couldn't correctly read stabs\n");
930 elf_unmap_section(&stab_sect
);
931 elf_unmap_section(&stabstr_sect
);
933 if (elf_find_section(fmap
, ".debug_info", SHT_NULL
, &debug_sect
))
935 /* Dwarf 2 debug information */
936 const BYTE
* dw2_debug
;
937 const BYTE
* dw2_debug_abbrev
;
938 const BYTE
* dw2_debug_str
;
939 const BYTE
* dw2_debug_line
;
940 const BYTE
* dw2_debug_loclist
;
942 /* debug info might have a different base address than .so file
943 * when elf file is prelinked after splitting off debug info
944 * adjust symbol base addresses accordingly
946 unsigned long load_offset
= module
->elf_info
->elf_addr
+
947 fmap
->elf_start
- debug_sect
.fmap
->elf_start
;
949 TRACE("Loading Dwarf2 information for %s\n", debugstr_w(module
->module
.ModuleName
));
951 elf_find_section(fmap
, ".debug_str", SHT_NULL
, &debug_str_sect
);
952 elf_find_section(fmap
, ".debug_abbrev", SHT_NULL
, &debug_abbrev_sect
);
953 elf_find_section(fmap
, ".debug_line", SHT_NULL
, &debug_line_sect
);
954 elf_find_section(fmap
, ".debug_loc", SHT_NULL
, &debug_loclist_sect
);
956 dw2_debug
= (const BYTE
*)elf_map_section(&debug_sect
);
957 dw2_debug_abbrev
= (const BYTE
*)elf_map_section(&debug_abbrev_sect
);
958 dw2_debug_str
= (const BYTE
*)elf_map_section(&debug_str_sect
);
959 dw2_debug_line
= (const BYTE
*)elf_map_section(&debug_line_sect
);
960 dw2_debug_loclist
= (const BYTE
*)elf_map_section(&debug_loclist_sect
);
961 if (dw2_debug
!= ELF_NO_MAP
&& dw2_debug_abbrev
!= ELF_NO_MAP
&& dw2_debug_str
!= ELF_NO_MAP
)
963 /* OK, now just parse dwarf2 debug infos. */
964 lret
= dwarf2_parse(module
, load_offset
, thunks
,
965 dw2_debug
, elf_get_map_size(&debug_sect
),
966 dw2_debug_abbrev
, elf_get_map_size(&debug_abbrev_sect
),
967 dw2_debug_str
, elf_get_map_size(&debug_str_sect
),
968 dw2_debug_line
, elf_get_map_size(&debug_line_sect
),
969 dw2_debug_loclist
, elf_get_map_size(&debug_loclist_sect
));
972 WARN("Couldn't correctly read dwarf2\n");
975 elf_unmap_section(&debug_sect
);
976 elf_unmap_section(&debug_abbrev_sect
);
977 elf_unmap_section(&debug_str_sect
);
978 elf_unmap_section(&debug_line_sect
);
979 elf_unmap_section(&debug_loclist_sect
);
982 if (strstrW(module
->module
.ModuleName
, S_ElfW
) ||
983 !strcmpW(module
->module
.ModuleName
, S_WineLoaderW
))
985 /* add the thunks for native libraries */
986 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
987 elf_new_wine_thunks(module
, ht_symtab
, thunks
);
989 /* add all the public symbols from symtab */
990 if (elf_new_public_symbols(module
, ht_symtab
) && !ret
) ret
= TRUE
;
995 /******************************************************************
996 * elf_load_debug_info
998 * Loads ELF debugging information from the module image file.
1000 BOOL
elf_load_debug_info(struct module
* module
, struct elf_file_map
* fmap
)
1004 struct hash_table ht_symtab
;
1005 struct elf_file_map my_fmap
;
1007 if (module
->type
!= DMT_ELF
|| !module
->elf_info
)
1009 ERR("Bad elf module '%s'\n", debugstr_w(module
->module
.LoadedImageName
));
1013 pool_init(&pool
, 65536);
1014 hash_table_init(&pool
, &ht_symtab
, 256);
1019 ret
= elf_map_file(module
->module
.LoadedImageName
, fmap
);
1022 ret
= elf_load_debug_info_from_map(module
, fmap
, &pool
, &ht_symtab
);
1024 pool_destroy(&pool
);
1025 if (fmap
== &my_fmap
) elf_unmap_file(fmap
);
1029 /******************************************************************
1030 * elf_fetch_file_info
1032 * Gathers some more information for an ELF module from a given file
1034 BOOL
elf_fetch_file_info(const WCHAR
* name
, DWORD
* base
,
1035 DWORD
* size
, DWORD
* checksum
)
1037 struct elf_file_map fmap
;
1039 if (!elf_map_file(name
, &fmap
)) return FALSE
;
1040 if (base
) *base
= fmap
.elf_start
;
1041 *size
= fmap
.elf_size
;
1042 *checksum
= calc_crc32(fmap
.fd
);
1043 elf_unmap_file(&fmap
);
1047 /******************************************************************
1050 * Loads the information for ELF module stored in 'filename'
1051 * the module has been loaded at 'load_offset' address
1053 * -1 if the file cannot be found/opened
1054 * 0 if the file doesn't contain symbolic info (or this info cannot be
1058 static BOOL
elf_load_file(struct process
* pcs
, const WCHAR
* filename
,
1059 unsigned long load_offset
, struct elf_info
* elf_info
)
1062 struct elf_file_map fmap
;
1064 TRACE("Processing elf file '%s' at %08lx\n", debugstr_w(filename
), load_offset
);
1066 if (!elf_map_file(filename
, &fmap
)) goto leave
;
1068 /* Next, we need to find a few of the internal ELF headers within
1069 * this thing. We need the main executable header, and the section
1072 if (!fmap
.elf_start
&& !load_offset
)
1073 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
1074 debugstr_w(filename
));
1075 if (fmap
.elf_start
&& load_offset
)
1077 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
1078 "Assuming load address is corrupt\n", debugstr_w(filename
), load_offset
);
1082 if (elf_info
->flags
& ELF_INFO_DEBUG_HEADER
)
1084 struct elf_section_map esm
;
1086 if (elf_find_section(&fmap
, ".dynamic", SHT_DYNAMIC
, &esm
))
1089 char* ptr
= (char*)fmap
.sect
[esm
.sidx
].shdr
.sh_addr
;
1094 if (!ReadProcessMemory(pcs
->handle
, ptr
, &dyn
, sizeof(dyn
), &len
) ||
1097 if (dyn
.d_tag
== DT_DEBUG
)
1099 elf_info
->dbg_hdr_addr
= dyn
.d_un
.d_ptr
;
1103 } while (dyn
.d_tag
!= DT_NULL
);
1104 if (dyn
.d_tag
== DT_NULL
) goto leave
;
1106 elf_end_find(&fmap
);
1109 if (elf_info
->flags
& ELF_INFO_MODULE
)
1111 struct elf_module_info
*elf_module_info
=
1112 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info
));
1113 if (!elf_module_info
) goto leave
;
1114 elf_info
->module
= module_new(pcs
, filename
, DMT_ELF
, FALSE
,
1115 (load_offset
) ? load_offset
: fmap
.elf_start
,
1116 fmap
.elf_size
, 0, calc_crc32(fmap
.fd
));
1117 if (!elf_info
->module
)
1119 HeapFree(GetProcessHeap(), 0, elf_module_info
);
1122 elf_info
->module
->elf_info
= elf_module_info
;
1123 elf_info
->module
->elf_info
->elf_addr
= load_offset
;
1125 if (dbghelp_options
& SYMOPT_DEFERRED_LOADS
)
1127 elf_info
->module
->module
.SymType
= SymDeferred
;
1130 else ret
= elf_load_debug_info(elf_info
->module
, &fmap
);
1132 elf_info
->module
->elf_info
->elf_mark
= 1;
1133 elf_info
->module
->elf_info
->elf_loader
= 0;
1136 if (elf_info
->flags
& ELF_INFO_NAME
)
1139 ptr
= HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename
) + 1) * sizeof(WCHAR
));
1142 strcpyW(ptr
, filename
);
1143 elf_info
->module_name
= ptr
;
1148 elf_unmap_file(&fmap
);
1153 /******************************************************************
1154 * elf_load_file_from_path
1155 * tries to load an ELF file from a set of paths (separated by ':')
1157 static BOOL
elf_load_file_from_path(HANDLE hProcess
,
1158 const WCHAR
* filename
,
1159 unsigned long load_offset
,
1161 struct elf_info
* elf_info
)
1165 WCHAR
* pathW
= NULL
;
1168 if (!path
) return FALSE
;
1170 len
= MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, NULL
, 0);
1171 pathW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1172 if (!pathW
) return FALSE
;
1173 MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, pathW
, len
);
1175 for (s
= pathW
; s
&& *s
; s
= (t
) ? (t
+1) : NULL
)
1177 t
= strchrW(s
, ':');
1179 fn
= HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename
) + 1 + lstrlenW(s
) + 1) * sizeof(WCHAR
));
1182 strcatW(fn
, S_SlashW
);
1183 strcatW(fn
, filename
);
1184 ret
= elf_load_file(hProcess
, fn
, load_offset
, elf_info
);
1185 HeapFree(GetProcessHeap(), 0, fn
);
1187 s
= (t
) ? (t
+1) : NULL
;
1190 HeapFree(GetProcessHeap(), 0, pathW
);
1194 /******************************************************************
1195 * elf_load_file_from_dll_path
1197 * Tries to load an ELF file from the dll path
1199 static BOOL
elf_load_file_from_dll_path(HANDLE hProcess
,
1200 const WCHAR
* filename
,
1201 unsigned long load_offset
,
1202 struct elf_info
* elf_info
)
1205 unsigned int index
= 0;
1208 while (!ret
&& (path
= wine_dll_enum_load_path( index
++ )))
1213 len
= MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, NULL
, 0);
1215 name
= HeapAlloc( GetProcessHeap(), 0,
1216 (len
+ lstrlenW(filename
) + 2) * sizeof(WCHAR
) );
1219 MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, name
, len
);
1220 strcatW( name
, S_SlashW
);
1221 strcatW( name
, filename
);
1222 ret
= elf_load_file(hProcess
, name
, load_offset
, elf_info
);
1223 HeapFree( GetProcessHeap(), 0, name
);
1228 /******************************************************************
1229 * elf_search_and_load_file
1231 * lookup a file in standard ELF locations, and if found, load it
1233 static BOOL
elf_search_and_load_file(struct process
* pcs
, const WCHAR
* filename
,
1234 unsigned long load_offset
,
1235 struct elf_info
* elf_info
)
1238 struct module
* module
;
1239 static WCHAR S_libstdcPPW
[] = {'l','i','b','s','t','d','c','+','+','\0'};
1241 if (filename
== NULL
|| *filename
== '\0') return FALSE
;
1242 if ((module
= module_is_already_loaded(pcs
, filename
)))
1244 elf_info
->module
= module
;
1245 module
->elf_info
->elf_mark
= 1;
1246 return module
->module
.SymType
;
1249 if (strstrW(filename
, S_libstdcPPW
)) return FALSE
; /* We know we can't do it */
1250 ret
= elf_load_file(pcs
, filename
, load_offset
, elf_info
);
1251 /* if relative pathname, try some absolute base dirs */
1252 if (!ret
&& !strchrW(filename
, '/'))
1254 ret
= elf_load_file_from_path(pcs
, filename
, load_offset
,
1255 getenv("PATH"), elf_info
) ||
1256 elf_load_file_from_path(pcs
, filename
, load_offset
,
1257 getenv("LD_LIBRARY_PATH"), elf_info
);
1258 if (!ret
) ret
= elf_load_file_from_dll_path(pcs
, filename
, load_offset
, elf_info
);
1264 /******************************************************************
1265 * elf_enum_modules_internal
1267 * Enumerate ELF modules from a running process
1269 static BOOL
elf_enum_modules_internal(const struct process
* pcs
,
1270 const WCHAR
* main_name
,
1271 enum_modules_cb cb
, void* user
)
1273 struct r_debug dbg_hdr
;
1277 WCHAR bufstrW
[MAX_PATH
];
1279 if (!pcs
->dbg_hdr_addr
||
1280 !ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
,
1281 &dbg_hdr
, sizeof(dbg_hdr
), NULL
))
1284 /* Now walk the linked list. In all known ELF implementations,
1285 * the dynamic loader maintains this linked list for us. In some
1286 * cases the first entry doesn't appear with a name, in other cases it
1289 for (lm_addr
= (void*)dbg_hdr
.r_map
; lm_addr
; lm_addr
= (void*)lm
.l_next
)
1291 if (!ReadProcessMemory(pcs
->handle
, lm_addr
, &lm
, sizeof(lm
), NULL
))
1294 if (lm
.l_prev
!= NULL
&& /* skip first entry, normally debuggee itself */
1295 lm
.l_name
!= NULL
&&
1296 ReadProcessMemory(pcs
->handle
, lm
.l_name
, bufstr
, sizeof(bufstr
), NULL
))
1298 bufstr
[sizeof(bufstr
) - 1] = '\0';
1299 MultiByteToWideChar(CP_UNIXCP
, 0, bufstr
, -1, bufstrW
, sizeof(bufstrW
) / sizeof(WCHAR
));
1300 if (main_name
&& !bufstrW
[0]) strcpyW(bufstrW
, main_name
);
1301 if (!cb(bufstrW
, (unsigned long)lm
.l_addr
, user
)) break;
1309 struct process
* pcs
;
1310 struct elf_info elf_info
;
1313 static BOOL
elf_enum_sync_cb(const WCHAR
* name
, unsigned long addr
, void* user
)
1315 struct elf_sync
* es
= user
;
1317 elf_search_and_load_file(es
->pcs
, name
, addr
, &es
->elf_info
);
1321 /******************************************************************
1322 * elf_synchronize_module_list
1324 * this functions rescans the debuggee module's list and synchronizes it with
1325 * the one from 'pcs', ie:
1326 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1327 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1329 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1331 struct module
* module
;
1334 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1336 if (module
->type
== DMT_ELF
&& !module
->is_virtual
)
1337 module
->elf_info
->elf_mark
= 0;
1341 es
.elf_info
.flags
= ELF_INFO_MODULE
;
1342 if (!elf_enum_modules_internal(pcs
, NULL
, elf_enum_sync_cb
, &es
))
1345 module
= pcs
->lmodules
;
1348 if (module
->type
== DMT_ELF
&& !module
->is_virtual
&&
1349 !module
->elf_info
->elf_mark
&& !module
->elf_info
->elf_loader
)
1351 module_remove(pcs
, module
);
1352 /* restart all over */
1353 module
= pcs
->lmodules
;
1355 else module
= module
->next
;
1360 /******************************************************************
1363 * Lookup in a running ELF process the loader, and sets its ELF link
1364 * address (for accessing the list of loaded .so libs) in pcs.
1365 * If flags is ELF_INFO_MODULE, the module for the loader is also
1366 * added as a module into pcs.
1368 static BOOL
elf_search_loader(struct process
* pcs
, struct elf_info
* elf_info
)
1373 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1376 if ((ptr
= getenv("WINELOADER")))
1378 WCHAR tmp
[MAX_PATH
];
1379 MultiByteToWideChar(CP_ACP
, 0, ptr
, -1, tmp
, sizeof(tmp
) / sizeof(WCHAR
));
1380 ret
= elf_search_and_load_file(pcs
, tmp
, 0, elf_info
);
1384 ret
= elf_search_and_load_file(pcs
, S_WineW
, 0, elf_info
);
1389 /******************************************************************
1390 * elf_read_wine_loader_dbg_info
1392 * Try to find a decent wine executable which could have loaded the debuggee
1394 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1396 struct elf_info elf_info
;
1398 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_MODULE
;
1399 if (!elf_search_loader(pcs
, &elf_info
)) return FALSE
;
1400 elf_info
.module
->elf_info
->elf_loader
= 1;
1401 module_set_module(elf_info
.module
, S_WineLoaderW
);
1402 return (pcs
->dbg_hdr_addr
= elf_info
.dbg_hdr_addr
) != 0;
1405 /******************************************************************
1408 * Enumerates the ELF loaded modules from a running target (hProc)
1409 * This function doesn't require that someone has called SymInitialize
1410 * on this very process.
1412 BOOL
elf_enum_modules(HANDLE hProc
, enum_modules_cb cb
, void* user
)
1415 struct elf_info elf_info
;
1418 memset(&pcs
, 0, sizeof(pcs
));
1420 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_NAME
;
1421 if (!elf_search_loader(&pcs
, &elf_info
)) return FALSE
;
1422 pcs
.dbg_hdr_addr
= elf_info
.dbg_hdr_addr
;
1423 ret
= elf_enum_modules_internal(&pcs
, elf_info
.module_name
, cb
, user
);
1424 HeapFree(GetProcessHeap(), 0, (char*)elf_info
.module_name
);
1430 struct process
* pcs
;
1431 struct elf_info elf_info
;
1436 /******************************************************************
1439 * Callback for elf_load_module, used to walk the list of loaded
1442 static BOOL
elf_load_cb(const WCHAR
* name
, unsigned long addr
, void* user
)
1444 struct elf_load
* el
= user
;
1447 /* memcmp is needed for matches when bufstr contains also version information
1448 * el->name: libc.so, name: libc.so.6.0
1450 p
= strrchrW(name
, '/');
1452 if (!memcmp(p
, el
->name
, lstrlenW(el
->name
) * sizeof(WCHAR
)))
1454 el
->ret
= elf_search_and_load_file(el
->pcs
, name
, addr
, &el
->elf_info
);
1460 /******************************************************************
1463 * loads an ELF module and stores it in process' module list
1464 * Also, find module real name and load address from
1465 * the real loaded modules list in pcs address space
1467 struct module
* elf_load_module(struct process
* pcs
, const WCHAR
* name
, unsigned long addr
)
1471 TRACE("(%p %s %08lx)\n", pcs
, debugstr_w(name
), addr
);
1473 el
.elf_info
.flags
= ELF_INFO_MODULE
;
1476 if (pcs
->dbg_hdr_addr
) /* we're debugging a life target */
1479 /* do only the lookup from the filename, not the path (as we lookup module
1480 * name in the process' loaded module list)
1482 el
.name
= strrchrW(name
, '/');
1483 if (!el
.name
++) el
.name
= name
;
1486 if (!elf_enum_modules_internal(pcs
, NULL
, elf_load_cb
, &el
))
1492 el
.ret
= elf_search_and_load_file(pcs
, el
.name
, addr
, &el
.elf_info
);
1494 if (!el
.ret
) return NULL
;
1495 assert(el
.elf_info
.module
);
1496 return el
.elf_info
.module
;
1499 #else /* !__ELF__ */
1501 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1506 BOOL
elf_fetch_file_info(const WCHAR
* name
, DWORD
* base
,
1507 DWORD
* size
, DWORD
* checksum
)
1512 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1517 BOOL
elf_enum_modules(HANDLE hProc
, enum_modules_cb cb
, void* user
)
1522 struct module
* elf_load_module(struct process
* pcs
, const WCHAR
* name
, unsigned long addr
)
1527 BOOL
elf_load_debug_info(struct module
* module
, struct elf_file_map
* fmap
)
1532 int elf_is_in_thunk_area(unsigned long addr
,
1533 const struct elf_thunk_area
* thunks
)
1537 #endif /* __ELF__ */