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) */
94 struct hash_table_elt ht_elt
;
95 const Elf32_Sym
* symp
;
103 THUNK_ORDINAL ordinal
;
104 unsigned long rva_start
;
105 unsigned long rva_end
;
108 /******************************************************************
111 * creating an internal hash table to ease use ELF symtab information lookup
113 static void elf_hash_symtab(const struct module
* module
, struct pool
* pool
,
114 struct hash_table
* ht_symtab
, const char* map_addr
,
115 const Elf32_Shdr
* symtab
, const Elf32_Shdr
* strtab
,
116 unsigned num_areas
, struct thunk_area
* thunks
)
121 const char* filename
= NULL
;
123 const Elf32_Sym
* symp
;
124 struct symtab_elt
* ste
;
126 symp
= (const Elf32_Sym
*)(map_addr
+ symtab
->sh_offset
);
127 nsym
= symtab
->sh_size
/ sizeof(*symp
);
128 strp
= (const char*)(map_addr
+ strtab
->sh_offset
);
130 for (j
= 0; j
< num_areas
; j
++)
131 thunks
[j
].rva_start
= thunks
[j
].rva_end
= 0;
133 for (i
= 0; i
< nsym
; i
++, symp
++)
135 /* Ignore certain types of entries which really aren't of that much
138 if (ELF32_ST_TYPE(symp
->st_info
) == STT_SECTION
|| symp
->st_shndx
== SHN_UNDEF
)
143 symname
= strp
+ symp
->st_name
;
145 if (ELF32_ST_TYPE(symp
->st_info
) == STT_FILE
)
150 for (j
= 0; j
< num_areas
; j
++)
152 if (!strcmp(symname
, thunks
[j
].symname
))
154 thunks
[j
].rva_start
= symp
->st_value
;
155 thunks
[j
].rva_end
= symp
->st_value
+ symp
->st_size
;
159 if (j
< num_areas
) continue;
161 /* FIXME: we don't need to handle them (GCC internals)
162 * Moreover, they screw up our symbol lookup :-/
164 if (symname
[0] == '.' && symname
[1] == 'L' && isdigit(symname
[2]))
167 ste
= pool_alloc(pool
, sizeof(*ste
));
168 /* GCC seems to emit, in some cases, a .<digit>+ suffix.
169 * This is used for static variable inside functions, so
170 * that we can have several such variables with same name in
171 * the same compilation unit
172 * We simply ignore that suffix when present (we also get rid
173 * of it in stabs parsing)
175 ptr
= symname
+ strlen(symname
) - 1;
176 ste
->ht_elt
.name
= symname
;
179 while (*ptr
>= '0' && *ptr
<= '9' && ptr
>= symname
) ptr
--;
180 if (ptr
> symname
&& *ptr
== '.')
182 char* n
= pool_alloc(pool
, ptr
- symname
+ 1);
183 memcpy(n
, symname
, ptr
- symname
+ 1);
184 n
[ptr
- symname
] = '\0';
185 ste
->ht_elt
.name
= n
;
189 ste
->filename
= filename
;
191 hash_table_add(ht_symtab
, &ste
->ht_elt
);
195 /******************************************************************
198 * lookup a symbol by name in our internal hash table for the symtab
200 static const Elf32_Sym
* elf_lookup_symtab(const struct module
* module
,
201 const struct hash_table
* ht_symtab
,
202 const char* name
, struct symt
* compiland
)
204 struct symtab_elt
* weak_result
= NULL
; /* without compiland name */
205 struct symtab_elt
* result
= NULL
;
206 struct hash_table_iter hti
;
207 struct symtab_elt
* ste
;
208 const char* compiland_name
;
209 const char* compiland_basename
;
212 /* we need weak match up (at least) when symbols of same name,
213 * defined several times in different compilation units,
214 * are merged in a single one (hence a different filename for c.u.)
218 compiland_name
= source_get(module
,
219 ((struct symt_compiland
*)compiland
)->source
);
220 compiland_basename
= strrchr(compiland_name
, '/');
221 if (!compiland_basename
++) compiland_basename
= compiland_name
;
223 else compiland_name
= compiland_basename
= NULL
;
225 hash_table_iter_init(ht_symtab
, &hti
, name
);
226 while ((ste
= hash_table_iter_up(&hti
)))
228 if (ste
->used
|| strcmp(ste
->ht_elt
.name
, name
)) continue;
231 if ((ste
->filename
&& !compiland_name
) || (!ste
->filename
&& compiland_name
))
233 if (ste
->filename
&& compiland_name
)
235 if (strcmp(ste
->filename
, compiland_name
))
237 base
= strrchr(ste
->filename
, '/');
238 if (!base
++) base
= ste
->filename
;
239 if (strcmp(base
, compiland_basename
)) continue;
244 FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n",
245 name
, compiland_name
, result
->filename
, result
->symp
->st_value
,
246 ste
->filename
, ste
->symp
->st_value
);
254 if (!result
&& !(result
= weak_result
))
256 FIXME("Couldn't find symbol %s.%s in symtab\n",
257 module
->module
.ModuleName
, name
);
263 /******************************************************************
264 * elf_finish_stabs_info
266 * - get any relevant information (address & size) from the bits we got from the
267 * stabs debugging information
269 static void elf_finish_stabs_info(struct module
* module
, struct hash_table
* symtab
)
271 struct hash_table_iter hti
;
274 const Elf32_Sym
* symp
;
276 hash_table_iter_init(&module
->ht_symbols
, &hti
, NULL
);
277 while ((ptr
= hash_table_iter_up(&hti
)))
279 sym
= GET_ENTRY(ptr
, struct symt_ht
, hash_elt
);
280 switch (sym
->symt
.tag
)
283 if (((struct symt_function
*)sym
)->address
!= module
->elf_info
->elf_addr
&&
284 ((struct symt_function
*)sym
)->size
)
288 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
289 ((struct symt_function
*)sym
)->container
);
292 ((struct symt_function
*)sym
)->address
= module
->elf_info
->elf_addr
+
294 ((struct symt_function
*)sym
)->size
= symp
->st_size
;
295 } else FIXME("Couldn't find %s\n", sym
->hash_elt
.name
);
298 switch (((struct symt_data
*)sym
)->kind
)
301 case DataIsFileStatic
:
302 if (((struct symt_data
*)sym
)->u
.address
!= module
->elf_info
->elf_addr
)
304 symp
= elf_lookup_symtab(module
, symtab
, sym
->hash_elt
.name
,
305 ((struct symt_data
*)sym
)->container
);
308 ((struct symt_data
*)sym
)->u
.address
= module
->elf_info
->elf_addr
+
310 ((struct symt_data
*)sym
)->kind
= (ELF32_ST_BIND(symp
->st_info
) == STB_LOCAL
) ?
311 DataIsFileStatic
: DataIsGlobal
;
318 FIXME("Unsupported tag %u\n", sym
->symt
.tag
);
322 /* since we may have changed some addresses & sizes, mark the module to be resorted */
323 module
->sortlist_valid
= FALSE
;
326 /******************************************************************
327 * elf_load_wine_thunks
329 * creating the thunk objects for a wine native DLL
331 static int elf_new_wine_thunks(struct module
* module
, struct hash_table
* ht_symtab
,
332 unsigned num_areas
, struct thunk_area
* thunks
)
335 struct symt_compiland
* compiland
= NULL
;
336 const char* compiland_name
= NULL
;
337 struct hash_table_iter hti
;
338 struct symtab_elt
* ste
;
342 hash_table_iter_init(ht_symtab
, &hti
, NULL
);
343 while ((ste
= hash_table_iter_up(&hti
)))
345 if (ste
->used
) continue;
347 /* FIXME: this is not a good idea anyway... we are creating several
348 * compiland objects for a same compilation unit
349 * We try to cache the last compiland used, but it's not enough
350 * (we should here only create compilands if they are not yet
353 if (!compiland_name
|| compiland_name
!= ste
->filename
)
354 compiland
= symt_new_compiland(module
,
355 compiland_name
= ste
->filename
);
357 addr
= module
->elf_info
->elf_addr
+ ste
->symp
->st_value
;
359 for (j
= 0; j
< num_areas
; j
++)
361 if (ste
->symp
->st_value
>= thunks
[j
].rva_start
&&
362 ste
->symp
->st_value
< thunks
[j
].rva_end
)
365 if (j
< num_areas
) /* thunk found */
367 symt_new_thunk(module
, compiland
, ste
->ht_elt
.name
, thunks
[j
].ordinal
,
368 addr
, ste
->symp
->st_size
);
374 idx
= symt_find_nearest(module
, addr
);
376 symt_get_info(&module
->addr_sorttab
[idx
]->symt
,
377 TI_GET_ADDRESS
, &ref_addr
);
378 if (idx
== -1 || addr
!= ref_addr
)
380 /* creating public symbols for all the ELF symbols which haven't been
381 * used yet (ie we have no debug information on them)
382 * That's the case, for example, of the .spec.c files
384 if (ELF32_ST_TYPE(ste
->symp
->st_info
) == STT_FUNC
)
386 symt_new_function(module
, compiland
, ste
->ht_elt
.name
,
387 addr
, ste
->symp
->st_size
, NULL
);
391 symt_new_global_variable(module
, compiland
, ste
->ht_elt
.name
,
392 ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
,
393 addr
, ste
->symp
->st_size
, NULL
);
395 /* FIXME: this is a hack !!!
396 * we are adding new symbols, but as we're parsing a symbol table
397 * (hopefully without duplicate symbols) we delay rebuilding the sorted
398 * module table until we're done with the symbol table
399 * Otherwise, as we intertwine symbols's add and lookup, performance
402 module
->sortlist_valid
= TRUE
;
404 else if (strcmp(ste
->ht_elt
.name
, module
->addr_sorttab
[idx
]->hash_elt
.name
))
407 DWORD xsize
= 0, kind
= -1;
409 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_ADDRESS
, &xaddr
);
410 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_LENGTH
, &xsize
);
411 symt_get_info(&module
->addr_sorttab
[idx
]->symt
, TI_GET_DATAKIND
, &kind
);
413 /* If none of symbols has a correct size, we consider they are both markers
414 * Hence, we can silence this warning
415 * Also, we check that we don't have two symbols, one local, the other
416 * global which is legal
418 if ((xsize
|| ste
->symp
->st_size
) &&
419 (kind
== (ELF32_ST_BIND(ste
->symp
->st_info
) == STB_LOCAL
) ? DataIsFileStatic
: DataIsGlobal
))
420 FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%08lx>\n",
421 module
->module
.ModuleName
,
422 ste
->ht_elt
.name
, addr
, ste
->symp
->st_size
,
423 module
->addr_sorttab
[idx
]->hash_elt
.name
,
424 wine_dbgstr_longlong(xaddr
), xsize
);
428 /* see comment above */
429 module
->sortlist_valid
= FALSE
;
433 /******************************************************************
434 * elf_new_public_symbols
436 * Creates a set of public symbols from an ELF symtab
438 static int elf_new_public_symbols(struct module
* module
, struct hash_table
* symtab
)
440 struct symt_compiland
* compiland
= NULL
;
441 const char* compiland_name
= NULL
;
442 struct hash_table_iter hti
;
443 struct symtab_elt
* ste
;
445 if (dbghelp_options
& SYMOPT_NO_PUBLICS
) return TRUE
;
447 /* FIXME: we're missing the ELF entry point here */
449 hash_table_iter_init(symtab
, &hti
, NULL
);
450 while ((ste
= hash_table_iter_up(&hti
)))
452 /* FIXME: this is not a good idea anyway... we are creating several
453 * compiland objects for a same compilation unit
454 * We try to cache the last compiland used, but it's not enough
455 * (we should here only create compilands if they are not yet
458 if (!compiland_name
|| compiland_name
!= ste
->filename
)
459 compiland
= symt_new_compiland(module
,
460 compiland_name
= ste
->filename
);
462 symt_new_public(module
, compiland
, ste
->ht_elt
.name
,
463 module
->elf_info
->elf_addr
+ ste
->symp
->st_value
,
464 ste
->symp
->st_size
, TRUE
/* FIXME */,
465 ELF32_ST_TYPE(ste
->symp
->st_info
) == STT_FUNC
);
470 /* Copyright (C) 1986 Gary S. Brown. Modified by Robert Shearman. You may use
471 the following calc_crc32 code or tables extracted from it, as desired without
474 /**********************************************************************\
475 |* Demonstration program to compute the 32-bit CRC used as the frame *|
476 |* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
477 |* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
478 |* protocol). The 32-bit FCS was added via the Federal Register, *|
479 |* 1 June 1982, p.23798. I presume but don't know for certain that *|
480 |* this polynomial is or will be included in CCITT V.41, which *|
481 |* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
482 |* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
483 |* errors by a factor of 10^-5 over 16-bit FCS. *|
484 \**********************************************************************/
486 /* First, the polynomial itself and its table of feedback terms. The */
488 /* 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 */
489 /* Note that we take it "backwards" and put the highest-order term in */
490 /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
491 /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
492 /* the MSB being 1. */
494 /* Note that the usual hardware shift register implementation, which */
495 /* is what we're using (we're merely optimizing it by doing eight-bit */
496 /* chunks at a time) shifts bits into the lowest-order term. In our */
497 /* implementation, that means shifting towards the right. Why do we */
498 /* do it this way? Because the calculated CRC must be transmitted in */
499 /* order from highest-order term to lowest-order term. UARTs transmit */
500 /* characters in order from LSB to MSB. By storing the CRC this way, */
501 /* we hand it to the UART in the order low-byte to high-byte; the UART */
502 /* sends each low-bit to hight-bit; and the result is transmission bit */
503 /* by bit from highest- to lowest-order term without requiring any bit */
504 /* shuffling on our part. Reception works similarly. */
506 /* The feedback terms table consists of 256, 32-bit entries. Notes: */
508 /* 1. The table can be generated at runtime if desired; code to do so */
509 /* is shown later. It might not be obvious, but the feedback */
510 /* terms simply represent the results of eight shift/xor opera- */
511 /* tions for all combinations of data and CRC register values. */
513 /* 2. The CRC accumulation logic is the same for all CRC polynomials, */
514 /* be they sixteen or thirty-two bits wide. You simply choose the */
515 /* appropriate table. Alternatively, because the table can be */
516 /* generated at runtime, you can start by generating the table for */
517 /* the polynomial in question and use exactly the same "updcrc", */
518 /* if your application needn't simultaneously handle two CRC */
519 /* polynomials. (Note, however, that XMODEM is strange.) */
521 /* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
522 /* of course, 32-bit entries work OK if the high 16 bits are zero. */
524 /* 4. The values must be right-shifted by eight bits by the "updcrc" */
525 /* logic; the shift must be unsigned (bring in zeroes). On some */
526 /* hardware you could probably optimize the shift in assembler by */
527 /* using byte-swap instructions. */
530 static DWORD
calc_crc32(const unsigned char *buf
, size_t len
)
532 #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
533 static const DWORD crc_32_tab
[] =
534 { /* CRC polynomial 0xedb88320 */
535 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
536 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
537 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
538 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
539 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
540 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
541 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
542 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
543 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
544 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
545 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
546 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
547 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
548 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
549 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
550 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
551 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
552 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
553 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
554 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
555 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
556 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
557 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
558 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
559 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
560 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
561 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
562 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
563 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
564 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
565 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
566 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
567 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
568 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
569 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
570 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
571 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
572 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
573 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
574 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
575 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
576 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
577 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
581 for(i
= 0; i
< len
; i
++)
582 crc
= UPDC32(buf
[i
], crc
);
588 /******************************************************************
589 * elf_load_debug_info_from_file
591 * Loads the symbolic information from ELF module stored in 'file'
592 * the module has been loaded at 'load_offset' address, so symbols' address
593 * relocation is performed. crc optionally points to the CRC of the debug file
596 * 0 if the file doesn't contain symbolic info (or this info cannot be
600 static BOOL
elf_load_debug_info_from_file(
601 struct module
* module
, const char* file
, struct pool
* pool
,
602 struct hash_table
* ht_symtab
, const DWORD
*crc
)
605 char* addr
= (char*)0xffffffff;
608 const Elf32_Ehdr
* ehptr
;
609 const Elf32_Shdr
* spnt
;
610 const char* shstrtab
;
612 int symtab_sect
, dynsym_sect
, stab_sect
, stabstr_sect
, debug_sect
, debuglink_sect
;
613 struct thunk_area thunks
[] =
615 {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE
, 0, 0}, /* inter DLL calls */
616 {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
617 {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
618 {"__wine_delay_load", THUNK_ORDINAL_LOAD
, 0, 0}, /* delayed inter DLL calls */
619 {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */
620 {"__wine_spec_thunk_data_16", -16, 0, 0}, /* 16 => 32 thunks */
621 {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */
622 {"__wine_spec_thunk_data_32", -32, 0, 0}, /* 32 => 16 thunks */
625 if (module
->type
!= DMT_ELF
|| !module
->elf_info
)
627 ERR("Bad elf module '%s'\n", module
->module
.LoadedImageName
);
632 /* check that the file exists, and that the module hasn't been loaded yet */
633 if (stat(file
, &statbuf
) == -1) goto leave
;
634 if (S_ISDIR(statbuf
.st_mode
)) goto leave
;
637 * Now open the file, so that we can mmap() it.
639 if ((fd
= open(file
, O_RDONLY
)) == -1) goto leave
;
642 * Now mmap() the file.
644 addr
= mmap(0, statbuf
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
645 if (addr
== (char*)0xffffffff) goto leave
;
647 if (crc
&& (*crc
!= calc_crc32(addr
, statbuf
.st_size
)))
649 ERR("Bad CRC for file %s\n", file
);
650 /* we don't tolerate mis-matched files */
655 * Next, we need to find a few of the internal ELF headers within
656 * this thing. We need the main executable header, and the section
659 ehptr
= (Elf32_Ehdr
*)addr
;
660 spnt
= (Elf32_Shdr
*)(addr
+ ehptr
->e_shoff
);
661 shstrtab
= (addr
+ spnt
[ehptr
->e_shstrndx
].sh_offset
);
663 symtab_sect
= dynsym_sect
= stab_sect
= stabstr_sect
= debug_sect
= debuglink_sect
= -1;
665 for (i
= 0; i
< ehptr
->e_shnum
; i
++)
667 if (strcmp(shstrtab
+ spnt
[i
].sh_name
, ".stab") == 0)
669 if (strcmp(shstrtab
+ spnt
[i
].sh_name
, ".stabstr") == 0)
671 if (strcmp(shstrtab
+ spnt
[i
].sh_name
, ".debug_info") == 0)
673 if (strcmp(shstrtab
+ spnt
[i
].sh_name
, ".gnu_debuglink") == 0)
675 if ((strcmp(shstrtab
+ spnt
[i
].sh_name
, ".symtab") == 0) &&
676 (spnt
[i
].sh_type
== SHT_SYMTAB
))
678 if ((strcmp(shstrtab
+ spnt
[i
].sh_name
, ".dynsym") == 0) &&
679 (spnt
[i
].sh_type
== SHT_DYNSYM
))
683 if (symtab_sect
== -1)
685 /* if we don't have a symtab but a dynsym, process the dynsym
686 * section instead. It'll contain less (relevant) information,
687 * but it'll be better than nothing
689 if (dynsym_sect
== -1) goto leave
;
690 symtab_sect
= dynsym_sect
;
693 module
->module
.SymType
= SymExport
;
695 /* create a hash table for the symtab */
696 elf_hash_symtab(module
, pool
, ht_symtab
, addr
,
697 spnt
+ symtab_sect
, spnt
+ spnt
[symtab_sect
].sh_link
,
698 sizeof(thunks
) / sizeof(thunks
[0]), thunks
);
700 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
702 if (stab_sect
!= -1 && stabstr_sect
!= -1)
704 /* OK, now just parse all of the stabs. */
705 ret
= stabs_parse(module
, module
->elf_info
->elf_addr
,
706 addr
+ spnt
[stab_sect
].sh_offset
,
707 spnt
[stab_sect
].sh_size
,
708 addr
+ spnt
[stabstr_sect
].sh_offset
,
709 spnt
[stabstr_sect
].sh_size
);
712 WARN("Couldn't read correctly read stabs\n");
715 /* and fill in the missing information for stabs */
716 elf_finish_stabs_info(module
, ht_symtab
);
718 else if (debug_sect
!= -1)
720 /* Dwarf 2 debug information */
721 FIXME("Unsupported Dwarf2 information for %s\n", module
->module
.ModuleName
);
723 else if (debuglink_sect
!= -1)
726 const char * file
= (const char *)(addr
+ spnt
[debuglink_sect
].sh_offset
);
727 /* crc is stored after the null terminated file string rounded
728 * up to the next 4 byte boundary */
729 crc
= *(const DWORD
*)(file
+ ((DWORD_PTR
)(strlen(file
) + 4) & ~3));
730 ret
= elf_load_debug_info_from_file(module
, file
, pool
, ht_symtab
, &crc
);
732 WARN("Couldn't load linked debug file %s\n", file
);
735 if (strstr(module
->module
.ModuleName
, "<elf>") ||
736 !strcmp(module
->module
.ModuleName
, "<wine-loader>"))
738 /* add the thunks for native libraries */
739 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
740 elf_new_wine_thunks(module
, ht_symtab
,
741 sizeof(thunks
) / sizeof(thunks
[0]), thunks
);
743 /* add all the public symbols from symtab */
744 if (elf_new_public_symbols(module
, ht_symtab
) && !ret
) ret
= TRUE
;
747 if (addr
!= (char*)0xffffffff) munmap(addr
, statbuf
.st_size
);
748 if (fd
!= -1) close(fd
);
753 /******************************************************************
754 * elf_load_debug_info
756 * Loads ELF debugging information from the module image file.
758 BOOL
elf_load_debug_info(struct module
* module
)
762 struct hash_table ht_symtab
;
764 pool_init(&pool
, 65536);
765 hash_table_init(&pool
, &ht_symtab
, 256);
767 ret
= elf_load_debug_info_from_file(module
,
768 module
->module
.LoadedImageName
, &pool
, &ht_symtab
, NULL
);
776 /******************************************************************
778 * returns true iff the section tag is valid
780 static unsigned is_dt_flag_valid(unsigned d_tag
)
786 #define DT_EXTRANUM 0
788 return (d_tag
>= 0 && d_tag
< DT_NUM
+ DT_PROCNUM
+ DT_EXTRANUM
)
789 #if defined(DT_LOOS) && defined(DT_HIOS)
790 || (d_tag
>= DT_LOOS
&& d_tag
< DT_HIOS
)
792 #if defined(DT_LOPROC) && defined(DT_HIPROC)
793 || (d_tag
>= DT_LOPROC
&& d_tag
< DT_HIPROC
)
798 /******************************************************************
801 * Loads the information for ELF module stored in 'filename'
802 * the module has been loaded at 'load_offset' address
804 * -1 if the file cannot be found/opened
805 * 0 if the file doesn't contain symbolic info (or this info cannot be
809 static BOOL
elf_load_file(struct process
* pcs
, const char* filename
,
810 unsigned long load_offset
, struct elf_info
* elf_info
)
812 static const BYTE elf_signature
[4] = { ELFMAG0
, ELFMAG1
, ELFMAG2
, ELFMAG3
};
814 const char* addr
= (char*)0xffffffff;
817 const Elf32_Ehdr
* ehptr
;
818 const Elf32_Shdr
* spnt
;
819 const Elf32_Phdr
* ppnt
;
820 const char* shstrtab
;
823 unsigned tmp
, page_mask
= getpagesize() - 1;
825 TRACE("Processing elf file '%s' at %08lx\n", filename
, load_offset
);
827 /* check that the file exists, and that the module hasn't been loaded yet */
828 if (stat(filename
, &statbuf
) == -1) goto leave
;
830 /* Now open the file, so that we can mmap() it. */
831 if ((fd
= open(filename
, O_RDONLY
)) == -1) goto leave
;
833 /* Now mmap() the file. */
834 addr
= mmap(0, statbuf
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
835 if (addr
== (char*)-1) goto leave
;
837 /* Next, we need to find a few of the internal ELF headers within
838 * this thing. We need the main executable header, and the section
841 ehptr
= (const Elf32_Ehdr
*)addr
;
842 if (memcmp(ehptr
->e_ident
, elf_signature
, sizeof(elf_signature
))) goto leave
;
844 spnt
= (const Elf32_Shdr
*)(addr
+ ehptr
->e_shoff
);
845 shstrtab
= (addr
+ spnt
[ehptr
->e_shstrndx
].sh_offset
);
847 /* grab size of module once loaded in memory */
848 ppnt
= (const Elf32_Phdr
*)(addr
+ ehptr
->e_phoff
);
849 size
= 0; start
= ~0L;
851 for (i
= 0; i
< ehptr
->e_phnum
; i
++)
853 if (ppnt
[i
].p_type
== PT_LOAD
)
855 tmp
= (ppnt
[i
].p_vaddr
+ ppnt
[i
].p_memsz
+ page_mask
) & ~page_mask
;
856 if (size
< tmp
) size
= tmp
;
857 if (ppnt
[i
].p_vaddr
< start
) start
= ppnt
[i
].p_vaddr
;
861 /* if non relocatable ELF, then remove fixed address from computation
862 * otherwise, all addresses are zero based and start has no effect
865 if (!start
&& !load_offset
)
866 ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n",
868 if (start
&& load_offset
)
870 WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. "
871 "Assuming load address is corrupt\n", filename
, load_offset
);
875 if (elf_info
->flags
& ELF_INFO_DEBUG_HEADER
)
877 for (i
= 0; i
< ehptr
->e_shnum
; i
++)
879 if (strcmp(shstrtab
+ spnt
[i
].sh_name
, ".dynamic") == 0 &&
880 spnt
[i
].sh_type
== SHT_DYNAMIC
)
883 char* ptr
= (char*)spnt
[i
].sh_addr
;
888 if (!ReadProcessMemory(pcs
->handle
, ptr
, &dyn
, sizeof(dyn
), &len
) ||
889 len
!= sizeof(dyn
) || !is_dt_flag_valid(dyn
.d_tag
))
892 } while (dyn
.d_tag
!= DT_DEBUG
&& dyn
.d_tag
!= DT_NULL
);
893 if (dyn
.d_tag
== DT_NULL
) goto leave
;
894 elf_info
->dbg_hdr_addr
= dyn
.d_un
.d_ptr
;
899 if (elf_info
->flags
& ELF_INFO_MODULE
)
901 struct elf_module_info
*elf_module_info
=
902 HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info
));
903 if (!elf_module_info
) goto leave
;
904 elf_info
->module
= module_new(pcs
, filename
, DMT_ELF
,
905 (load_offset
) ? load_offset
: start
,
907 if (!elf_info
->module
)
909 HeapFree(GetProcessHeap(), 0, elf_module_info
);
912 elf_info
->module
->elf_info
= elf_module_info
;
913 elf_info
->module
->elf_info
->elf_addr
= load_offset
;
915 if (dbghelp_options
& SYMOPT_DEFERRED_LOADS
)
917 elf_info
->module
->module
.SymType
= SymDeferred
;
920 else ret
= elf_load_debug_info(elf_info
->module
);
922 elf_info
->module
->elf_info
->elf_mark
= 1;
923 elf_info
->module
->elf_info
->elf_loader
= 0;
927 if (addr
!= (char*)0xffffffff) munmap((void*)addr
, statbuf
.st_size
);
928 if (fd
!= -1) close(fd
);
933 /******************************************************************
934 * elf_load_file_from_path
935 * tries to load an ELF file from a set of paths (separated by ':')
937 static BOOL
elf_load_file_from_path(HANDLE hProcess
,
938 const char* filename
,
939 unsigned long load_offset
,
941 struct elf_info
* elf_info
)
947 if (!path
) return FALSE
;
949 paths
= strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path
) + 1), path
);
950 for (s
= paths
; s
&& *s
; s
= (t
) ? (t
+1) : NULL
)
954 fn
= HeapAlloc(GetProcessHeap(), 0, strlen(filename
) + 1 + strlen(s
) + 1);
958 strcat(fn
, filename
);
959 ret
= elf_load_file(hProcess
, fn
, load_offset
, elf_info
);
960 HeapFree(GetProcessHeap(), 0, fn
);
962 s
= (t
) ? (t
+1) : NULL
;
965 HeapFree(GetProcessHeap(), 0, paths
);
969 /******************************************************************
970 * elf_search_and_load_file
972 * lookup a file in standard ELF locations, and if found, load it
974 static BOOL
elf_search_and_load_file(struct process
* pcs
, const char* filename
,
975 unsigned long load_offset
,
976 struct elf_info
* elf_info
)
979 struct module
* module
;
981 if (filename
== NULL
|| *filename
== '\0') return FALSE
;
982 if ((module
= module_find_by_name(pcs
, filename
, DMT_ELF
)))
984 elf_info
->module
= module
;
985 module
->elf_info
->elf_mark
= 1;
986 return module
->module
.SymType
;
989 if (strstr(filename
, "libstdc++")) return FALSE
; /* We know we can't do it */
990 ret
= elf_load_file(pcs
, filename
, load_offset
, elf_info
);
991 /* if relative pathname, try some absolute base dirs */
992 if (!ret
&& !strchr(filename
, '/'))
994 ret
= elf_load_file_from_path(pcs
, filename
, load_offset
,
995 getenv("PATH"), elf_info
) ||
996 elf_load_file_from_path(pcs
, filename
, load_offset
,
997 getenv("LD_LIBRARY_PATH"), elf_info
) ||
998 elf_load_file_from_path(pcs
, filename
, load_offset
,
999 getenv("WINEDLLPATH"), elf_info
);
1005 /******************************************************************
1006 * elf_synchronize_module_list
1008 * this functions rescans the debuggee module's list and synchronizes it with
1009 * the one from 'pcs', ie:
1010 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1011 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1013 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1015 struct r_debug dbg_hdr
;
1019 struct elf_info elf_info
;
1020 struct module
* module
;
1022 if (!pcs
->dbg_hdr_addr
||
1023 !ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
,
1024 &dbg_hdr
, sizeof(dbg_hdr
), NULL
))
1027 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1029 if (module
->type
== DMT_ELF
) module
->elf_info
->elf_mark
= 0;
1032 elf_info
.flags
= ELF_INFO_MODULE
;
1033 /* Now walk the linked list. In all known ELF implementations,
1034 * the dynamic loader maintains this linked list for us. In some
1035 * cases the first entry doesn't appear with a name, in other cases it
1038 for (lm_addr
= (void*)dbg_hdr
.r_map
; lm_addr
; lm_addr
= (void*)lm
.l_next
)
1040 if (!ReadProcessMemory(pcs
->handle
, lm_addr
, &lm
, sizeof(lm
), NULL
))
1043 if (lm
.l_prev
!= NULL
&& /* skip first entry, normally debuggee itself */
1044 lm
.l_name
!= NULL
&&
1045 ReadProcessMemory(pcs
->handle
, lm
.l_name
, bufstr
, sizeof(bufstr
), NULL
))
1047 bufstr
[sizeof(bufstr
) - 1] = '\0';
1048 elf_search_and_load_file(pcs
, bufstr
, (unsigned long)lm
.l_addr
,
1053 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1055 if (module
->type
== DMT_ELF
&& !module
->elf_info
->elf_mark
&&
1056 !module
->elf_info
->elf_loader
)
1058 module_remove(pcs
, module
);
1059 /* restart all over */
1060 module
= pcs
->lmodules
;
1066 /******************************************************************
1067 * elf_read_wine_loader_dbg_info
1069 * Try to find a decent wine executable which could have loaded the debuggee
1071 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1074 struct elf_info elf_info
;
1077 elf_info
.flags
= ELF_INFO_DEBUG_HEADER
| ELF_INFO_MODULE
;
1078 /* All binaries are loaded with WINELOADER (if run from tree) or by the
1079 * main executable (either wine-kthread or wine-pthread)
1080 * Note: the heuristic use to know whether we need to load wine-pthread or
1081 * wine-kthread is not 100% safe
1083 if ((ptr
= getenv("WINELOADER")))
1084 ret
= elf_search_and_load_file(pcs
, ptr
, 0, &elf_info
);
1087 ret
= elf_search_and_load_file(pcs
, "wine-kthread", 0, &elf_info
) ||
1088 elf_search_and_load_file(pcs
, "wine-pthread", 0, &elf_info
);
1090 if (!ret
) return FALSE
;
1091 elf_info
.module
->elf_info
->elf_loader
= 1;
1092 strcpy(elf_info
.module
->module
.ModuleName
, "<wine-loader>");
1093 return (pcs
->dbg_hdr_addr
= elf_info
.dbg_hdr_addr
) != 0;
1096 /******************************************************************
1099 * loads an ELF module and stores it in process' module list
1100 * Also, find module real name and load address from
1101 * the real loaded modules list in pcs address space
1103 struct module
* elf_load_module(struct process
* pcs
, const char* name
)
1105 struct elf_info elf_info
;
1109 struct r_debug dbg_hdr
;
1114 TRACE("(%p %s)\n", pcs
, name
);
1116 elf_info
.flags
= ELF_INFO_MODULE
;
1118 /* do only the lookup from the filename, not the path (as we lookup module name
1119 * in the process' loaded module list)
1121 xname
= strrchr(name
, '/');
1122 if (!xname
++) xname
= name
;
1124 if (!ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
, &dbg_hdr
, sizeof(dbg_hdr
), NULL
))
1127 for (lm_addr
= (void*)dbg_hdr
.r_map
; lm_addr
; lm_addr
= (void*)lm
.l_next
)
1129 if (!ReadProcessMemory(pcs
->handle
, lm_addr
, &lm
, sizeof(lm
), NULL
))
1132 if (lm
.l_prev
!= NULL
&& /* skip first entry, normally debuggee itself */
1133 lm
.l_name
!= NULL
&&
1134 ReadProcessMemory(pcs
->handle
, lm
.l_name
, bufstr
, sizeof(bufstr
), NULL
))
1136 bufstr
[sizeof(bufstr
) - 1] = '\0';
1137 /* memcmp is needed for matches when bufstr contains also version information
1138 * name: libc.so, bufstr: libc.so.6.0
1140 p
= strrchr(bufstr
, '/');
1141 if (!p
++) p
= bufstr
;
1142 if (!memcmp(p
, xname
, strlen(xname
)))
1144 ret
= elf_search_and_load_file(pcs
, bufstr
,
1145 (unsigned long)lm
.l_addr
, &elf_info
);
1150 if (!lm_addr
|| !ret
) return NULL
;
1151 assert(elf_info
.module
);
1152 return elf_info
.module
;
1155 #else /* !__ELF__ */
1157 BOOL
elf_synchronize_module_list(struct process
* pcs
)
1162 BOOL
elf_read_wine_loader_dbg_info(struct process
* pcs
)
1167 struct module
* elf_load_module(struct process
* pcs
, const char* name
)
1172 BOOL
elf_load_debug_info(struct module
* module
)
1176 #endif /* __ELF__ */