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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #ifdef HAVE_SYS_MMAN_H
36 #define PATH_MAX MAX_PATH
39 #include "dbghelp_private.h"
41 #if defined(__svr4__) || defined(__sun)
48 #ifdef HAVE_SYS_ELF32_H
49 # include <sys/elf32.h>
51 #ifdef HAVE_SYS_EXEC_ELF_H
52 # include <sys/exec_elf.h>
55 # if defined(DT_COUNT)
56 # define DT_NUM DT_COUNT
58 /* this seems to be a satisfactory value on Solaris, which doesn't support this AFAICT */
65 #ifdef HAVE_SYS_LINK_H
66 # include <sys/link.h>
69 #include "wine/debug.h"
71 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
73 struct elf_module_info
75 unsigned long elf_addr
;
76 unsigned short elf_mark
: 1,
82 #define ELF_INFO_DEBUG_HEADER 0x0001
83 #define ELF_INFO_MODULE 0x0002
87 unsigned flags
; /* IN one (or several) of the ELF_INFO constants */
88 unsigned long dbg_hdr_addr
; /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */
89 struct module
* module
; /* OUT loaded module (if ELF_INFO_MODULE is set) */
92 #define NO_MAP ((const void*)0xffffffff)
93 /* structure holding information while handling an ELF image
94 * allows one by one section mapping for memory savings
113 struct hash_table_elt ht_elt
;
114 const Elf32_Sym
* symp
;
115 const char* filename
;
122 THUNK_ORDINAL ordinal
;
123 unsigned long rva_start
;
124 unsigned long rva_end
;
127 /******************************************************************
130 * Maps a single section into memory from a ELF file
132 static const char* elf_map_section(struct elf_file_map
* fmap
, int sidx
)
134 unsigned pgsz
= getpagesize();
137 if (sidx
>= fmap
->elfhdr
.e_shnum
||
138 fmap
->sect
[sidx
].shdr
.sh_type
== SHT_NOBITS
)
140 /* align required information on page size (we assume pagesize is a power of 2) */
141 ofst
= fmap
->sect
[sidx
].shdr
.sh_offset
& ~(pgsz
- 1);
142 size
= (fmap
->sect
[sidx
].shdr
.sh_offset
+ fmap
->sect
[sidx
].shdr
.sh_size
+ pgsz
- 1) & ~(pgsz
- 1);
143 fmap
->sect
[sidx
].mapped
= mmap(NULL
, size
, PROT_READ
, MAP_PRIVATE
, fmap
->fd
, ofst
);
144 if (fmap
->sect
[sidx
].mapped
== NO_MAP
) return NO_MAP
;
145 return fmap
->sect
[sidx
].mapped
+ (fmap
->sect
[sidx
].shdr
.sh_offset
& (pgsz
- 1));
148 /******************************************************************
151 * Unmaps a single section from memory
153 static void elf_unmap_section(struct elf_file_map
* fmap
, int sidx
)
155 if (sidx
< fmap
->elfhdr
.e_shnum
&& fmap
->sect
[sidx
].mapped
!= NO_MAP
)
157 munmap((char*)fmap
->sect
[sidx
].mapped
, fmap
->sect
[sidx
].shdr
.sh_size
);
158 fmap
->sect
[sidx
].mapped
= NO_MAP
;
162 /******************************************************************
165 * Maps a ELF file into memory (and checks it's a real ELF file)
167 static BOOL
elf_map_file(const char* filename
, struct elf_file_map
* fmap
)
169 static const BYTE elf_signature
[4] = { ELFMAG0
, ELFMAG1
, ELFMAG2
, ELFMAG3
};
173 unsigned tmp
, page_mask
= getpagesize() - 1;
179 /* check that the file exists, and that the module hasn't been loaded yet */
180 if (stat(filename
, &statbuf
) == -1 || S_ISDIR(statbuf
.st_mode
)) return FALSE
;
182 /* Now open the file, so that we can mmap() it. */
183 if ((fmap
->fd
= open(filename
, O_RDONLY
)) == -1) return FALSE
;
185 if (read(fmap
->fd
, &fmap
->elfhdr
, sizeof(fmap
->elfhdr
)) != sizeof(fmap
->elfhdr
))
187 /* and check for an ELF header */
188 if (memcmp(fmap
->elfhdr
.e_ident
,
189 elf_signature
, sizeof(elf_signature
))) return FALSE
;
191 fmap
->sect
= HeapAlloc(GetProcessHeap(), 0, fmap
->elfhdr
.e_shnum
* sizeof(fmap
->sect
[0]));
192 if (!fmap
->sect
) return FALSE
;
194 lseek(fmap
->fd
, fmap
->elfhdr
.e_shoff
, SEEK_SET
);
195 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
197 read(fmap
->fd
, &fmap
->sect
[i
].shdr
, sizeof(fmap
->sect
[i
].shdr
));
198 fmap
->sect
[i
].mapped
= NO_MAP
;
201 /* grab size of module once loaded in memory */
202 lseek(fmap
->fd
, fmap
->elfhdr
.e_phoff
, SEEK_SET
);
204 fmap
->elf_start
= ~0L;
205 for (i
= 0; i
< fmap
->elfhdr
.e_phnum
; i
++)
207 if (read(fmap
->fd
, &phdr
, sizeof(phdr
)) == sizeof(phdr
) &&
208 phdr
.p_type
== PT_LOAD
)
210 tmp
= (phdr
.p_vaddr
+ phdr
.p_memsz
+ page_mask
) & ~page_mask
;
211 if (fmap
->elf_size
< tmp
) fmap
->elf_size
= tmp
;
212 if (phdr
.p_vaddr
< fmap
->elf_start
) fmap
->elf_start
= phdr
.p_vaddr
;
215 /* if non relocatable ELF, then remove fixed address from computation
216 * otherwise, all addresses are zero based and start has no effect
218 fmap
->elf_size
-= fmap
->elf_start
;
222 /******************************************************************
225 * Unmaps a ELF file from memory (previously mapped with elf_map_file)
227 static void elf_unmap_file(struct elf_file_map
* fmap
)
232 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
234 elf_unmap_section(fmap
, i
);
236 HeapFree(GetProcessHeap(), 0, fmap
->sect
);
241 /******************************************************************
244 * creating an internal hash table to ease use ELF symtab information lookup
246 static void elf_hash_symtab(const struct module
* module
, struct pool
* pool
,
247 struct hash_table
* ht_symtab
, struct elf_file_map
* fmap
,
248 int symtab_idx
, struct thunk_area
* thunks
)
253 const char* filename
= NULL
;
255 const Elf32_Sym
* symp
;
256 struct symtab_elt
* ste
;
258 symp
= (const Elf32_Sym
*)elf_map_section(fmap
, symtab_idx
);
259 strp
= elf_map_section(fmap
, fmap
->sect
[symtab_idx
].shdr
.sh_link
);
260 if (symp
== NO_MAP
|| strp
== NO_MAP
) return;
262 nsym
= fmap
->sect
[symtab_idx
].shdr
.sh_size
/ sizeof(*symp
);
264 for (j
= 0; thunks
[j
].symname
; j
++)
265 thunks
[j
].rva_start
= thunks
[j
].rva_end
= 0;
267 for (i
= 0; i
< nsym
; i
++, symp
++)
269 /* Ignore certain types of entries which really aren't of that much
272 if ((ELF32_ST_TYPE(symp
->st_info
) != STT_FILE
&&
273 ELF32_ST_TYPE(symp
->st_info
) != STT_OBJECT
&&
274 ELF32_ST_TYPE(symp
->st_info
) != STT_FUNC
) ||
275 symp
->st_shndx
== SHN_UNDEF
)
280 symname
= strp
+ symp
->st_name
;
282 if (ELF32_ST_TYPE(symp
->st_info
) == STT_FILE
)
287 for (j
= 0; thunks
[j
].symname
; j
++)
289 if (!strcmp(symname
, thunks
[j
].symname
))
291 thunks
[j
].rva_start
= symp
->st_value
;
292 thunks
[j
].rva_end
= symp
->st_value
+ symp
->st_size
;
296 if (thunks
[j
].symname
) continue;
298 /* FIXME: we don't need to handle them (GCC internals)
299 * Moreover, they screw up our symbol lookup :-/
301 if (symname
[0] == '.' && symname
[1] == 'L' && isdigit(symname
[2]))
304 ste
= pool_alloc(pool
, sizeof(*ste
));
305 ste
->ht_elt
.name
= symname
;
306 /* GCC emits, in some cases, a .<digit>+ suffix.
307 * This is used for static variable inside functions, so
308 * that we can have several such variables with same name in
309 * the same compilation unit
310 * We simply ignore that suffix when present (we also get rid
311 * of it in stabs parsing)
313 ptr
= symname
+ strlen(symname
) - 1;
316 while (isdigit(*ptr
) && ptr
>= symname
) ptr
--;
317 if (ptr
> symname
&& *ptr
== '.')
319 char* n
= pool_alloc(pool
, ptr
- symname
+ 1);
320 memcpy(n
, symname
, ptr
- symname
+ 1);
321 n
[ptr
- symname
] = '\0';
322 ste
->ht_elt
.name
= n
;
326 ste
->filename
= filename
;
328 hash_table_add(ht_symtab
, &ste
->ht_elt
);
330 /* as we added in the ht_symtab pointers to the symbols themselves,
331 * we cannot unmap yet the sections, it will be done when we're over
336 /******************************************************************
339 * lookup a symbol by name in our internal hash table for the symtab
341 static const Elf32_Sym
* elf_lookup_symtab(const struct module
* module
,
342 const struct hash_table
* ht_symtab
,
343 const char* name
, struct symt
* compiland
)
345 struct symtab_elt
* weak_result
= NULL
; /* without compiland name */
346 struct symtab_elt
* result
= NULL
;
347 struct hash_table_iter hti
;
348 struct symtab_elt
* ste
;
349 const char* compiland_name
;
350 const char* compiland_basename
;
353 /* we need weak match up (at least) when symbols of same name,
354 * defined several times in different compilation units,
355 * are merged in a single one (hence a different filename for c.u.)
359 compiland_name
= source_get(module
,
360 ((struct symt_compiland
*)compiland
)->source
);
361 compiland_basename
= strrchr(compiland_name
, '/');
362 if (!compiland_basename
++) compiland_basename
= compiland_name
;
364 else compiland_name
= compiland_basename
= NULL
;
366 hash_table_iter_init(ht_symtab
, &hti
, name
);
367 while ((ste
= hash_table_iter_up(&hti
)))
369 if (ste
->used
|| strcmp(ste
->ht_elt
.name
, name
)) continue;
372 if ((ste
->filename
&& !compiland_name
) || (!ste
->filename
&& compiland_name
))
374 if (ste
->filename
&& compiland_name
)
376 if (strcmp(ste
->filename
, compiland_name
))
378 base
= strrchr(ste
->filename
, '/');
379 if (!base
++) base
= ste
->filename
;
380 if (strcmp(base
, compiland_basename
)) continue;
385 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
386 name
, compiland_name
, result
->filename
, result
->symp
->st_value
,
387 ste
->filename
, ste
->symp
->st_value
);
395 if (!result
&& !(result
= weak_result
))
397 FIXME("Couldn't find symbol %s!%s in symtab\n",
398 module
->module
.ModuleName
, name
);
404 /******************************************************************
405 * elf_finish_stabs_info
407 * - get any relevant information (address & size) from the bits we got from the
408 * stabs debugging information
410 static void elf_finish_stabs_info(struct module
* module
, struct hash_table
* symtab
)
412 struct hash_table_iter hti
;
415 const Elf32_Sym
* symp
;
417 hash_table_iter_init(&module
->ht_symbols
, &hti
, NULL
);
418 while ((ptr
= hash_table_iter_up(&hti
)))
420 sym
= GET_ENTRY(ptr
, struct symt_ht
, hash_elt
);
421 switch (sym
->symt
.tag
)
424 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
425 ((struct symt_function
*)sym
)->size
)
429 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
430 ((struct symt_function
*)sym
)->container
);
433 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
434 ((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
+ symp
->st_value
)
435 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
436 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
437 ((struct symt_function
*)sym
)->address
, module
->elf_info
->elf_addr
+ symp
->st_value
);
438 if (((struct symt_function
*)sym
)->size
&& ((struct symt_function
*)sym
)->size
!= symp
->st_size
)
439 FIXME("Changing size for %p/%s!%s from %08lx to %08x\n",
440 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
441 ((struct symt_function
*)sym
)->size
, symp
->st_size
);
443 ((struct symt_function
*)sym
)->address
= module
->elf_info
->elf_addr
+
445 ((struct symt_function
*)sym
)->size
= symp
->st_size
;
446 } else FIXME("Couldn't find %s!%s\n", module
->module
.ModuleName
, sym
->hash_elt
.name
);
449 switch (((struct symt_data
*)sym
)->kind
)
452 case DataIsFileStatic
:
453 if (((struct symt_data
*)sym
)->u
.address
!= module
->elf_info
->elf_addr
)
455 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
456 ((struct symt_data
*)sym
)->container
);
459 if (((struct symt_data
*)sym
)->u
.address
!= module
->elf_info
->elf_addr
&&
460 ((struct symt_data
*)sym
)->u
.address
!= module
->elf_info
->elf_addr
+ symp
->st_value
)
461 FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n",
462 sym
, module
->module
.ModuleName
, sym
->hash_elt
.name
,
463 ((struct symt_function
*)sym
)->address
, module
->elf_info
->elf_addr
+ symp
->st_value
);
464 ((struct symt_data
*)sym
)->u
.address
= module
->elf_info
->elf_addr
+
466 ((struct symt_data
*)sym
)->kind
= (ELF32_ST_BIND(symp
->st_info
) == STB_LOCAL
) ?
467 DataIsFileStatic
: DataIsGlobal
;
468 } else FIXME("Couldn't find %s!%s\n", module
->module
.ModuleName
, sym
->hash_elt
.name
);
474 FIXME("Unsupported tag %u\n", sym
->symt
.tag
);
478 /* since we may have changed some addresses & sizes, mark the module to be resorted */
479 module
->sortlist_valid
= FALSE
;
482 /******************************************************************
483 * elf_load_wine_thunks
485 * creating the thunk objects for a wine native DLL
487 static int elf_new_wine_thunks(struct module
* module
, struct hash_table
* ht_symtab
,
488 unsigned num_areas
, struct thunk_area
* thunks
)
491 struct symt_compiland
* compiland
= NULL
;
492 const char* compiland_name
= NULL
;
493 struct hash_table_iter hti
;
494 struct symtab_elt
* ste
;
498 hash_table_iter_init(ht_symtab
, &hti
, NULL
);
499 while ((ste
= hash_table_iter_up(&hti
)))
501 if (ste
->used
) continue;
503 /* FIXME: this is not a good idea anyway... we are creating several
504 * compiland objects for a same compilation unit
505 * We try to cache the last compiland used, but it's not enough
506 * (we should here only create compilands if they are not yet
509 if (!compiland_name
|| compiland_name
!= ste
->filename
)
510 compiland
= symt_new_compiland(module
,
511 compiland_name
= ste
->filename
);
513 addr
= module
->elf_info
->elf_addr
+ ste
->symp
->st_value
;
515 for (j
= 0; j
< num_areas
; j
++)
517 if (ste
->symp
->st_value
>= thunks
[j
].rva_start
&&
518 ste
->symp
->st_value
< thunks
[j
].rva_end
)
521 if (j
< num_areas
) /* thunk found */
523 symt_new_thunk(module
, compiland
, ste
->ht_elt
.name
, thunks
[j
].ordinal
,
524 addr
, ste
->symp
->st_size
);
530 idx
= symt_find_nearest(module
, addr
);
532 symt_get_info(&module
->addr_sorttab
[idx
]->symt
,
533 TI_GET_ADDRESS
, &ref_addr
);
534 if (idx
== -1 || addr
!= ref_addr
)
536 /* creating public symbols for all the ELF symbols which haven't been
537 * used yet (ie we have no debug information on them)
538 * That's the case, for example, of the .spec.c files
540 switch (ELF32_ST_TYPE(ste
->symp
->st_info
))
543 symt_new_function(module
, compiland
, ste
->ht_elt
.name
,
544 addr
, ste
->symp
->st_size
, NULL
);
547 symt_new_global_variable(module
, compiland
, ste
->ht_elt
.name
,
548 ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
,
549 addr
, ste
->symp
->st_size
, NULL
);
552 FIXME("Shouldn't happen\n");
555 /* FIXME: this is a hack !!!
556 * we are adding new symbols, but as we're parsing a symbol table
557 * (hopefully without duplicate symbols) we delay rebuilding the sorted
558 * module table until we're done with the symbol table
559 * Otherwise, as we intertwine symbols's add and lookup, performance
562 module
->sortlist_valid
= TRUE
;
564 else if (strcmp(ste
->ht_elt
.name
, module
->addr_sorttab
[idx
]->hash_elt
.name
))
567 DWORD xsize
= 0, kind
= -1;
569 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_ADDRESS
, &xaddr
);
570 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_LENGTH
, &xsize
);
571 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_DATAKIND
, &kind
);
573 /* If none of symbols has a correct size, we consider they are both markers
574 * Hence, we can silence this warning
575 * Also, we check that we don't have two symbols, one local, the other
576 * global which is legal
578 if ((xsize
|| ste
->symp
->st_size
) &&
579 (kind
== (ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
) ? DataIsFileStatic
: DataIsGlobal
))
580 FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%08lx>\n",
581 module
->module
.ModuleName
,
582 ste
->ht_elt
.name
, addr
, ste
->symp
->st_size
,
583 module
->addr_sorttab
[idx
]->hash_elt
.name
,
584 wine_dbgstr_longlong(xaddr
), xsize
);
588 /* see comment above */
589 module
->sortlist_valid
= FALSE
;
593 /******************************************************************
594 * elf_new_public_symbols
596 * Creates a set of public symbols from an ELF symtab
598 static int elf_new_public_symbols(struct module
* module
, struct hash_table
* symtab
)
600 struct symt_compiland
* compiland
= NULL
;
601 const char* compiland_name
= NULL
;
602 struct hash_table_iter hti
;
603 struct symtab_elt
* ste
;
605 if (dbghelp_options
& SYMOPT_NO_PUBLICS
) return TRUE
;
607 /* FIXME: we're missing the ELF entry point here */
609 hash_table_iter_init(symtab
, &hti
, NULL
);
610 while ((ste
= hash_table_iter_up(&hti
)))
612 /* FIXME: this is not a good idea anyway... we are creating several
613 * compiland objects for a same compilation unit
614 * We try to cache the last compiland used, but it's not enough
615 * (we should here only create compilands if they are not yet
618 if (!compiland_name
|| compiland_name
!= ste
->filename
)
619 compiland
= symt_new_compiland(module
,
620 compiland_name
= ste
->filename
);
622 symt_new_public(module
, compiland
, ste
->ht_elt
.name
,
623 module
->elf_info
->elf_addr
+ ste
->symp
->st_value
,
624 ste
->symp
->st_size
, TRUE
/* FIXME */,
625 ELF32_ST_TYPE(ste
->symp
->st_info
) == STT_FUNC
);
630 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
631 the following calc_crc32 code or tables extracted from it, as desired without
634 /**********************************************************************\
635 |* Demonstration program to compute the 32-bit CRC used as the frame *|
636 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
637 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
638 |* protocol). The 32-bit FCS was added via the Federal Register, *|
639 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
640 |* this polynomial is or will be included in CCITT V.41, which *|
641 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
642 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
643 |* errors by a factor of 10^-5 over 16-bit FCS. *|
644 \**********************************************************************/
646 /* First, the polynomial itself and its table of feedback terms. The */
648 /* 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 */
649 /* Note that we take it "backwards" and put the highest-order term in */
650 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
651 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
652 /* the MSB being 1. */
654 /* Note that the usual hardware shift register implementation, which */
655 /* is what we're using (we're merely optimizing it by doing eight-bit */
656 /* chunks at a time) shifts bits into the lowest-order term. In our */
657 /* implementation, that means shifting towards the right. Why do we */
658 /* do it this way? Because the calculated CRC must be transmitted in */
659 /* order from highest-order term to lowest-order term. UARTs transmit */
660 /* characters in order from LSB to MSB. By storing the CRC this way, */
661 /* we hand it to the UART in the order low-byte to high-byte; the UART */
662 /* sends each low-bit to hight-bit; and the result is transmission bit */
663 /* by bit from highest- to lowest-order term without requiring any bit */
664 /* shuffling on our part. Reception works similarly. */
666 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
668 /* 1. The table can be generated at runtime if desired; code to do so */
669 /* is shown later. It might not be obvious, but the feedback */
670 /* terms simply represent the results of eight shift/xor opera- */
671 /* tions for all combinations of data and CRC register values. */
673 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
674 /* be they sixteen or thirty-two bits wide. You simply choose the */
675 /* appropriate table. Alternatively, because the table can be */
676 /* generated at runtime, you can start by generating the table for */
677 /* the polynomial in question and use exactly the same "updcrc", */
678 /* if your application needn't simultaneously handle two CRC */
679 /* polynomials. (Note, however, that XMODEM is strange.) */
681 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
682 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
684 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
685 /* logic; the shift must be unsigned (bring in zeroes). On some */
686 /* hardware you could probably optimize the shift in assembler by */
687 /* using byte-swap instructions. */
690 static DWORD
calc_crc32(struct elf_file_map
* fmap
)
692 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
693 static const DWORD crc_32_tab
[] =
694 { /* CRC polynomial 0xedb88320 */
695 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
696 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
697 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
698 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
699 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
700 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
701 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
702 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
703 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
704 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
705 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
706 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
707 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
708 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
709 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
710 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
711 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
712 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
713 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
714 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
715 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
716 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
717 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
718 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
719 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
720 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
721 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
722 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
723 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
724 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
725 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
726 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
727 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
728 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
729 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
730 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
731 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
732 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
733 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
734 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
735 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
736 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
737 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
740 unsigned char buffer
[256];
743 lseek(fmap
->fd
, 0, SEEK_SET
);
744 while ((r
= read(fmap
->fd
, buffer
, sizeof(buffer
))) > 0)
746 for (i
= 0; i
< r
; i
++) crc
= UPDC32(buffer
[i
], crc
);
752 /******************************************************************
753 * elf_load_debug_info_from_map
755 * Loads the symbolic information from ELF module which mapping is described
757 * the module has been loaded at 'load_offset' address, so symbols' address
758 * relocation is performed.
759 * CRC is checked if fmap->with_crc is TRUE
761 * 0 if the file doesn't contain symbolic info (or this info cannot be
765 static BOOL
elf_load_debug_info_from_map(struct module
* module
,
766 struct elf_file_map
* fmap
,
768 struct hash_table
* ht_symtab
)
771 const char* shstrtab
;
773 int symtab_sect
, dynsym_sect
, stab_sect
, stabstr_sect
, debug_sect
, debuglink_sect
;
774 struct thunk_area thunks
[] =
776 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE
, 0, 0}, /* inter DLL calls */
777 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
778 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
779 {"__wine_delay_load", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
780 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
781 {"__wine_spec_thunk_data_16", -16, 0, 0}, /* 16 => 32 thunks */
782 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
783 {"__wine_spec_thunk_data_32", -32, 0, 0}, /* 32 => 16 thunks */
787 if (fmap
->with_crc
&& (fmap
->crc
!= calc_crc32(fmap
)))
789 ERR("Bad CRC for module %s (got %08lx while expecting %08lx)\n",
790 module
->module
.ImageName
, calc_crc32(fmap
), fmap
->crc
);
791 /* we don't tolerate mis-matched files */
796 * Next, we need to find a few of the internal ELF headers within
797 * this thing. We need the main executable header, and the section
800 shstrtab
= elf_map_section(fmap
, fmap
->elfhdr
.e_shstrndx
);
801 if (shstrtab
== NO_MAP
) return FALSE
;
803 symtab_sect
= dynsym_sect
= stab_sect
= stabstr_sect
= debug_sect
= debuglink_sect
= -1;
805 for (i
= 0; i
< fmap
->elfhdr
.e_shnum
; i
++)
807 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".stab") == 0)
809 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".stabstr") == 0)
811 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".debug_info") == 0)
813 if (strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".gnu_debuglink") == 0)
815 if ((strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".symtab") == 0) &&
816 (fmap
->sect
[i
].shdr
.sh_type
== SHT_SYMTAB
))
818 if ((strcmp(shstrtab
+ fmap
->sect
[i
].shdr
.sh_name
, ".dynsym") == 0) &&
819 (fmap
->sect
[i
].shdr
.sh_type
== SHT_DYNSYM
))
822 elf_unmap_section(fmap
, fmap
->elfhdr
.e_shstrndx
);
825 if (symtab_sect
== -1)
827 /* if we don't have a symtab but a dynsym, process the dynsym
828 * section instead. It'll contain less (relevant) information,
829 * but it'll be better than nothing
831 if (dynsym_sect
== -1) return FALSE
;
832 symtab_sect
= dynsym_sect
;
835 module
->module
.SymType
= SymExport
;
837 /* create a hash table for the symtab */
838 elf_hash_symtab(module
, pool
, ht_symtab
, fmap
, symtab_sect
, thunks
);
840 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
842 if (stab_sect
!= -1 && stabstr_sect
!= -1)
847 stab
= elf_map_section(fmap
, stab_sect
);
848 stabstr
= elf_map_section(fmap
, stabstr_sect
);
849 if (stab
!= NO_MAP
&& stabstr
!= NO_MAP
)
851 /* OK, now just parse all of the stabs. */
852 ret
= stabs_parse(module
, module
->elf_info
->elf_addr
,
853 stab
, fmap
->sect
[stab_sect
].shdr
.sh_size
,
854 stabstr
, fmap
->sect
[stabstr_sect
].shdr
.sh_size
);
856 elf_unmap_section(fmap
, stab_sect
);
857 elf_unmap_section(fmap
, stabstr_sect
);
861 WARN("Couldn't correctly read stabs\n");
864 /* and fill in the missing information for stabs */
865 elf_finish_stabs_info(module
, ht_symtab
);
867 else if (debug_sect
!= -1)
869 /* Dwarf 2 debug information */
870 FIXME("Unsupported Dwarf2 information for %s\n", module
->module
.ModuleName
);
872 else if (debuglink_sect
!= -1)
874 const char* dbg_link
;
875 struct elf_file_map fmap_link
;
877 dbg_link
= elf_map_section(fmap
, debuglink_sect
);
878 /* The content of a debug link section is:
879 * 1/ a NULL terminated string, containing the file name for the debug info
880 * 2/ padding on 4 byte boundary
881 * 3/ CRC of the linked ELF file
883 if (dbg_link
!= NO_MAP
&& elf_map_file(dbg_link
, &fmap_link
))
885 fmap_link
.crc
= *(const DWORD
*)(dbg_link
+ ((DWORD_PTR
)(strlen(dbg_link
) + 4) & ~3));
886 fmap_link
.with_crc
= 1;
887 ret
= elf_load_debug_info_from_map(module
, &fmap_link
, pool
, ht_symtab
);
889 WARN("Couldn't load debug information from %s\n", dbg_link
);
891 else WARN("Couldn't load linked debug file for %s\n", module
->module
.ModuleName
);
892 elf_unmap_file(&fmap_link
);
895 if (strstr(module
->module
.ModuleName
, "<elf>") ||
896 !strcmp(module
->module
.ModuleName
, "<wine-loader>"))
898 /* add the thunks for native libraries */
899 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
900 elf_new_wine_thunks(module
, ht_symtab
,
901 sizeof(thunks
) / sizeof(thunks
[0]), thunks
);
903 /* add all the public symbols from symtab */
904 if (elf_new_public_symbols(module
, ht_symtab
) && !ret
) ret
= TRUE
;
909 /******************************************************************
910 * elf_load_debug_info
912 * Loads ELF debugging information from the module image file.
914 BOOL
elf_load_debug_info(struct module
* module
, struct elf_file_map
* fmap
)
918 struct hash_table ht_symtab
;
919 struct elf_file_map my_fmap
;
921 if (module
->type
!= DMT_ELF
|| !module
->elf_info
)
923 ERR("Bad elf module '%s'\n", module
->module
.LoadedImageName
);
927 pool_init(&pool
, 65536);
928 hash_table_init(&pool
, &ht_symtab
, 256);
933 ret
= elf_map_file(module
->module
.LoadedImageName
, fmap
);
936 ret
= elf_load_debug_info_from_map(module
, fmap
, &pool
, &ht_symtab
);
939 if (fmap
== &my_fmap
) elf_unmap_file(fmap
);
944 /******************************************************************
946 * returns true iff the section tag is valid
948 static unsigned is_dt_flag_valid(unsigned d_tag
)
954 #define DT_EXTRANUM 0
956 return (d_tag
>= 0 && d_tag
< DT_NUM
+ DT_PROCNUM
+ DT_EXTRANUM
)
957 #if defined(DT_LOOS) && defined(DT_HIOS)
958 || (d_tag
>= DT_LOOS
&& d_tag
< DT_HIOS
)
960 #if defined(DT_LOPROC) && defined(DT_HIPROC)
961 || (d_tag
>= DT_LOPROC
&& d_tag
< DT_HIPROC
)
966 /******************************************************************
969 * Loads the information for ELF module stored in 'filename'
970 * the module has been loaded at 'load_offset' address
972 * -1 if the file cannot be found/opened
973 * 0 if the file doesn't contain symbolic info (or this info cannot be
977 static BOOL
elf_load_file(struct process
* pcs
, const char* filename
,
978 unsigned long load_offset
, struct elf_info
* elf_info
)
981 struct elf_file_map fmap
;
984 TRACE("Processing elf file '%s' at %08lx\n", filename
, load_offset
);
986 if (!elf_map_file(filename
, &fmap
)) goto leave
;
988 /* Next, we need to find a few of the internal ELF headers within
989 * this thing. We need the main executable header, and the section
992 if (!fmap
.elf_start
&& !load_offset
)
993 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
995 if (fmap
.elf_start
&& load_offset
)
997 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
998 "Assuming load address is corrupt\n", filename
, load_offset
);
1002 if (elf_info
->flags
& ELF_INFO_DEBUG_HEADER
)
1004 const char* shstrtab
= elf_map_section(&fmap
, fmap
.elfhdr
.e_shstrndx
);
1005 if (shstrtab
== NO_MAP
) goto leave
;
1006 for (i
= 0; i
< fmap
.elfhdr
.e_shnum
; i
++)
1008 if (strcmp(shstrtab
+ fmap
.sect
[i
].shdr
.sh_name
, ".dynamic") == 0 &&
1009 fmap
.sect
[i
].shdr
.sh_type
== SHT_DYNAMIC
)
1012 char* ptr
= (char*)fmap
.sect
[i
].shdr
.sh_addr
;
1017 if (!ReadProcessMemory(pcs
->handle
, ptr
, &dyn
, sizeof(dyn
), &len
) ||
1018 len
!= sizeof(dyn
) || !is_dt_flag_valid(dyn
.d_tag
))
1019 dyn
.d_tag
= DT_NULL
;
1021 } while (dyn
.d_tag
!= DT_DEBUG
&& dyn
.d_tag
!= DT_NULL
);
1022 if (dyn
.d_tag
== DT_NULL
) goto leave
;
1023 elf_info
->dbg_hdr_addr
= dyn
.d_un
.d_ptr
;
1026 elf_unmap_section(&fmap
, fmap
.elfhdr
.e_shstrndx
);
1029 if (elf_info
->flags
& ELF_INFO_MODULE
)
1031 struct elf_module_info
*elf_module_info
=
1032 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info
));
1033 if (!elf_module_info
) goto leave
;
1034 elf_info
->module
= module_new(pcs
, filename
, DMT_ELF
,
1035 (load_offset
) ? load_offset
: fmap
.elf_start
,
1036 fmap
.elf_size
, 0, 0);
1037 if (!elf_info
->module
)
1039 HeapFree(GetProcessHeap(), 0, elf_module_info
);
1042 elf_info
->module
->elf_info
= elf_module_info
;
1043 elf_info
->module
->elf_info
->elf_addr
= load_offset
;
1045 if (dbghelp_options
& SYMOPT_DEFERRED_LOADS
)
1047 elf_info
->module
->module
.SymType
= SymDeferred
;
1050 else ret
= elf_load_debug_info(elf_info
->module
, &fmap
);
1052 elf_info
->module
->elf_info
->elf_mark
= 1;
1053 elf_info
->module
->elf_info
->elf_loader
= 0;
1057 elf_unmap_file(&fmap
);
1062 /******************************************************************
1063 * elf_load_file_from_path
1064 * tries to load an ELF file from a set of paths (separated by ':')
1066 static BOOL
elf_load_file_from_path(HANDLE hProcess
,
1067 const char* filename
,
1068 unsigned long load_offset
,
1070 struct elf_info
* elf_info
)
1076 if (!path
) return FALSE
;
1078 paths
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path
) + 1), path
);
1079 for (s
= paths
; s
&& *s
; s
= (t
) ? (t
+1) : NULL
)
1083 fn
= HeapAlloc(GetProcessHeap(), 0, strlen(filename
) + 1 + strlen(s
) + 1);
1087 strcat(fn
, filename
);
1088 ret
= elf_load_file(hProcess
, fn
, load_offset
, elf_info
);
1089 HeapFree(GetProcessHeap(), 0, fn
);
1091 s
= (t
) ? (t
+1) : NULL
;
1094 HeapFree(GetProcessHeap(), 0, paths
);
1098 /******************************************************************
1099 * elf_search_and_load_file
1101 * lookup a file in standard ELF locations, and if found, load it
1103 static BOOL
elf_search_and_load_file(struct process
* pcs
, const char* filename
,
1104 unsigned long load_offset
,
1105 struct elf_info
* elf_info
)
1108 struct module
* module
;
1110 if (filename
== NULL
|| *filename
== '\0') return FALSE
;
1111 if ((module
= module_find_by_name(pcs
, filename
, DMT_ELF
)))
1113 elf_info
->module
= module
;
1114 module
->elf_info
->elf_mark
= 1;
1115 return module
->module
.SymType
;
1118 if (strstr(filename
, "libstdc++")) return FALSE
; /* We know we can't do it */
1119 ret
= elf_load_file(pcs
, filename
, load_offset
, elf_info
);
1120 /* if relative pathname, try some absolute base dirs */
1121 if (!ret
&& !strchr(filename
, '/'))
1123 ret
= elf_load_file_from_path(pcs
, filename
, load_offset
,
1124 getenv("PATH"), elf_info
) ||
1125 elf_load_file_from_path(pcs
, filename
, load_offset
,
1126 getenv("LD_LIBRARY_PATH"), elf_info
) ||
1127 elf_load_file_from_path(pcs
, filename
, load_offset
,
1128 getenv("WINEDLLPATH"), elf_info
);
1134 /******************************************************************
1135 * elf_enum_modules_internal
1137 * Enumerate ELF modules from a running process
1139 static BOOL
elf_enum_modules_internal(const struct process
* pcs
,
1140 elf_enum_modules_cb cb
, void* user
)
1142 struct r_debug dbg_hdr
;
1147 if (!pcs
->dbg_hdr_addr
||
1148 !ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
,
1149 &dbg_hdr
, sizeof(dbg_hdr
), NULL
))
1152 /* Now walk the linked list. In all known ELF implementations,
1153 * the dynamic loader maintains this linked list for us. In some
1154 * cases the first entry doesn't appear with a name, in other cases it
1157 for (lm_addr
= (void*)dbg_hdr
.r_map
; lm_addr
; lm_addr
= (void*)lm
.l_next
)
1159 if (!ReadProcessMemory(pcs
->handle
, lm_addr
, &lm
, sizeof(lm
), NULL
))
1162 if (lm
.l_prev
!= NULL
&& /* skip first entry, normally debuggee itself */
1163 lm
.l_name
!= NULL
&&
1164 ReadProcessMemory(pcs
->handle
, lm
.l_name
, bufstr
, sizeof(bufstr
), NULL
))
1166 bufstr
[sizeof(bufstr
) - 1] = '\0';
1167 if (!cb(bufstr
, lm
.l_addr
, user
)) break;
1175 struct process
* pcs
;
1176 struct elf_info elf_info
;
1179 static BOOL
elf_enum_sync_cb(const char* name
, unsigned long addr
, void* user
)
1181 struct elf_sync
* es
= user
;
1183 elf_search_and_load_file(es
->pcs
, name
, addr
, &es
->elf_info
);
1187 /******************************************************************
1188 * elf_synchronize_module_list
1190 * this functions rescans the debuggee module's list and synchronizes it with
1191 * the one from 'pcs', ie:
1192 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1193 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1195 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1197 struct module
* module
;
1200 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1202 if (module
->type
== DMT_ELF
) module
->elf_info
->elf_mark
= 0;
1206 es
.elf_info
.flags
= ELF_INFO_MODULE
;
1207 if (!elf_enum_modules_internal(pcs
, elf_enum_sync_cb
, &es
))
1210 module
= pcs
->lmodules
;
1213 if (module
->type
== DMT_ELF
&& !module
->elf_info
->elf_mark
&&
1214 !module
->elf_info
->elf_loader
)
1216 module_remove(pcs
, module
);
1217 /* restart all over */
1218 module
= pcs
->lmodules
;
1220 else module
= module
->next
;
1225 /******************************************************************
1228 * Lookup in a running ELF process the loader, and sets its ELF link
1229 * address (for accessing the list of loaded .so libs) in pcs.
1230 * If flags is ELF_INFO_MODULE, the module for the loader is also
1231 * added as a module into pcs.
1233 static BOOL
elf_search_loader(struct process
* pcs
, struct elf_info
* elf_info
)
1238 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1239 * main executable (either wine-kthread or wine-pthread)
1240 * FIXME: the heuristic used to know whether we need to load wine-pthread
1241 * or wine-kthread is not 100% safe
1243 if ((ptr
= getenv("WINELOADER")))
1244 ret
= elf_search_and_load_file(pcs
, ptr
, 0, elf_info
);
1247 ret
= elf_search_and_load_file(pcs
, "wine-kthread", 0, elf_info
) ||
1248 elf_search_and_load_file(pcs
, "wine-pthread", 0, elf_info
);
1253 /******************************************************************
1254 * elf_read_wine_loader_dbg_info
1256 * Try to find a decent wine executable which could have loaded the debuggee
1258 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1260 struct elf_info elf_info
;
1262 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_MODULE
;
1263 if (!elf_search_loader(pcs
, &elf_info
)) return FALSE
;
1264 elf_info
.module
->elf_info
->elf_loader
= 1;
1265 strcpy(elf_info
.module
->module
.ModuleName
, "<wine-loader>");
1266 return (pcs
->dbg_hdr_addr
= elf_info
.dbg_hdr_addr
) != 0;
1269 /******************************************************************
1272 * Enumerates the ELF loaded modules from a running target (hProc)
1273 * This function doesn't require that someone has called SymInitialize
1274 * on this very process.
1276 BOOL
elf_enum_modules(HANDLE hProc
, elf_enum_modules_cb cb
, void* user
)
1279 struct elf_info elf_info
;
1281 memset(&pcs
, 0, sizeof(pcs
));
1283 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
;
1284 if (!elf_search_loader(&pcs
, &elf_info
)) return FALSE
;
1285 pcs
.dbg_hdr_addr
= elf_info
.dbg_hdr_addr
;
1286 return elf_enum_modules_internal(&pcs
, cb
, user
);
1291 struct process
* pcs
;
1292 struct elf_info elf_info
;
1297 /******************************************************************
1300 * Callback for elf_load_module, used to walk the list of loaded
1303 static BOOL
elf_load_cb(const char* name
, unsigned long addr
, void* user
)
1305 struct elf_load
* el
= user
;
1308 /* memcmp is needed for matches when bufstr contains also version information
1309 * el->name: libc.so, name: libc.so.6.0
1311 p
= strrchr(name
, '/');
1313 if (!memcmp(p
, el
->name
, strlen(el
->name
)))
1315 elf_search_and_load_file(el
->pcs
, name
, addr
, &el
->elf_info
);
1321 /******************************************************************
1324 * loads an ELF module and stores it in process' module list
1325 * Also, find module real name and load address from
1326 * the real loaded modules list in pcs address space
1328 struct module
* elf_load_module(struct process
* pcs
, const char* name
, DWORD addr
)
1332 TRACE("(%p %s)\n", pcs
, name
);
1334 el
.elf_info
.flags
= ELF_INFO_MODULE
;
1337 if (pcs
->dbg_hdr_addr
) /* we're debugging a life target */
1340 /* do only the lookup from the filename, not the path (as we lookup module name
1341 * in the process' loaded module list)
1343 el
.name
= strrchr(name
, '/');
1344 if (!el
.name
++) el
.name
= name
;
1347 if (!elf_enum_modules_internal(pcs
, elf_load_cb
, &el
))
1352 el
.ret
= elf_search_and_load_file(pcs
, name
, addr
, &el
.elf_info
);
1354 if (!el
.ret
) return NULL
;
1355 assert(el
.elf_info
.module
);
1356 return el
.elf_info
.module
;
1359 #else /* !__ELF__ */
1361 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1366 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1371 struct module
* elf_load_module(struct process
* pcs
, const char* name
, DWORD addr
)
1376 BOOL
elf_load_debug_info(struct module
* module
)
1380 #endif /* __ELF__ */