2 * File macho_module.c - processing of Mach-O files
3 * Originally based on elf_module.c
5 * Copyright (C) 1996, Eric Youngdale.
6 * 1999-2007 Eric Pouech
7 * 2009 Ken Thomases, CodeWeavers Inc.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
27 #include "dbghelp_private.h"
29 #ifdef HAVE_MACH_O_LOADER_H
33 #ifdef HAVE_SYS_STAT_H
34 # include <sys/stat.h>
36 #ifdef HAVE_SYS_MMAN_H
37 # include <sys/mman.h>
40 #include <mach-o/fat.h>
41 #include <mach-o/loader.h>
42 #include <mach-o/nlist.h>
44 #ifdef HAVE_MACH_O_DYLD_IMAGES_H
45 #include <mach-o/dyld_images.h>
47 struct dyld_image_info
{
48 const struct mach_header
*imageLoadAddress
;
49 const char *imageFilePath
;
50 uintptr_t imageFileModDate
;
53 struct dyld_all_image_infos
{
55 uint32_t infoArrayCount
;
56 const struct dyld_image_info
*infoArray
;
58 int processDetachedFromSharedRegion
;
63 #include "wine/library.h"
64 #include "wine/debug.h"
66 #ifdef WORDS_BIGENDIAN
67 #define swap_ulong_be_to_host(n) (n)
69 #define swap_ulong_be_to_host(n) (RtlUlongByteSwap(n))
72 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_macho
);
75 struct macho_module_info
77 unsigned long load_addr
;
78 unsigned short in_use
: 1,
82 #define MACHO_INFO_DEBUG_HEADER 0x0001
83 #define MACHO_INFO_MODULE 0x0002
84 #define MACHO_INFO_NAME 0x0004
88 unsigned flags
; /* IN one (or several) of the MACHO_INFO constants */
89 unsigned long dbg_hdr_addr
; /* OUT address of debug header (if MACHO_INFO_DEBUG_HEADER is set) */
90 struct module
* module
; /* OUT loaded module (if MACHO_INFO_MODULE is set) */
91 const WCHAR
* module_name
; /* OUT found module name (if MACHO_INFO_NAME is set) */
94 /* structure holding information while handling a Mach-O image */
95 #define BITS_PER_ULONG (sizeof(ULONG) * 8)
96 #define ULONGS_FOR_BITS(nbits) (((nbits) + BITS_PER_ULONG - 1) / BITS_PER_ULONG)
99 /* A copy of the Mach-O header for an individual architecture. */
100 struct mach_header mach_header
;
102 /* The mapped load commands. */
103 const struct load_command
* load_commands
;
105 /* The portion of the file which is this architecture. mach_header was
106 * read from arch_offset. */
107 unsigned arch_offset
;
110 /* The range of address space covered by all segments. */
114 /* Map of which sections contain code. Sections are accessed using 1-based
115 * index. Bit 0 of this bitset indicates if the bitset has been initialized. */
116 RTL_BITMAP sect_is_code
;
117 ULONG sect_is_code_buff
[ULONGS_FOR_BITS(MAX_SECT
+ 1)];
123 static void macho_unmap_file(struct macho_file_map
* fmap
);
125 /******************************************************************
128 * For a range (offset & length) of a single architecture within
129 * a Mach-O file, calculate the page-aligned range of the whole file
130 * that encompasses it. For a fat binary, the architecture will
131 * itself be offset within the file, so take that into account.
133 static void macho_calc_range(const struct macho_file_map
* fmap
, unsigned offset
,
134 unsigned len
, unsigned* out_aligned_offset
,
135 unsigned* out_aligned_end
, unsigned* out_aligned_len
,
136 unsigned* out_misalign
)
138 unsigned pagemask
= sysconf( _SC_PAGESIZE
) - 1;
139 unsigned file_offset
, misalign
;
141 file_offset
= fmap
->arch_offset
+ offset
;
142 misalign
= file_offset
& pagemask
;
143 *out_aligned_offset
= file_offset
- misalign
;
144 *out_aligned_end
= (file_offset
+ len
+ pagemask
) & ~pagemask
;
146 *out_aligned_len
= *out_aligned_end
- *out_aligned_offset
;
148 *out_misalign
= misalign
;
151 /******************************************************************
154 * Maps a range (offset, length in bytes) from a Mach-O file into memory
156 static const char* macho_map_range(const struct macho_file_map
* fmap
, unsigned offset
, unsigned len
)
158 unsigned misalign
, aligned_offset
, aligned_map_end
, map_size
;
159 const void* aligned_ptr
;
161 TRACE("(%p/%d, 0x%08x, 0x%08x)\n", fmap
, fmap
->fd
, offset
, len
);
163 macho_calc_range(fmap
, offset
, len
, &aligned_offset
, &aligned_map_end
,
164 &map_size
, &misalign
);
166 aligned_ptr
= mmap(NULL
, map_size
, PROT_READ
, MAP_PRIVATE
, fmap
->fd
, aligned_offset
);
168 TRACE("Mapped (0x%08x - 0x%08x) to %p\n", aligned_offset
, aligned_map_end
, aligned_ptr
);
170 if (aligned_ptr
== MAP_FAILED
) return MACHO_NO_MAP
;
171 return (const char*)aligned_ptr
+ misalign
;
174 /******************************************************************
177 * Unmaps a range (offset, length in bytes) of a Mach-O file from memory
179 static void macho_unmap_range(const void** mapped
, const struct macho_file_map
* fmap
,
180 unsigned offset
, unsigned len
)
182 TRACE("(%p, %p/%d, 0x%08x, 0x%08x)\n", mapped
, fmap
, fmap
->fd
, offset
, len
);
184 if (mapped
&& *mapped
!= MACHO_NO_MAP
)
186 unsigned misalign
, aligned_offset
, aligned_map_end
, map_size
;
189 macho_calc_range(fmap
, offset
, len
, &aligned_offset
, &aligned_map_end
,
190 &map_size
, &misalign
);
192 aligned_ptr
= (char*)*mapped
- misalign
;
193 if (munmap(aligned_ptr
, map_size
) < 0)
194 WARN("Couldn't unmap the range\n");
195 TRACE("Unmapped (0x%08x - 0x%08x) from %p - %p\n", aligned_offset
, aligned_map_end
, aligned_ptr
, (char*)aligned_ptr
+ map_size
);
196 *mapped
= MACHO_NO_MAP
;
200 /******************************************************************
203 * Maps two ranges (offset, length in bytes) from a Mach-O file
204 * into memory. If the two ranges overlap, use one mmap so that
205 * the munmap doesn't fragment the mapping.
207 static BOOL
macho_map_ranges(const struct macho_file_map
* fmap
,
208 unsigned offset1
, unsigned len1
,
209 unsigned offset2
, unsigned len2
,
210 const void** mapped1
, const void** mapped2
)
212 unsigned aligned_offset1
, aligned_map_end1
;
213 unsigned aligned_offset2
, aligned_map_end2
;
215 TRACE("(%p/%d, 0x%08x, 0x%08x, 0x%08x, 0x%08x, %p, %p)\n", fmap
, fmap
->fd
,
216 offset1
, len1
, offset2
, len2
, mapped1
, mapped2
);
218 macho_calc_range(fmap
, offset1
, len1
, &aligned_offset1
, &aligned_map_end1
, NULL
, NULL
);
219 macho_calc_range(fmap
, offset2
, len2
, &aligned_offset2
, &aligned_map_end2
, NULL
, NULL
);
221 if (aligned_map_end1
< aligned_offset2
|| aligned_map_end2
< aligned_offset1
)
223 *mapped1
= macho_map_range(fmap
, offset1
, len1
);
224 if (*mapped1
!= MACHO_NO_MAP
)
226 *mapped2
= macho_map_range(fmap
, offset2
, len2
);
227 if (*mapped2
== MACHO_NO_MAP
)
228 macho_unmap_range(mapped1
, fmap
, offset1
, len1
);
233 if (offset1
< offset2
)
235 *mapped1
= macho_map_range(fmap
, offset1
, offset2
+ len2
- offset1
);
236 if (*mapped1
!= MACHO_NO_MAP
)
237 *mapped2
= (const char*)*mapped1
+ offset2
- offset1
;
241 *mapped2
= macho_map_range(fmap
, offset2
, offset1
+ len1
- offset2
);
242 if (*mapped2
!= MACHO_NO_MAP
)
243 *mapped1
= (const char*)*mapped2
+ offset1
- offset2
;
247 TRACE(" => %p, %p\n", *mapped1
, *mapped2
);
249 return (*mapped1
!= MACHO_NO_MAP
) && (*mapped2
!= MACHO_NO_MAP
);
252 /******************************************************************
255 * Unmaps two ranges (offset, length in bytes) of a Mach-O file
256 * from memory. Use for ranges which were mapped by
259 static void macho_unmap_ranges(const struct macho_file_map
* fmap
,
260 unsigned offset1
, unsigned len1
,
261 unsigned offset2
, unsigned len2
,
262 const void** mapped1
, const void** mapped2
)
264 unsigned aligned_offset1
, aligned_map_end1
;
265 unsigned aligned_offset2
, aligned_map_end2
;
267 TRACE("(%p/%d, 0x%08x, 0x%08x, 0x%08x, 0x%08x, %p/%p, %p/%p)\n", fmap
, fmap
->fd
,
268 offset1
, len1
, offset2
, len2
, mapped1
, *mapped1
, mapped2
, *mapped2
);
270 macho_calc_range(fmap
, offset1
, len1
, &aligned_offset1
, &aligned_map_end1
, NULL
, NULL
);
271 macho_calc_range(fmap
, offset2
, len2
, &aligned_offset2
, &aligned_map_end2
, NULL
, NULL
);
273 if (aligned_map_end1
< aligned_offset2
|| aligned_map_end2
< aligned_offset1
)
275 macho_unmap_range(mapped1
, fmap
, offset1
, len1
);
276 macho_unmap_range(mapped2
, fmap
, offset2
, len2
);
280 if (offset1
< offset2
)
282 macho_unmap_range(mapped1
, fmap
, offset1
, offset2
+ len2
- offset1
);
283 *mapped2
= MACHO_NO_MAP
;
287 macho_unmap_range(mapped2
, fmap
, offset2
, offset1
+ len1
- offset2
);
288 *mapped1
= MACHO_NO_MAP
;
293 /******************************************************************
294 * macho_map_load_commands
296 * Maps the load commands from a Mach-O file into memory
298 static const struct load_command
* macho_map_load_commands(struct macho_file_map
* fmap
)
300 if (fmap
->load_commands
== MACHO_NO_MAP
)
302 fmap
->load_commands
= (const struct load_command
*) macho_map_range(
303 fmap
, sizeof(fmap
->mach_header
), fmap
->mach_header
.sizeofcmds
);
304 TRACE("Mapped load commands: %p\n", fmap
->load_commands
);
307 return fmap
->load_commands
;
310 /******************************************************************
311 * macho_unmap_load_commands
313 * Unmaps the load commands of a Mach-O file from memory
315 static void macho_unmap_load_commands(struct macho_file_map
* fmap
)
317 if (fmap
->load_commands
!= MACHO_NO_MAP
)
319 TRACE("Unmapping load commands: %p\n", fmap
->load_commands
);
320 macho_unmap_range((const void**)&fmap
->load_commands
, fmap
,
321 sizeof(fmap
->mach_header
), fmap
->mach_header
.sizeofcmds
);
325 /******************************************************************
326 * macho_next_load_command
328 * Advance to the next load command
330 static const struct load_command
* macho_next_load_command(const struct load_command
* lc
)
332 return (const struct load_command
*)((const char*)lc
+ lc
->cmdsize
);
335 /******************************************************************
336 * macho_enum_load_commands
338 * Enumerates the load commands for a Mach-O file, selecting by
339 * the command type, calling a callback for each. If the callback
340 * returns <0, that indicates an error. If it returns >0, that means
341 * it's not interested in getting any more load commands.
342 * If this function returns <0, that's an error produced by the
343 * callback. If >=0, that's the count of load commands successfully
346 static int macho_enum_load_commands(struct macho_file_map
* fmap
, unsigned cmd
,
347 int (*cb
)(struct macho_file_map
*, const struct load_command
*, void*),
350 const struct load_command
* lc
;
354 TRACE("(%p/%d, %u, %p, %p)\n", fmap
, fmap
->fd
, cmd
, cb
, user
);
356 if ((lc
= macho_map_load_commands(fmap
)) == MACHO_NO_MAP
) return -1;
358 TRACE("%d total commands\n", fmap
->mach_header
.ncmds
);
360 for (i
= 0; i
< fmap
->mach_header
.ncmds
; i
++, lc
= macho_next_load_command(lc
))
364 if (cmd
&& cmd
!= lc
->cmd
) continue;
367 result
= cb(fmap
, lc
, user
);
368 TRACE("load_command[%d] (%p), cmd %u; callback => %d\n", i
, lc
, lc
->cmd
, result
);
369 if (result
) return (result
< 0) ? result
: count
;
375 /******************************************************************
376 * macho_accum_segs_range
378 * Callback for macho_enum_load_commands. Accumulates the address
379 * range covered by the segments of a Mach-O file. All commands
380 * are expected to be of LC_SEGMENT type.
382 static int macho_accum_segs_range(struct macho_file_map
* fmap
,
383 const struct load_command
* lc
, void* user
)
385 const struct segment_command
* sc
= (const struct segment_command
*)lc
;
386 unsigned tmp
, page_mask
= sysconf( _SC_PAGESIZE
) - 1;
388 TRACE("(%p/%d, %p, %p) before: 0x%08x - 0x%08x\n", fmap
, fmap
->fd
, lc
, user
,
389 (unsigned)fmap
->segs_start
, (unsigned)fmap
->segs_size
);
390 TRACE("Segment command vm: 0x%08x - 0x%08x\n", (unsigned)sc
->vmaddr
,
391 (unsigned)sc
->vmaddr
+ sc
->vmsize
);
393 if (!strncmp(sc
->segname
, "WINE_", 5))
395 TRACE("Ignoring special Wine segment %s\n", debugstr_an(sc
->segname
, sizeof(sc
->segname
)));
399 /* If this segment starts before previously-known earliest, record
401 if (sc
->vmaddr
< fmap
->segs_start
)
402 fmap
->segs_start
= sc
->vmaddr
;
404 /* If this segment extends beyond previously-known furthest, record
406 tmp
= (sc
->vmaddr
+ sc
->vmsize
+ page_mask
) & ~page_mask
;
407 if (fmap
->segs_size
< tmp
) fmap
->segs_size
= tmp
;
409 TRACE("after: 0x%08x - 0x%08x\n", (unsigned)fmap
->segs_start
, (unsigned)fmap
->segs_size
);
414 /******************************************************************
417 * Maps a Mach-O file into memory (and checks it's a real Mach-O file)
419 static BOOL
macho_map_file(const WCHAR
* filenameW
, struct macho_file_map
* fmap
)
421 struct fat_header fat_header
;
428 TRACE("(%s, %p)\n", debugstr_w(filenameW
), fmap
);
431 fmap
->load_commands
= MACHO_NO_MAP
;
432 RtlInitializeBitMap(&fmap
->sect_is_code
, fmap
->sect_is_code_buff
, MAX_SECT
+ 1);
434 len
= WideCharToMultiByte(CP_UNIXCP
, 0, filenameW
, -1, NULL
, 0, NULL
, NULL
);
435 if (!(filename
= HeapAlloc(GetProcessHeap(), 0, len
))) return FALSE
;
436 WideCharToMultiByte(CP_UNIXCP
, 0, filenameW
, -1, filename
, len
, NULL
, NULL
);
438 /* check that the file exists */
439 if (stat(filename
, &statbuf
) == -1 || S_ISDIR(statbuf
.st_mode
)) goto done
;
441 /* Now open the file, so that we can mmap() it. */
442 if ((fmap
->fd
= open(filename
, O_RDONLY
)) == -1) goto done
;
444 if (read(fmap
->fd
, &fat_header
, sizeof(fat_header
)) != sizeof(fat_header
))
446 TRACE("... got possible fat header\n");
448 /* Fat header is always in big-endian order. */
449 if (swap_ulong_be_to_host(fat_header
.magic
) == FAT_MAGIC
)
451 int narch
= swap_ulong_be_to_host(fat_header
.nfat_arch
);
452 for (i
= 0; i
< narch
; i
++)
454 struct fat_arch fat_arch
;
455 if (read(fmap
->fd
, &fat_arch
, sizeof(fat_arch
)) != sizeof(fat_arch
))
457 if (swap_ulong_be_to_host(fat_arch
.cputype
) == CPU_TYPE_X86
)
459 fmap
->arch_offset
= swap_ulong_be_to_host(fat_arch
.offset
);
460 fmap
->arch_size
= swap_ulong_be_to_host(fat_arch
.size
);
464 if (i
>= narch
) goto done
;
465 TRACE("... found x86 arch\n");
469 fmap
->arch_offset
= 0;
470 fmap
->arch_size
= statbuf
.st_size
;
471 TRACE("... not a fat header\n");
474 /* Individual architecture (standalone or within a fat file) is in its native byte order. */
475 lseek(fmap
->fd
, fmap
->arch_offset
, SEEK_SET
);
476 if (read(fmap
->fd
, &fmap
->mach_header
, sizeof(fmap
->mach_header
)) != sizeof(fmap
->mach_header
))
478 TRACE("... got possible Mach header\n");
479 /* and check for a Mach-O header */
480 if (fmap
->mach_header
.magic
!= MH_MAGIC
||
481 fmap
->mach_header
.cputype
!= CPU_TYPE_X86
) goto done
;
482 /* Make sure the file type is one of the ones we expect. */
483 switch (fmap
->mach_header
.filetype
)
493 TRACE("... verified Mach x86 header\n");
496 fmap
->segs_start
= ~0L;
498 if (macho_enum_load_commands(fmap
, LC_SEGMENT
, macho_accum_segs_range
, NULL
) < 0)
501 fmap
->segs_size
-= fmap
->segs_start
;
502 TRACE("segs_start: 0x%08x, segs_size: 0x%08x\n", (unsigned)fmap
->segs_start
,
503 (unsigned)fmap
->segs_size
);
508 macho_unmap_file(fmap
);
509 HeapFree(GetProcessHeap(), 0, filename
);
513 /******************************************************************
516 * Unmaps a Mach-O file from memory (previously mapped with macho_map_file)
518 static void macho_unmap_file(struct macho_file_map
* fmap
)
520 TRACE("(%p/%d)\n", fmap
, fmap
->fd
);
523 macho_unmap_load_commands(fmap
);
529 /******************************************************************
530 * macho_fill_sect_is_code
532 * Callback for macho_enum_load_commands. Determines which segments
533 * of a Mach-O file contain code. All commands are expected to be
534 * of LC_SEGMENT type.
536 static int macho_fill_sect_is_code(struct macho_file_map
* fmap
,
537 const struct load_command
* lc
, void* user
)
539 const struct segment_command
* sc
= (const struct segment_command
*)lc
;
540 const struct section
* sections
;
544 TRACE("(%p/%d, %p, %p/%d) scanning %u sections\n", fmap
, fmap
->fd
, lc
,
545 cursect
, *cursect
, sc
->nsects
);
547 sections
= (const struct section
*)(sc
+ 1);
548 for (i
= 0; i
< sc
->nsects
; i
++)
550 if (*cursect
> MAX_SECT
) return -1;
553 if (!(sections
[i
].flags
& SECTION_TYPE
) &&
554 (sections
[i
].flags
& (S_ATTR_PURE_INSTRUCTIONS
|S_ATTR_SOME_INSTRUCTIONS
)))
555 RtlSetBits(&fmap
->sect_is_code
, *cursect
, 1);
557 RtlClearBits(&fmap
->sect_is_code
, *cursect
, 1);
558 TRACE("Section %d (%d of this segment) is%s code\n", *cursect
, i
,
559 (RtlAreBitsSet(&fmap
->sect_is_code
, *cursect
, 1) ? "" : " not"));
565 /******************************************************************
568 * Checks if a section, identified by sectidx which is a 1-based
569 * index into the sections of all segments, in order of load
570 * commands, contains code.
572 static BOOL
macho_sect_is_code(struct macho_file_map
* fmap
, unsigned char sectidx
)
574 TRACE("(%p/%d, %u)\n", fmap
, fmap
->fd
, sectidx
);
576 if (!RtlAreBitsSet(&fmap
->sect_is_code
, 0, 1))
579 if (macho_enum_load_commands(fmap
, LC_SEGMENT
, macho_fill_sect_is_code
, &cursect
) < 0)
580 WARN("Couldn't load sect_is_code map\n");
581 RtlSetBits(&fmap
->sect_is_code
, 0, 1);
584 return RtlAreBitsSet(&fmap
->sect_is_code
, sectidx
, 1);
589 struct hash_table_elt ht_elt
;
590 struct symt_compiland
* compiland
;
592 unsigned char is_code
:1,
598 struct macho_debug_info
600 struct macho_file_map
* fmap
;
601 struct module
* module
;
603 struct hash_table ht_symtab
;
606 /******************************************************************
609 * Callback for stabs_parse. Collect symbol definitions.
611 static void macho_stabs_def_cb(struct module
* module
, unsigned long load_offset
,
612 const char* name
, unsigned long offset
,
613 BOOL is_public
, BOOL is_global
, unsigned char sectidx
,
614 struct symt_compiland
* compiland
, void* user
)
616 struct macho_debug_info
* mdi
= user
;
617 struct symtab_elt
* ste
;
619 TRACE("(%p, 0x%08lx, %s, 0x%08lx, %d, %d, %u, %p, %p/%p/%d)\n", module
, load_offset
,
620 debugstr_a(name
), offset
, is_public
, is_global
, sectidx
,
621 compiland
, mdi
, mdi
->fmap
, mdi
->fmap
->fd
);
623 /* Defer the creation of new non-debugging symbols until after we've
624 * finished parsing the stabs. */
625 ste
= pool_alloc(&mdi
->pool
, sizeof(*ste
));
626 ste
->ht_elt
.name
= pool_strdup(&mdi
->pool
, name
);
627 ste
->compiland
= compiland
;
628 ste
->addr
= load_offset
+ offset
;
629 ste
->is_code
= !!macho_sect_is_code(mdi
->fmap
, sectidx
);
630 ste
->is_public
= !!is_public
;
631 ste
->is_global
= !!is_global
;
633 hash_table_add(&mdi
->ht_symtab
, &ste
->ht_elt
);
636 /******************************************************************
639 * Callback for macho_enum_load_commands. Processes the LC_SYMTAB
640 * load commands from the Mach-O file.
642 static int macho_parse_symtab(struct macho_file_map
* fmap
,
643 const struct load_command
* lc
, void* user
)
645 const struct symtab_command
* sc
= (const struct symtab_command
*)lc
;
646 struct macho_debug_info
* mdi
= user
;
647 const struct nlist
* stab
;
651 TRACE("(%p/%d, %p, %p) %u syms at 0x%08x, strings 0x%08x - 0x%08x\n", fmap
, fmap
->fd
, lc
,
652 user
, sc
->nsyms
, sc
->symoff
, sc
->stroff
, sc
->stroff
+ sc
->strsize
);
654 if (!macho_map_ranges(fmap
, sc
->symoff
, sc
->nsyms
* sizeof(struct nlist
),
655 sc
->stroff
, sc
->strsize
, (const void**)&stab
, (const void**)&stabstr
))
658 if (!stabs_parse(mdi
->module
,
659 mdi
->module
->format_info
[DFI_MACHO
]->u
.macho_info
->load_addr
- fmap
->segs_start
,
660 stab
, sc
->nsyms
* sizeof(struct nlist
),
661 stabstr
, sc
->strsize
, macho_stabs_def_cb
, mdi
))
664 macho_unmap_ranges(fmap
, sc
->symoff
, sc
->nsyms
* sizeof(struct nlist
),
665 sc
->stroff
, sc
->strsize
, (const void**)&stab
, (const void**)&stabstr
);
670 /******************************************************************
673 * Integrate the non-debugging symbols we've gathered into the
674 * symbols that were generated during stabs parsing.
676 static void macho_finish_stabs(struct module
* module
, struct hash_table
* ht_symtab
)
678 struct hash_table_iter hti_ours
;
679 struct symtab_elt
* ste
;
680 BOOL adjusted
= FALSE
;
682 TRACE("(%p, %p)\n", module
, ht_symtab
);
684 /* For each of our non-debugging symbols, see if it can provide some
685 * missing details to one of the module's known symbols. */
686 hash_table_iter_init(ht_symtab
, &hti_ours
, NULL
);
687 while ((ste
= hash_table_iter_up(&hti_ours
)))
689 struct hash_table_iter hti_modules
;
692 struct symt_function
* func
;
693 struct symt_data
* data
;
695 hash_table_iter_init(&module
->ht_symbols
, &hti_modules
, ste
->ht_elt
.name
);
696 while ((ptr
= hash_table_iter_up(&hti_modules
)))
698 sym
= GET_ENTRY(ptr
, struct symt_ht
, hash_elt
);
700 if (strcmp(sym
->hash_elt
.name
, ste
->ht_elt
.name
))
703 switch (sym
->symt
.tag
)
706 func
= (struct symt_function
*)sym
;
707 if (func
->address
== module
->format_info
[DFI_MACHO
]->u
.macho_info
->load_addr
)
709 TRACE("Adjusting function %p/%s!%s from 0x%08lx to 0x%08lx\n", func
,
710 debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
,
711 func
->address
, ste
->addr
);
712 func
->address
= ste
->addr
;
715 if (func
->address
== ste
->addr
)
719 data
= (struct symt_data
*)sym
;
723 case DataIsFileStatic
:
724 if (data
->u
.var
.offset
== module
->format_info
[DFI_MACHO
]->u
.macho_info
->load_addr
)
726 TRACE("Adjusting data symbol %p/%s!%s from 0x%08lx to 0x%08lx\n",
727 data
, debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
,
728 data
->u
.var
.offset
, ste
->addr
);
729 data
->u
.var
.offset
= ste
->addr
;
732 if (data
->u
.var
.offset
== ste
->addr
)
734 enum DataKind new_kind
;
736 new_kind
= ste
->is_global
? DataIsGlobal
: DataIsFileStatic
;
737 if (data
->kind
!= new_kind
)
739 WARN("Changing kind for %p/%s!%s from %d to %d\n", sym
,
740 debugstr_w(module
->module
.ModuleName
), sym
->hash_elt
.name
,
741 (int)data
->kind
, (int)new_kind
);
742 data
->kind
= new_kind
;
752 TRACE("Ignoring tag %u\n", sym
->symt
.tag
);
760 /* since we may have changed some addresses, mark the module to be resorted */
761 module
->sortlist_valid
= FALSE
;
764 /* Mark any of our non-debugging symbols which fall on an already-used
765 * address as "used". This allows us to skip them in the next loop,
766 * below. We do this in separate loops because symt_new_* marks the
767 * list as needing sorting and symt_find_nearest sorts if needed,
768 * causing thrashing. */
769 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
))
771 hash_table_iter_init(ht_symtab
, &hti_ours
, NULL
);
772 while ((ste
= hash_table_iter_up(&hti_ours
)))
777 if (ste
->used
) continue;
779 sym
= symt_find_nearest(module
, ste
->addr
);
781 symt_get_address(&sym
->symt
, &addr
);
782 if (sym
&& ste
->addr
== addr
)
789 /* If neither symbol has a correct size (ours never does), we
790 * consider them both to be markers. No warning is needed in
792 * Also, we check that we don't have two symbols, one local, the other
793 * global, which is legal.
795 symt_get_info(module
, &sym
->symt
, TI_GET_LENGTH
, &size
);
796 symt_get_info(module
, &sym
->symt
, TI_GET_DATAKIND
, &kind
);
797 if (size
&& kind
== (ste
->is_global
? DataIsGlobal
: DataIsFileStatic
))
798 FIXME("Duplicate in %s: %s<%08lx> %s<%s-%s>\n",
799 debugstr_w(module
->module
.ModuleName
),
800 ste
->ht_elt
.name
, ste
->addr
,
802 wine_dbgstr_longlong(addr
), wine_dbgstr_longlong(size
));
807 /* For any of our remaining non-debugging symbols which have no match
808 * among the module's known symbols, add them as new symbols. */
809 hash_table_iter_init(ht_symtab
, &hti_ours
, NULL
);
810 while ((ste
= hash_table_iter_up(&hti_ours
)))
812 if (!(dbghelp_options
& SYMOPT_PUBLICS_ONLY
) && !ste
->used
)
816 symt_new_function(module
, ste
->compiland
, ste
->ht_elt
.name
,
823 loc
.kind
= loc_absolute
;
825 loc
.offset
= ste
->addr
;
826 symt_new_global_variable(module
, ste
->compiland
, ste
->ht_elt
.name
,
827 !ste
->is_global
, loc
, 0, NULL
);
833 if (ste
->is_public
&& !(dbghelp_options
& SYMOPT_NO_PUBLICS
))
835 symt_new_public(module
, ste
->compiland
, ste
->ht_elt
.name
, ste
->addr
, 0);
840 /******************************************************************
841 * macho_load_debug_info_from_map
843 * Loads the symbolic information from a Mach-O module.
845 * FALSE if the file doesn't contain symbolic info (or this info
846 * cannot be read or parsed)
849 static BOOL
macho_load_debug_info_from_map(struct module
* module
,
850 struct macho_file_map
* fmap
)
853 struct macho_debug_info mdi
;
856 TRACE("(%p, %p/%d)\n", module
, fmap
, fmap
->fd
);
858 module
->module
.SymType
= SymExport
;
862 pool_init(&mdi
.pool
, 65536);
863 hash_table_init(&mdi
.pool
, &mdi
.ht_symtab
, 256);
864 result
= macho_enum_load_commands(fmap
, LC_SYMTAB
, macho_parse_symtab
, &mdi
);
868 WARN("Couldn't correctly read stabs\n");
870 macho_finish_stabs(module
, &mdi
.ht_symtab
);
872 pool_destroy(&mdi
.pool
);
876 /******************************************************************
877 * macho_load_debug_info
879 * Loads Mach-O debugging information from the module image file.
881 BOOL
macho_load_debug_info(struct module
* module
, struct macho_file_map
* fmap
)
884 struct macho_file_map my_fmap
;
886 TRACE("(%p, %p/%d)\n", module
, fmap
, fmap
? fmap
->fd
: -1);
888 if (module
->type
!= DMT_MACHO
|| !module
->format_info
[DFI_MACHO
]->u
.macho_info
)
890 ERR("Bad Mach-O module '%s'\n", debugstr_w(module
->module
.LoadedImageName
));
897 ret
= macho_map_file(module
->module
.LoadedImageName
, fmap
);
900 ret
= macho_load_debug_info_from_map(module
, fmap
);
902 if (fmap
== &my_fmap
) macho_unmap_file(fmap
);
906 /******************************************************************
907 * macho_fetch_file_info
909 * Gathers some more information for a Mach-O module from a given file
911 BOOL
macho_fetch_file_info(const WCHAR
* name
, DWORD_PTR
* base
,
912 DWORD
* size
, DWORD
* checksum
)
914 struct macho_file_map fmap
;
916 TRACE("(%s, %p, %p, %p)\n", debugstr_w(name
), base
, size
, checksum
);
918 if (!macho_map_file(name
, &fmap
)) return FALSE
;
919 if (base
) *base
= fmap
.segs_start
;
920 *size
= fmap
.segs_size
;
921 *checksum
= calc_crc32(fmap
.fd
);
922 macho_unmap_file(&fmap
);
926 /******************************************************************
929 * Loads the information for Mach-O module stored in 'filename'.
930 * The module has been loaded at 'load_addr' address.
932 * FALSE if the file cannot be found/opened or if the file doesn't
933 * contain symbolic info (or this info cannot be read or parsed)
936 static BOOL
macho_load_file(struct process
* pcs
, const WCHAR
* filename
,
937 unsigned long load_addr
, struct macho_info
* macho_info
)
940 struct macho_file_map fmap
;
942 TRACE("(%p/%p, %s, 0x%08lx, %p/0x%08x)\n", pcs
, pcs
->handle
, debugstr_w(filename
),
943 load_addr
, macho_info
, macho_info
->flags
);
945 if (!macho_map_file(filename
, &fmap
)) return FALSE
;
947 /* Find the dynamic loader's table of images loaded into the process.
949 if (macho_info
->flags
& MACHO_INFO_DEBUG_HEADER
)
951 static void* dyld_all_image_infos_addr
;
953 /* This symbol should be in the same place in all processes. */
954 if (!dyld_all_image_infos_addr
)
957 memset(nl
, 0, sizeof(nl
));
958 nl
[0].n_un
.n_name
= (char*)"_dyld_all_image_infos";
959 if (!nlist("/usr/lib/dyld", nl
))
960 dyld_all_image_infos_addr
= (void*)nl
[0].n_value
;
963 if (dyld_all_image_infos_addr
)
964 macho_info
->dbg_hdr_addr
= (unsigned long)dyld_all_image_infos_addr
;
967 TRACE("dbg_hdr_addr = 0x%08lx\n", macho_info
->dbg_hdr_addr
);
970 if (macho_info
->flags
& MACHO_INFO_MODULE
)
972 struct macho_module_info
*macho_module_info
;
973 struct module_format
* modfmt
=
974 HeapAlloc(GetProcessHeap(), 0, sizeof(struct module_format
) + sizeof(struct macho_module_info
));
975 if (!modfmt
) goto leave
;
976 macho_info
->module
= module_new(pcs
, filename
, DMT_MACHO
, FALSE
, load_addr
,
977 fmap
.segs_size
, 0, calc_crc32(fmap
.fd
));
978 if (!macho_info
->module
)
980 HeapFree(GetProcessHeap(), 0, modfmt
);
983 macho_module_info
= (void*)(modfmt
+ 1);
984 macho_info
->module
->format_info
[DFI_MACHO
] = modfmt
;
986 modfmt
->module
= macho_info
->module
;
987 modfmt
->remove
= NULL
;
988 modfmt
->loc_compute
= NULL
;
989 modfmt
->u
.macho_info
= macho_module_info
;
991 macho_module_info
->load_addr
= load_addr
;
993 if (dbghelp_options
& SYMOPT_DEFERRED_LOADS
)
994 macho_info
->module
->module
.SymType
= SymDeferred
;
995 else if (!macho_load_debug_info(macho_info
->module
, &fmap
))
998 macho_info
->module
->format_info
[DFI_MACHO
]->u
.macho_info
->in_use
= 1;
999 macho_info
->module
->format_info
[DFI_MACHO
]->u
.macho_info
->is_loader
= 0;
1000 TRACE("module = %p\n", macho_info
->module
);
1003 if (macho_info
->flags
& MACHO_INFO_NAME
)
1006 ptr
= HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename
) + 1) * sizeof(WCHAR
));
1009 strcpyW(ptr
, filename
);
1010 macho_info
->module_name
= ptr
;
1013 TRACE("module_name = %p %s\n", macho_info
->module_name
, debugstr_w(macho_info
->module_name
));
1016 macho_unmap_file(&fmap
);
1018 TRACE(" => %d\n", ret
);
1022 /******************************************************************
1023 * macho_load_file_from_path
1024 * Tries to load a Mach-O file from a set of paths (separated by ':')
1026 static BOOL
macho_load_file_from_path(HANDLE hProcess
,
1027 const WCHAR
* filename
,
1028 unsigned long load_addr
,
1030 struct macho_info
* macho_info
)
1034 WCHAR
* pathW
= NULL
;
1037 TRACE("(%p, %s, 0x%08lx, %s, %p)\n", hProcess
, debugstr_w(filename
), load_addr
,
1038 debugstr_a(path
), macho_info
);
1040 if (!path
) return FALSE
;
1042 len
= MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, NULL
, 0);
1043 pathW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1044 if (!pathW
) return FALSE
;
1045 MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, pathW
, len
);
1047 for (s
= pathW
; s
&& *s
; s
= (t
) ? (t
+1) : NULL
)
1049 t
= strchrW(s
, ':');
1051 fn
= HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename
) + 1 + lstrlenW(s
) + 1) * sizeof(WCHAR
));
1054 strcatW(fn
, S_SlashW
);
1055 strcatW(fn
, filename
);
1056 ret
= macho_load_file(hProcess
, fn
, load_addr
, macho_info
);
1057 HeapFree(GetProcessHeap(), 0, fn
);
1059 s
= (t
) ? (t
+1) : NULL
;
1062 TRACE(" => %d\n", ret
);
1063 HeapFree(GetProcessHeap(), 0, pathW
);
1067 /******************************************************************
1068 * macho_load_file_from_dll_path
1070 * Tries to load a Mach-O file from the dll path
1072 static BOOL
macho_load_file_from_dll_path(HANDLE hProcess
,
1073 const WCHAR
* filename
,
1074 unsigned long load_addr
,
1075 struct macho_info
* macho_info
)
1078 unsigned int index
= 0;
1081 TRACE("(%p, %s, 0x%08lx, %p)\n", hProcess
, debugstr_w(filename
), load_addr
,
1084 while (!ret
&& (path
= wine_dll_enum_load_path( index
++ )))
1089 len
= MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, NULL
, 0);
1091 name
= HeapAlloc( GetProcessHeap(), 0,
1092 (len
+ lstrlenW(filename
) + 2) * sizeof(WCHAR
) );
1095 MultiByteToWideChar(CP_UNIXCP
, 0, path
, -1, name
, len
);
1096 strcatW( name
, S_SlashW
);
1097 strcatW( name
, filename
);
1098 ret
= macho_load_file(hProcess
, name
, load_addr
, macho_info
);
1099 HeapFree( GetProcessHeap(), 0, name
);
1101 TRACE(" => %d\n", ret
);
1105 /******************************************************************
1106 * macho_search_and_load_file
1108 * Lookup a file in standard Mach-O locations, and if found, load it
1110 static BOOL
macho_search_and_load_file(struct process
* pcs
, const WCHAR
* filename
,
1111 unsigned long load_addr
,
1112 struct macho_info
* macho_info
)
1115 struct module
* module
;
1116 static WCHAR S_libstdcPPW
[] = {'l','i','b','s','t','d','c','+','+','\0'};
1119 TRACE("(%p/%p, %s, 0x%08lx, %p)\n", pcs
, pcs
->handle
, debugstr_w(filename
), load_addr
,
1122 if (filename
== NULL
|| *filename
== '\0') return FALSE
;
1123 if ((module
= module_is_already_loaded(pcs
, filename
)))
1125 macho_info
->module
= module
;
1126 module
->format_info
[DFI_MACHO
]->u
.macho_info
->in_use
= 1;
1127 return module
->module
.SymType
;
1130 if (strstrW(filename
, S_libstdcPPW
)) return FALSE
; /* We know we can't do it */
1132 /* If has no directories, try LD_LIBRARY_PATH first. */
1133 if (!strchrW(filename
, '/'))
1135 ret
= macho_load_file_from_path(pcs
, filename
, load_addr
,
1136 getenv("PATH"), macho_info
);
1138 /* Try DYLD_LIBRARY_PATH, with just the filename (no directories). */
1141 if ((p
= strrchrW(filename
, '/'))) p
++;
1143 ret
= macho_load_file_from_path(pcs
, p
, load_addr
,
1144 getenv("DYLD_LIBRARY_PATH"), macho_info
);
1146 /* Try the path as given. */
1148 ret
= macho_load_file(pcs
, filename
, load_addr
, macho_info
);
1149 /* Try DYLD_FALLBACK_LIBRARY_PATH, with just the filename (no directories). */
1152 ret
= macho_load_file_from_path(pcs
, p
, load_addr
,
1153 getenv("DYLD_FALLBACK_LIBRARY_PATH"), macho_info
);
1155 if (!ret
&& !strchrW(filename
, '/'))
1156 ret
= macho_load_file_from_dll_path(pcs
, filename
, load_addr
, macho_info
);
1161 /******************************************************************
1162 * macho_enum_modules_internal
1164 * Enumerate Mach-O modules from a running process
1166 static BOOL
macho_enum_modules_internal(const struct process
* pcs
,
1167 const WCHAR
* main_name
,
1168 enum_modules_cb cb
, void* user
)
1170 struct dyld_all_image_infos image_infos
;
1171 struct dyld_image_info
* info_array
= NULL
;
1175 WCHAR bufstrW
[MAX_PATH
];
1178 TRACE("(%p/%p, %s, %p, %p)\n", pcs
, pcs
->handle
, debugstr_w(main_name
), cb
,
1181 if (!pcs
->dbg_hdr_addr
||
1182 !ReadProcessMemory(pcs
->handle
, (void*)pcs
->dbg_hdr_addr
,
1183 &image_infos
, sizeof(image_infos
), NULL
) ||
1184 !image_infos
.infoArray
)
1186 TRACE("Process has %u image infos at %p\n", image_infos
.infoArrayCount
, image_infos
.infoArray
);
1188 len
= image_infos
.infoArrayCount
* sizeof(info_array
[0]);
1189 info_array
= HeapAlloc(GetProcessHeap(), 0, len
);
1191 !ReadProcessMemory(pcs
->handle
, image_infos
.infoArray
,
1192 info_array
, len
, NULL
))
1194 TRACE("... read image infos\n");
1196 for (i
= 0; i
< image_infos
.infoArrayCount
; i
++)
1198 if (info_array
[i
].imageFilePath
!= NULL
&&
1199 ReadProcessMemory(pcs
->handle
, info_array
[i
].imageFilePath
, bufstr
, sizeof(bufstr
), NULL
))
1201 bufstr
[sizeof(bufstr
) - 1] = '\0';
1202 TRACE("[%d] image file %s\n", i
, debugstr_a(bufstr
));
1203 MultiByteToWideChar(CP_UNIXCP
, 0, bufstr
, -1, bufstrW
, sizeof(bufstrW
) / sizeof(WCHAR
));
1204 if (main_name
&& !bufstrW
[0]) strcpyW(bufstrW
, main_name
);
1205 if (!cb(bufstrW
, (unsigned long)info_array
[i
].imageLoadAddress
, user
)) break;
1211 HeapFree(GetProcessHeap(), 0, info_array
);
1217 struct process
* pcs
;
1218 struct macho_info macho_info
;
1221 static BOOL
macho_enum_sync_cb(const WCHAR
* name
, unsigned long addr
, void* user
)
1223 struct macho_sync
* ms
= user
;
1225 TRACE("(%s, 0x%08lx, %p)\n", debugstr_w(name
), addr
, user
);
1226 macho_search_and_load_file(ms
->pcs
, name
, addr
, &ms
->macho_info
);
1230 /******************************************************************
1231 * macho_synchronize_module_list
1233 * Rescans the debuggee's modules list and synchronizes it with
1234 * the one from 'pcs', ie:
1235 * - if a module is in debuggee and not in pcs, it's loaded into pcs
1236 * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1238 BOOL
macho_synchronize_module_list(struct process
* pcs
)
1240 struct module
* module
;
1241 struct macho_sync ms
;
1243 TRACE("(%p/%p)\n", pcs
, pcs
->handle
);
1245 for (module
= pcs
->lmodules
; module
; module
= module
->next
)
1247 if (module
->type
== DMT_MACHO
&& !module
->is_virtual
)
1248 module
->format_info
[DFI_MACHO
]->u
.macho_info
->in_use
= 0;
1252 ms
.macho_info
.flags
= MACHO_INFO_MODULE
;
1253 if (!macho_enum_modules_internal(pcs
, NULL
, macho_enum_sync_cb
, &ms
))
1256 module
= pcs
->lmodules
;
1259 if (module
->type
== DMT_MACHO
&& !module
->is_virtual
&&
1260 !module
->format_info
[DFI_MACHO
]->u
.macho_info
->in_use
&&
1261 !module
->format_info
[DFI_MACHO
]->u
.macho_info
->is_loader
)
1263 module_remove(pcs
, module
);
1264 /* restart all over */
1265 module
= pcs
->lmodules
;
1267 else module
= module
->next
;
1272 /******************************************************************
1273 * macho_search_loader
1275 * Lookup in a running Mach-O process the loader, and sets its Mach-O link
1276 * address (for accessing the list of loaded images) in pcs.
1277 * If flags is MACHO_INFO_MODULE, the module for the loader is also
1278 * added as a module into pcs.
1280 static BOOL
macho_search_loader(struct process
* pcs
, struct macho_info
* macho_info
)
1282 return macho_search_and_load_file(pcs
, get_wine_loader_name(), 0, macho_info
);
1285 /******************************************************************
1286 * macho_read_wine_loader_dbg_info
1288 * Try to find a decent wine executable which could have loaded the debuggee
1290 BOOL
macho_read_wine_loader_dbg_info(struct process
* pcs
)
1292 struct macho_info macho_info
;
1294 TRACE("(%p/%p)\n", pcs
, pcs
->handle
);
1295 macho_info
.flags
= MACHO_INFO_DEBUG_HEADER
| MACHO_INFO_MODULE
;
1296 if (!macho_search_loader(pcs
, &macho_info
)) return FALSE
;
1297 macho_info
.module
->format_info
[DFI_MACHO
]->u
.macho_info
->is_loader
= 1;
1298 module_set_module(macho_info
.module
, S_WineLoaderW
);
1299 return (pcs
->dbg_hdr_addr
= macho_info
.dbg_hdr_addr
) != 0;
1302 /******************************************************************
1303 * macho_enum_modules
1305 * Enumerates the Mach-O loaded modules from a running target (hProc)
1306 * This function doesn't require that someone has called SymInitialize
1307 * on this very process.
1309 BOOL
macho_enum_modules(HANDLE hProc
, enum_modules_cb cb
, void* user
)
1312 struct macho_info macho_info
;
1315 TRACE("(%p, %p, %p)\n", hProc
, cb
, user
);
1316 memset(&pcs
, 0, sizeof(pcs
));
1318 macho_info
.flags
= MACHO_INFO_DEBUG_HEADER
| MACHO_INFO_NAME
;
1319 if (!macho_search_loader(&pcs
, &macho_info
)) return FALSE
;
1320 pcs
.dbg_hdr_addr
= macho_info
.dbg_hdr_addr
;
1321 ret
= macho_enum_modules_internal(&pcs
, macho_info
.module_name
, cb
, user
);
1322 HeapFree(GetProcessHeap(), 0, (char*)macho_info
.module_name
);
1328 struct process
* pcs
;
1329 struct macho_info macho_info
;
1334 /******************************************************************
1337 * Callback for macho_load_module, used to walk the list of loaded
1340 static BOOL
macho_load_cb(const WCHAR
* name
, unsigned long addr
, void* user
)
1342 struct macho_load
* ml
= user
;
1345 TRACE("(%s, 0x%08lx, %p)\n", debugstr_w(name
), addr
, user
);
1347 /* memcmp is needed for matches when bufstr contains also version information
1348 * ml->name: libc.so, name: libc.so.6.0
1350 p
= strrchrW(name
, '/');
1352 if (!memcmp(p
, ml
->name
, lstrlenW(ml
->name
) * sizeof(WCHAR
)))
1354 ml
->ret
= macho_search_and_load_file(ml
->pcs
, name
, addr
, &ml
->macho_info
);
1360 /******************************************************************
1363 * Loads a Mach-O module and stores it in process' module list.
1364 * Also, find module real name and load address from
1365 * the real loaded modules list in pcs address space.
1367 struct module
* macho_load_module(struct process
* pcs
, const WCHAR
* name
, unsigned long addr
)
1369 struct macho_load ml
;
1371 TRACE("(%p/%p, %s, 0x%08lx)\n", pcs
, pcs
->handle
, debugstr_w(name
), addr
);
1373 ml
.macho_info
.flags
= MACHO_INFO_MODULE
;
1376 if (pcs
->dbg_hdr_addr
) /* we're debugging a live target */
1379 /* do only the lookup from the filename, not the path (as we lookup module
1380 * name in the process' loaded module list)
1382 ml
.name
= strrchrW(name
, '/');
1383 if (!ml
.name
++) ml
.name
= name
;
1386 if (!macho_enum_modules_internal(pcs
, NULL
, macho_load_cb
, &ml
))
1392 ml
.ret
= macho_search_and_load_file(pcs
, ml
.name
, addr
, &ml
.macho_info
);
1394 if (!ml
.ret
) return NULL
;
1395 assert(ml
.macho_info
.module
);
1396 return ml
.macho_info
.module
;
1399 #else /* HAVE_MACH_O_LOADER_H */
1401 BOOL
macho_synchronize_module_list(struct process
* pcs
)
1406 BOOL
macho_fetch_file_info(const WCHAR
* name
, DWORD_PTR
* base
,
1407 DWORD
* size
, DWORD
* checksum
)
1412 BOOL
macho_read_wine_loader_dbg_info(struct process
* pcs
)
1417 BOOL
macho_enum_modules(HANDLE hProc
, enum_modules_cb cb
, void* user
)
1422 struct module
* macho_load_module(struct process
* pcs
, const WCHAR
* name
, unsigned long addr
)
1427 BOOL
macho_load_debug_info(struct module
* module
, struct macho_file_map
* fmap
)
1431 #endif /* HAVE_MACH_O_LOADER_H */