msi: Don't print the function name twice in a WARN.
[wine] / dlls / dbghelp / macho_module.c
1 /*
2  * File macho_module.c - processing of Mach-O files
3  *      Originally based on elf_module.c
4  *
5  * Copyright (C) 1996, Eric Youngdale.
6  *               1999-2007 Eric Pouech
7  *               2009 Ken Thomases, CodeWeavers Inc.
8  *
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.
13  *
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.
18  *
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
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include "dbghelp_private.h"
28
29 #ifdef __MACH__
30
31 #include <assert.h>
32 #include <stdarg.h>
33 #ifdef HAVE_SYS_STAT_H
34 # include <sys/stat.h>
35 #endif
36 #ifdef HAVE_SYS_MMAN_H
37 # include <sys/mman.h>
38 #endif
39
40 #include <mach-o/fat.h>
41 #include <mach-o/loader.h>
42 #include <mach-o/nlist.h>
43
44 #ifdef HAVE_MACH_O_DYLD_IMAGES_H
45 #include <mach-o/dyld_images.h>
46 #else
47 struct dyld_image_info {
48     const struct mach_header *imageLoadAddress;
49     const char               *imageFilePath;
50     uintptr_t                 imageFileModDate;
51 };
52
53 struct dyld_all_image_infos {
54     uint32_t                      version;
55     uint32_t                      infoArrayCount;
56     const struct dyld_image_info *infoArray;
57     void*                         notification;
58     int                           processDetachedFromSharedRegion;
59 };
60 #endif
61
62 #include "winternl.h"
63 #include "wine/library.h"
64 #include "wine/debug.h"
65
66 #ifdef WORDS_BIGENDIAN
67 #define swap_ulong_be_to_host(n) (n)
68 #else
69 #define swap_ulong_be_to_host(n) (RtlUlongByteSwap(n))
70 #endif
71
72 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_macho);
73
74
75 struct macho_module_info
76 {
77     unsigned long               load_addr;
78     unsigned short              in_use : 1,
79                                 is_loader : 1;
80 };
81
82 #define MACHO_INFO_DEBUG_HEADER   0x0001
83 #define MACHO_INFO_MODULE         0x0002
84 #define MACHO_INFO_NAME           0x0004
85
86 struct macho_info
87 {
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) */
92 };
93
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)
97 struct macho_file_map
98 {
99     /* A copy of the Mach-O header for an individual architecture. */
100     struct mach_header          mach_header;
101
102     /* The mapped load commands. */
103     const struct load_command*  load_commands;
104
105     /* The portion of the file which is this architecture.  mach_header was
106      * read from arch_offset. */
107     unsigned                    arch_offset;
108     unsigned                    arch_size;
109
110     /* The range of address space covered by all segments. */
111     size_t                      segs_start;
112     size_t                      segs_size;
113
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)];
118
119     /* The file. */
120     int                         fd;
121 };
122
123 static void macho_unmap_file(struct macho_file_map* fmap);
124
125 /******************************************************************
126  *              macho_calc_range
127  *
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.
132  */
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)
137 {
138     unsigned pagemask = getpagesize() - 1;
139     unsigned file_offset, misalign;
140
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;
145     if (out_aligned_len)
146         *out_aligned_len = *out_aligned_end - *out_aligned_offset;
147     if (out_misalign)
148         *out_misalign = misalign;
149 }
150
151 /******************************************************************
152  *              macho_map_range
153  *
154  * Maps a range (offset, length in bytes) from a Mach-O file into memory
155  */
156 static const char* macho_map_range(const struct macho_file_map* fmap, unsigned offset, unsigned len)
157 {
158     unsigned    misalign, aligned_offset, aligned_map_end, map_size;
159     const void* aligned_ptr;
160
161     TRACE("(%p/%d, 0x%08x, 0x%08x)\n", fmap, fmap->fd, offset, len);
162
163     macho_calc_range(fmap, offset, len, &aligned_offset, &aligned_map_end,
164                      &map_size, &misalign);
165
166     aligned_ptr = mmap(NULL, map_size, PROT_READ, MAP_PRIVATE, fmap->fd, aligned_offset);
167
168     TRACE("Mapped (0x%08x - 0x%08x) to %p\n", aligned_offset, aligned_map_end, aligned_ptr);
169
170     if (aligned_ptr == MAP_FAILED) return MACHO_NO_MAP;
171     return (const char*)aligned_ptr + misalign;
172 }
173
174 /******************************************************************
175  *              macho_unmap_range
176  *
177  * Unmaps a range (offset, length in bytes) of a Mach-O file from memory
178  */
179 static void macho_unmap_range(const void** mapped, const struct macho_file_map* fmap,
180                               unsigned offset, unsigned len)
181 {
182     TRACE("(%p, %p/%d, 0x%08x, 0x%08x)\n", mapped, fmap, fmap->fd, offset, len);
183
184     if (mapped && *mapped != MACHO_NO_MAP)
185     {
186         unsigned    misalign, aligned_offset, aligned_map_end, map_size;
187         void*       aligned_ptr;
188
189         macho_calc_range(fmap, offset, len, &aligned_offset, &aligned_map_end,
190                          &map_size, &misalign);
191
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;
197     }
198 }
199
200 /******************************************************************
201  *              macho_map_ranges
202  *
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.
206  */
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)
211 {
212     unsigned aligned_offset1, aligned_map_end1;
213     unsigned aligned_offset2, aligned_map_end2;
214
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);
217
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);
220
221     if (aligned_map_end1 < aligned_offset2 || aligned_map_end2 < aligned_offset1)
222     {
223         *mapped1 = macho_map_range(fmap, offset1, len1);
224         if (*mapped1 != MACHO_NO_MAP)
225         {
226             *mapped2 = macho_map_range(fmap, offset2, len2);
227             if (*mapped2 == MACHO_NO_MAP)
228                 macho_unmap_range(mapped1, fmap, offset1, len1);
229         }
230     }
231     else
232     {
233         if (offset1 < offset2)
234         {
235             *mapped1 = macho_map_range(fmap, offset1, offset2 + len2 - offset1);
236             if (*mapped1 != MACHO_NO_MAP)
237                 *mapped2 = (const char*)*mapped1 + offset2 - offset1;
238         }
239         else
240         {
241             *mapped2 = macho_map_range(fmap, offset2, offset1 + len1 - offset2);
242             if (*mapped2 != MACHO_NO_MAP)
243                 *mapped1 = (const char*)*mapped2 + offset1 - offset2;
244         }
245     }
246
247     TRACE(" => %p, %p\n", *mapped1, *mapped2);
248
249     return (*mapped1 != MACHO_NO_MAP) && (*mapped2 != MACHO_NO_MAP);
250 }
251
252 /******************************************************************
253  *              macho_unmap_ranges
254  *
255  * Unmaps two ranges (offset, length in bytes) of a Mach-O file
256  * from memory.  Use for ranges which were mapped by
257  * macho_map_ranges.
258  */
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)
263 {
264     unsigned    aligned_offset1, aligned_map_end1;
265     unsigned    aligned_offset2, aligned_map_end2;
266
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);
269
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);
272
273     if (aligned_map_end1 < aligned_offset2 || aligned_map_end2 < aligned_offset1)
274     {
275         macho_unmap_range(mapped1, fmap, offset1, len1);
276         macho_unmap_range(mapped2, fmap, offset2, len2);
277     }
278     else
279     {
280         if (offset1 < offset2)
281         {
282             macho_unmap_range(mapped1, fmap, offset1, offset2 + len2 - offset1);
283             *mapped2 = MACHO_NO_MAP;
284         }
285         else
286         {
287             macho_unmap_range(mapped2, fmap, offset2, offset1 + len1 - offset2);
288             *mapped1 = MACHO_NO_MAP;
289         }
290     }
291 }
292
293 /******************************************************************
294  *              macho_map_load_commands
295  *
296  * Maps the load commands from a Mach-O file into memory
297  */
298 static const struct load_command* macho_map_load_commands(struct macho_file_map* fmap)
299 {
300     if (fmap->load_commands == MACHO_NO_MAP)
301     {
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);
305     }
306
307     return fmap->load_commands;
308 }
309
310 /******************************************************************
311  *              macho_unmap_load_commands
312  *
313  * Unmaps the load commands of a Mach-O file from memory
314  */
315 static void macho_unmap_load_commands(struct macho_file_map* fmap)
316 {
317     if (fmap->load_commands != MACHO_NO_MAP)
318     {
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);
322     }
323 }
324
325 /******************************************************************
326  *              macho_next_load_command
327  *
328  * Advance to the next load command
329  */
330 static const struct load_command* macho_next_load_command(const struct load_command* lc)
331 {
332     return (const struct load_command*)((const char*)lc + lc->cmdsize);
333 }
334
335 /******************************************************************
336  *              macho_enum_load_commands
337  *
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
344  * processed.
345  */
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*),
348                                     void* user)
349 {
350     const struct load_command* lc;
351     int i;
352     int count = 0;
353
354     TRACE("(%p/%d, %u, %p, %p)\n", fmap, fmap->fd, cmd, cb, user);
355
356     if ((lc = macho_map_load_commands(fmap)) == MACHO_NO_MAP) return -1;
357
358     TRACE("%d total commands\n", fmap->mach_header.ncmds);
359
360     for (i = 0; i < fmap->mach_header.ncmds; i++, lc = macho_next_load_command(lc))
361     {
362         int result;
363
364         if (cmd && cmd != lc->cmd) continue;
365         count++;
366
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;
370     }
371
372     return count;
373 }
374
375 /******************************************************************
376  *              macho_accum_segs_range
377  *
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.
381  */
382 static int macho_accum_segs_range(struct macho_file_map* fmap,
383                                   const struct load_command* lc, void* user)
384 {
385     const struct segment_command*   sc = (const struct segment_command*)lc;
386     unsigned                        tmp, page_mask = getpagesize() - 1;
387
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);
392
393     if (!strncmp(sc->segname, "WINE_", 5))
394     {
395         TRACE("Ignoring special Wine segment %s\n", debugstr_an(sc->segname, sizeof(sc->segname)));
396         return 0;
397     }
398
399     /* If this segment starts before previously-known earliest, record
400      * new earliest. */
401     if (sc->vmaddr < fmap->segs_start)
402         fmap->segs_start = sc->vmaddr;
403
404     /* If this segment extends beyond previously-known furthest, record
405      * new furthest. */
406     tmp = (sc->vmaddr + sc->vmsize + page_mask) & ~page_mask;
407     if (fmap->segs_size < tmp) fmap->segs_size = tmp;
408
409     TRACE("after: 0x%08x - 0x%08x\n", (unsigned)fmap->segs_start, (unsigned)fmap->segs_size);
410
411     return 0;
412 }
413
414 /******************************************************************
415  *              macho_map_file
416  *
417  * Maps a Mach-O file into memory (and checks it's a real Mach-O file)
418  */
419 static BOOL macho_map_file(const WCHAR* filenameW, struct macho_file_map* fmap)
420 {
421     struct fat_header   fat_header;
422     struct stat         statbuf;
423     int                 i;
424     char*               filename;
425     unsigned            len;
426     BOOL                ret = FALSE;
427
428     TRACE("(%s, %p)\n", debugstr_w(filenameW), fmap);
429
430     fmap->fd = -1;
431     fmap->load_commands = MACHO_NO_MAP;
432     RtlInitializeBitMap(&fmap->sect_is_code, fmap->sect_is_code_buff, MAX_SECT + 1);
433
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);
437
438     /* check that the file exists */
439     if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) goto done;
440
441     /* Now open the file, so that we can mmap() it. */
442     if ((fmap->fd = open(filename, O_RDONLY)) == -1) goto done;
443
444     if (read(fmap->fd, &fat_header, sizeof(fat_header)) != sizeof(fat_header))
445         goto done;
446     TRACE("... got possible fat header\n");
447
448     /* Fat header is always in big-endian order. */
449     if (swap_ulong_be_to_host(fat_header.magic) == FAT_MAGIC)
450     {
451         int narch = swap_ulong_be_to_host(fat_header.nfat_arch);
452         for (i = 0; i < narch; i++)
453         {
454             struct fat_arch fat_arch;
455             if (read(fmap->fd, &fat_arch, sizeof(fat_arch)) != sizeof(fat_arch))
456                 goto done;
457             if (swap_ulong_be_to_host(fat_arch.cputype) == CPU_TYPE_X86)
458             {
459                 fmap->arch_offset = swap_ulong_be_to_host(fat_arch.offset);
460                 fmap->arch_size = swap_ulong_be_to_host(fat_arch.size);
461                 break;
462             }
463         }
464         if (i >= narch) goto done;
465         TRACE("... found x86 arch\n");
466     }
467     else
468     {
469         fmap->arch_offset = 0;
470         fmap->arch_size = statbuf.st_size;
471         TRACE("... not a fat header\n");
472     }
473
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))
477         goto done;
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)
484     {
485         case MH_EXECUTE:
486         case MH_DYLIB:
487         case MH_DYLINKER:
488         case MH_BUNDLE:
489             break;
490         default:
491             goto done;
492     }
493     TRACE("... verified Mach x86 header\n");
494
495     fmap->segs_size = 0;
496     fmap->segs_start = ~0L;
497
498     if (macho_enum_load_commands(fmap, LC_SEGMENT, macho_accum_segs_range, NULL) < 0)
499         goto done;
500
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);
504
505     ret = TRUE;
506 done:
507     if (!ret)
508         macho_unmap_file(fmap);
509     HeapFree(GetProcessHeap(), 0, filename);
510     return ret;
511 }
512
513 /******************************************************************
514  *              macho_unmap_file
515  *
516  * Unmaps a Mach-O file from memory (previously mapped with macho_map_file)
517  */
518 static void macho_unmap_file(struct macho_file_map* fmap)
519 {
520     TRACE("(%p/%d)\n", fmap, fmap->fd);
521     if (fmap->fd != -1)
522     {
523         macho_unmap_load_commands(fmap);
524         close(fmap->fd);
525         fmap->fd = -1;
526     }
527 }
528
529 /******************************************************************
530  *              macho_fill_sect_is_code
531  *
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.
535  */
536 static int macho_fill_sect_is_code(struct macho_file_map* fmap,
537                                    const struct load_command* lc, void* user)
538 {
539     const struct segment_command*   sc = (const struct segment_command*)lc;
540     const struct section*           sections;
541     int*                            cursect = user;
542     int                             i;
543
544     TRACE("(%p/%d, %p, %p/%d) scanning %u sections\n", fmap, fmap->fd, lc,
545             cursect, *cursect, sc->nsects);
546
547     sections = (const struct section*)(sc + 1);
548     for (i = 0; i < sc->nsects; i++)
549     {
550         if (*cursect > MAX_SECT) return -1;
551         (*cursect)++;
552
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);
556         else
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"));
560     }
561
562     return 0;
563 }
564
565 /******************************************************************
566  *              macho_sect_is_code
567  *
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.
571  */
572 static BOOL macho_sect_is_code(struct macho_file_map* fmap, unsigned char sectidx)
573 {
574     TRACE("(%p/%d, %u)\n", fmap, fmap->fd, sectidx);
575
576     if (!RtlAreBitsSet(&fmap->sect_is_code, 0, 1))
577     {
578         int cursect = 0;
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);
582     }
583
584     return RtlAreBitsSet(&fmap->sect_is_code, sectidx, 1);
585 }
586
587 struct symtab_elt
588 {
589     struct hash_table_elt       ht_elt;
590     struct symt_compiland*      compiland;
591     unsigned long               addr;
592     unsigned char               is_code:1,
593                                 is_public:1,
594                                 is_global:1,
595                                 used:1;
596 };
597
598 struct macho_debug_info
599 {
600     struct macho_file_map*      fmap;
601     struct module*              module;
602     struct pool                 pool;
603     struct hash_table           ht_symtab;
604 };
605
606 /******************************************************************
607  *              macho_stabs_def_cb
608  *
609  * Callback for stabs_parse.  Collect symbol definitions.
610  */
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)
615 {
616     struct macho_debug_info*    mdi = user;
617     struct symtab_elt*          ste;
618
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);
622
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;
632     ste->used           = 0;
633     hash_table_add(&mdi->ht_symtab, &ste->ht_elt);
634 }
635
636 /******************************************************************
637  *              macho_parse_symtab
638  *
639  * Callback for macho_enum_load_commands.  Processes the LC_SYMTAB
640  * load commands from the Mach-O file.
641  */
642 static int macho_parse_symtab(struct macho_file_map* fmap,
643                               const struct load_command* lc, void* user)
644 {
645     const struct symtab_command*    sc = (const struct symtab_command*)lc;
646     struct macho_debug_info*        mdi = user;
647     const struct nlist*             stab;
648     const char*                     stabstr;
649     int                             ret = 0;
650
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);
653
654     if (!macho_map_ranges(fmap, sc->symoff, sc->nsyms * sizeof(struct nlist),
655             sc->stroff, sc->strsize, (const void**)&stab, (const void**)&stabstr))
656         return 0;
657
658     if (!stabs_parse(mdi->module, mdi->module->macho_info->load_addr - fmap->segs_start,
659                        stab, sc->nsyms * sizeof(struct nlist),
660                        stabstr, sc->strsize, macho_stabs_def_cb, mdi))
661         ret = -1;
662
663     macho_unmap_ranges(fmap, sc->symoff, sc->nsyms * sizeof(struct nlist),
664             sc->stroff, sc->strsize, (const void**)&stab, (const void**)&stabstr);
665
666     return ret;
667 }
668
669 /******************************************************************
670  *              macho_finish_stabs
671  *
672  * Integrate the non-debugging symbols we've gathered into the
673  * symbols that were generated during stabs parsing.
674  */
675 static void macho_finish_stabs(struct module* module, struct hash_table* ht_symtab)
676 {
677     struct hash_table_iter      hti_ours;
678     struct symtab_elt*          ste;
679     BOOL                        adjusted = FALSE;
680
681     TRACE("(%p, %p)\n", module, ht_symtab);
682
683     /* For each of our non-debugging symbols, see if it can provide some
684      * missing details to one of the module's known symbols. */
685     hash_table_iter_init(ht_symtab, &hti_ours, NULL);
686     while ((ste = hash_table_iter_up(&hti_ours)))
687     {
688         struct hash_table_iter  hti_modules;
689         void*                   ptr;
690         struct symt_ht*         sym;
691         struct symt_function*   func;
692         struct symt_data*       data;
693
694         hash_table_iter_init(&module->ht_symbols, &hti_modules, ste->ht_elt.name);
695         while ((ptr = hash_table_iter_up(&hti_modules)))
696         {
697             sym = GET_ENTRY(ptr, struct symt_ht, hash_elt);
698
699             if (strcmp(sym->hash_elt.name, ste->ht_elt.name))
700                 continue;
701
702             switch (sym->symt.tag)
703             {
704             case SymTagFunction:
705                 func = (struct symt_function*)sym;
706                 if (func->address == module->macho_info->load_addr)
707                 {
708                     TRACE("Adjusting function %p/%s!%s from 0x%08lx to 0x%08lx\n", func,
709                           debugstr_w(module->module.ModuleName), sym->hash_elt.name,
710                           func->address, ste->addr);
711                     func->address = ste->addr;
712                     adjusted = TRUE;
713                 }
714                 if (func->address == ste->addr)
715                     ste->used = 1;
716                 break;
717             case SymTagData:
718                 data = (struct symt_data*)sym;
719                 switch (data->kind)
720                 {
721                 case DataIsGlobal:
722                 case DataIsFileStatic:
723                     if (data->u.var.offset == module->macho_info->load_addr)
724                     {
725                         TRACE("Adjusting data symbol %p/%s!%s from 0x%08lx to 0x%08lx\n",
726                               data, debugstr_w(module->module.ModuleName), sym->hash_elt.name,
727                               data->u.var.offset, ste->addr);
728                         data->u.var.offset = ste->addr;
729                         adjusted = TRUE;
730                     }
731                     if (data->u.var.offset == ste->addr)
732                     {
733                         enum DataKind new_kind;
734
735                         new_kind = ste->is_global ? DataIsGlobal : DataIsFileStatic;
736                         if (data->kind != new_kind)
737                         {
738                             WARN("Changing kind for %p/%s!%s from %d to %d\n", sym,
739                                  debugstr_w(module->module.ModuleName), sym->hash_elt.name,
740                                  (int)data->kind, (int)new_kind);
741                             data->kind = new_kind;
742                             adjusted = TRUE;
743                         }
744                         ste->used = 1;
745                     }
746                     break;
747                 default:;
748                 }
749                 break;
750             default:
751                 TRACE("Ignoring tag %u\n", sym->symt.tag);
752                 break;
753             }
754         }
755     }
756
757     if (adjusted)
758     {
759         /* since we may have changed some addresses, mark the module to be resorted */
760         module->sortlist_valid = FALSE;
761     }
762
763     /* Mark any of our non-debugging symbols which fall on an already-used
764      * address as "used".  This allows us to skip them in the next loop,
765      * below.  We do this in separate loops because symt_new_* marks the
766      * list as needing sorting and symt_find_nearest sorts if needed,
767      * causing thrashing. */
768     if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
769     {
770         hash_table_iter_init(ht_symtab, &hti_ours, NULL);
771         while ((ste = hash_table_iter_up(&hti_ours)))
772         {
773             struct symt_ht* sym;
774             ULONG64         addr;
775
776             if (ste->used) continue;
777
778             sym = symt_find_nearest(module, ste->addr);
779             if (sym)
780                 symt_get_info(module, &sym->symt, TI_GET_ADDRESS, &addr);
781             if (sym && ste->addr == addr)
782             {
783                 ULONG64 size = 0;
784                 DWORD   kind = -1;
785
786                 ste->used = 1;
787
788                 /* If neither symbol has a correct size (ours never does), we
789                  * consider them both to be markers.  No warning is needed in
790                  * that case.
791                  * Also, we check that we don't have two symbols, one local, the other
792                  * global, which is legal.
793                  */
794                 symt_get_info(module, &sym->symt, TI_GET_LENGTH,   &size);
795                 symt_get_info(module, &sym->symt, TI_GET_DATAKIND, &kind);
796                 if (size && kind == (ste->is_global ? DataIsGlobal : DataIsFileStatic))
797                     FIXME("Duplicate in %s: %s<%08lx> %s<%s-%s>\n",
798                           debugstr_w(module->module.ModuleName),
799                           ste->ht_elt.name, ste->addr,
800                           sym->hash_elt.name,
801                           wine_dbgstr_longlong(addr), wine_dbgstr_longlong(size));
802             }
803         }
804     }
805
806     /* For any of our remaining non-debugging symbols which have no match
807      * among the module's known symbols, add them as new symbols. */
808     hash_table_iter_init(ht_symtab, &hti_ours, NULL);
809     while ((ste = hash_table_iter_up(&hti_ours)))
810     {
811         if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY) && !ste->used)
812         {
813             if (ste->is_code)
814             {
815                 symt_new_function(module, ste->compiland, ste->ht_elt.name,
816                     ste->addr, 0, NULL);
817             }
818             else
819             {
820                 symt_new_global_variable(module, ste->compiland, ste->ht_elt.name,
821                     !ste->is_global, ste->addr, 0, NULL);
822             }
823
824             ste->used = 1;
825         }
826
827         if (ste->is_public && !(dbghelp_options & SYMOPT_NO_PUBLICS))
828         {
829             symt_new_public(module, ste->compiland, ste->ht_elt.name, ste->addr, 0);
830         }
831     }
832 }
833
834 /******************************************************************
835  *              macho_load_debug_info_from_map
836  *
837  * Loads the symbolic information from a Mach-O module.
838  * Returns
839  *      FALSE if the file doesn't contain symbolic info (or this info
840  *              cannot be read or parsed)
841  *      TRUE on success
842  */
843 static BOOL macho_load_debug_info_from_map(struct module* module,
844                                            struct macho_file_map* fmap)
845 {
846     BOOL                    ret = FALSE;
847     struct macho_debug_info mdi;
848     int                     result;
849
850     TRACE("(%p, %p/%d)\n", module, fmap, fmap->fd);
851
852     module->module.SymType = SymExport;
853
854     mdi.fmap = fmap;
855     mdi.module = module;
856     pool_init(&mdi.pool, 65536);
857     hash_table_init(&mdi.pool, &mdi.ht_symtab, 256);
858     result = macho_enum_load_commands(fmap, LC_SYMTAB, macho_parse_symtab, &mdi);
859     if (result > 0)
860         ret = TRUE;
861     else if (result < 0)
862         WARN("Couldn't correctly read stabs\n");
863
864     macho_finish_stabs(module, &mdi.ht_symtab);
865
866     pool_destroy(&mdi.pool);
867     return ret;
868 }
869
870 /******************************************************************
871  *              macho_load_debug_info
872  *
873  * Loads Mach-O debugging information from the module image file.
874  */
875 BOOL macho_load_debug_info(struct module* module, struct macho_file_map* fmap)
876 {
877     BOOL                    ret = TRUE;
878     struct macho_file_map   my_fmap;
879
880     TRACE("(%p, %p/%d)\n", module, fmap, fmap ? fmap->fd : -1);
881
882     if (module->type != DMT_MACHO || !module->macho_info)
883     {
884         ERR("Bad Mach-O module '%s'\n", debugstr_w(module->module.LoadedImageName));
885         return FALSE;
886     }
887
888     if (!fmap)
889     {
890         fmap = &my_fmap;
891         ret = macho_map_file(module->module.LoadedImageName, fmap);
892     }
893     if (ret)
894         ret = macho_load_debug_info_from_map(module, fmap);
895
896     if (fmap == &my_fmap) macho_unmap_file(fmap);
897     return ret;
898 }
899
900 /******************************************************************
901  *              macho_fetch_file_info
902  *
903  * Gathers some more information for a Mach-O module from a given file
904  */
905 BOOL macho_fetch_file_info(const WCHAR* name, DWORD* base,
906                            DWORD* size, DWORD* checksum)
907 {
908     struct macho_file_map fmap;
909
910     TRACE("(%s, %p, %p, %p)\n", debugstr_w(name), base, size, checksum);
911
912     if (!macho_map_file(name, &fmap)) return FALSE;
913     if (base) *base = fmap.segs_start;
914     *size = fmap.segs_size;
915     *checksum = calc_crc32(fmap.fd);
916     macho_unmap_file(&fmap);
917     return TRUE;
918 }
919
920 /******************************************************************
921  *              macho_load_file
922  *
923  * Loads the information for Mach-O module stored in 'filename'.
924  * The module has been loaded at 'load_addr' address.
925  * returns
926  *      FALSE if the file cannot be found/opened or if the file doesn't
927  *              contain symbolic info (or this info cannot be read or parsed)
928  *      TRUE on success
929  */
930 static BOOL macho_load_file(struct process* pcs, const WCHAR* filename,
931                             unsigned long load_addr, struct macho_info* macho_info)
932 {
933     BOOL                    ret = TRUE;
934     struct macho_file_map   fmap;
935
936     TRACE("(%p/%p, %s, 0x%08lx, %p/0x%08x)\n", pcs, pcs->handle, debugstr_w(filename),
937             load_addr, macho_info, macho_info->flags);
938
939     if (!macho_map_file(filename, &fmap)) return FALSE;
940
941     /* Find the dynamic loader's table of images loaded into the process.
942      */
943     if (macho_info->flags & MACHO_INFO_DEBUG_HEADER)
944     {
945         static void* dyld_all_image_infos_addr;
946
947         /* This symbol should be in the same place in all processes. */
948         if (!dyld_all_image_infos_addr)
949         {
950             struct nlist nl[2];
951             memset(nl, 0, sizeof(nl));
952             nl[0].n_un.n_name = (char*)"_dyld_all_image_infos";
953             if (!nlist("/usr/lib/dyld", nl))
954                 dyld_all_image_infos_addr = (void*)nl[0].n_value;
955         }
956
957         if (dyld_all_image_infos_addr)
958             macho_info->dbg_hdr_addr = (unsigned long)dyld_all_image_infos_addr;
959         else
960             ret = FALSE;
961         TRACE("dbg_hdr_addr = 0x%08lx\n", macho_info->dbg_hdr_addr);
962     }
963
964     if (macho_info->flags & MACHO_INFO_MODULE)
965     {
966         struct macho_module_info *macho_module_info =
967             HeapAlloc(GetProcessHeap(), 0, sizeof(struct macho_module_info));
968         if (!macho_module_info) goto leave;
969         macho_info->module = module_new(pcs, filename, DMT_MACHO, FALSE, load_addr,
970                                         fmap.segs_size, 0, calc_crc32(fmap.fd));
971         if (!macho_info->module)
972         {
973             HeapFree(GetProcessHeap(), 0, macho_module_info);
974             goto leave;
975         }
976         macho_info->module->macho_info = macho_module_info;
977         macho_info->module->macho_info->load_addr = load_addr;
978
979         if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
980             macho_info->module->module.SymType = SymDeferred;
981         else if (!macho_load_debug_info(macho_info->module, &fmap))
982             ret = FALSE;
983
984         macho_info->module->macho_info->in_use = 1;
985         macho_info->module->macho_info->is_loader = 0;
986         TRACE("module = %p\n", macho_info->module);
987     }
988
989     if (macho_info->flags & MACHO_INFO_NAME)
990     {
991         WCHAR*  ptr;
992         ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
993         if (ptr)
994         {
995             strcpyW(ptr, filename);
996             macho_info->module_name = ptr;
997         }
998         else ret = FALSE;
999         TRACE("module_name = %p %s\n", macho_info->module_name, debugstr_w(macho_info->module_name));
1000     }
1001 leave:
1002     macho_unmap_file(&fmap);
1003
1004     TRACE(" => %d\n", ret);
1005     return ret;
1006 }
1007
1008 /******************************************************************
1009  *              macho_load_file_from_path
1010  * Tries to load a Mach-O file from a set of paths (separated by ':')
1011  */
1012 static BOOL macho_load_file_from_path(HANDLE hProcess,
1013                                       const WCHAR* filename,
1014                                       unsigned long load_addr,
1015                                       const char* path,
1016                                       struct macho_info* macho_info)
1017 {
1018     BOOL                ret = FALSE;
1019     WCHAR               *s, *t, *fn;
1020     WCHAR*              pathW = NULL;
1021     unsigned            len;
1022
1023     TRACE("(%p, %s, 0x%08lx, %s, %p)\n", hProcess, debugstr_w(filename), load_addr,
1024             debugstr_a(path), macho_info);
1025
1026     if (!path) return FALSE;
1027
1028     len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1029     pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1030     if (!pathW) return FALSE;
1031     MultiByteToWideChar(CP_UNIXCP, 0, path, -1, pathW, len);
1032
1033     for (s = pathW; s && *s; s = (t) ? (t+1) : NULL)
1034     {
1035         t = strchrW(s, ':');
1036         if (t) *t = '\0';
1037         fn = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1 + lstrlenW(s) + 1) * sizeof(WCHAR));
1038         if (!fn) break;
1039         strcpyW(fn, s);
1040         strcatW(fn, S_SlashW);
1041         strcatW(fn, filename);
1042         ret = macho_load_file(hProcess, fn, load_addr, macho_info);
1043         HeapFree(GetProcessHeap(), 0, fn);
1044         if (ret) break;
1045         s = (t) ? (t+1) : NULL;
1046     }
1047
1048     TRACE(" => %d\n", ret);
1049     HeapFree(GetProcessHeap(), 0, pathW);
1050     return ret;
1051 }
1052
1053 /******************************************************************
1054  *              macho_load_file_from_dll_path
1055  *
1056  * Tries to load a Mach-O file from the dll path
1057  */
1058 static BOOL macho_load_file_from_dll_path(HANDLE hProcess,
1059                                           const WCHAR* filename,
1060                                           unsigned long load_addr,
1061                                           struct macho_info* macho_info)
1062 {
1063     BOOL ret = FALSE;
1064     unsigned int index = 0;
1065     const char *path;
1066
1067     TRACE("(%p, %s, 0x%08lx, %p)\n", hProcess, debugstr_w(filename), load_addr,
1068             macho_info);
1069
1070     while (!ret && (path = wine_dll_enum_load_path( index++ )))
1071     {
1072         WCHAR *name;
1073         unsigned len;
1074
1075         len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0);
1076
1077         name = HeapAlloc( GetProcessHeap(), 0,
1078                           (len + lstrlenW(filename) + 2) * sizeof(WCHAR) );
1079
1080         if (!name) break;
1081         MultiByteToWideChar(CP_UNIXCP, 0, path, -1, name, len);
1082         strcatW( name, S_SlashW );
1083         strcatW( name, filename );
1084         ret = macho_load_file(hProcess, name, load_addr, macho_info);
1085         HeapFree( GetProcessHeap(), 0, name );
1086     }
1087     TRACE(" => %d\n", ret);
1088     return ret;
1089 }
1090
1091 /******************************************************************
1092  *              macho_search_and_load_file
1093  *
1094  * Lookup a file in standard Mach-O locations, and if found, load it
1095  */
1096 static BOOL macho_search_and_load_file(struct process* pcs, const WCHAR* filename,
1097                                        unsigned long load_addr,
1098                                        struct macho_info* macho_info)
1099 {
1100     BOOL                ret = FALSE;
1101     struct module*      module;
1102     static WCHAR        S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'};
1103     const WCHAR*        p;
1104
1105     TRACE("(%p/%p, %s, 0x%08lx, %p)\n", pcs, pcs->handle, debugstr_w(filename), load_addr,
1106             macho_info);
1107
1108     if (filename == NULL || *filename == '\0') return FALSE;
1109     if ((module = module_is_already_loaded(pcs, filename)))
1110     {
1111         macho_info->module = module;
1112         module->macho_info->in_use = 1;
1113         return module->module.SymType;
1114     }
1115
1116     if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */
1117
1118     /* If has no directories, try LD_LIBRARY_PATH first. */
1119     if (!strchrW(filename, '/'))
1120     {
1121         ret = macho_load_file_from_path(pcs, filename, load_addr,
1122                                       getenv("PATH"), macho_info);
1123     }
1124     /* Try DYLD_LIBRARY_PATH, with just the filename (no directories). */
1125     if (!ret)
1126     {
1127         if ((p = strrchrW(filename, '/'))) p++;
1128         else p = filename;
1129         ret = macho_load_file_from_path(pcs, p, load_addr,
1130                                       getenv("DYLD_LIBRARY_PATH"), macho_info);
1131     }
1132     /* Try the path as given. */
1133     if (!ret)
1134         ret = macho_load_file(pcs, filename, load_addr, macho_info);
1135     /* Try DYLD_FALLBACK_LIBRARY_PATH, with just the filename (no directories). */
1136     if (!ret)
1137     {
1138         ret = macho_load_file_from_path(pcs, p, load_addr,
1139                                       getenv("DYLD_FALLBACK_LIBRARY_PATH"), macho_info);
1140     }
1141     if (!ret && !strchrW(filename, '/'))
1142         ret = macho_load_file_from_dll_path(pcs, filename, load_addr, macho_info);
1143
1144     return ret;
1145 }
1146
1147 /******************************************************************
1148  *              macho_enum_modules_internal
1149  *
1150  * Enumerate Mach-O modules from a running process
1151  */
1152 static BOOL macho_enum_modules_internal(const struct process* pcs,
1153                                         const WCHAR* main_name,
1154                                         enum_modules_cb cb, void* user)
1155 {
1156     struct dyld_all_image_infos image_infos;
1157     struct dyld_image_info*     info_array = NULL;
1158     unsigned long               len;
1159     int                         i;
1160     char                        bufstr[256];
1161     WCHAR                       bufstrW[MAX_PATH];
1162     BOOL                        ret = FALSE;
1163
1164     TRACE("(%p/%p, %s, %p, %p)\n", pcs, pcs->handle, debugstr_w(main_name), cb,
1165             user);
1166
1167     if (!pcs->dbg_hdr_addr ||
1168         !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr,
1169                            &image_infos, sizeof(image_infos), NULL) ||
1170         !image_infos.infoArray)
1171         goto done;
1172     TRACE("Process has %u image infos at %p\n", image_infos.infoArrayCount, image_infos.infoArray);
1173
1174     len = image_infos.infoArrayCount * sizeof(info_array[0]);
1175     info_array = HeapAlloc(GetProcessHeap(), 0, len);
1176     if (!info_array ||
1177         !ReadProcessMemory(pcs->handle, image_infos.infoArray,
1178                            info_array, len, NULL))
1179         goto done;
1180     TRACE("... read image infos\n");
1181
1182     for (i = 0; i < image_infos.infoArrayCount; i++)
1183     {
1184         if (info_array[i].imageFilePath != NULL &&
1185             ReadProcessMemory(pcs->handle, info_array[i].imageFilePath, bufstr, sizeof(bufstr), NULL))
1186         {
1187             bufstr[sizeof(bufstr) - 1] = '\0';
1188             TRACE("[%d] image file %s\n", i, debugstr_a(bufstr));
1189             MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR));
1190             if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name);
1191             if (!cb(bufstrW, (unsigned long)info_array[i].imageLoadAddress, user)) break;
1192         }
1193     }
1194
1195     ret = TRUE;
1196 done:
1197     HeapFree(GetProcessHeap(), 0, info_array);
1198     return ret;
1199 }
1200
1201 struct macho_sync
1202 {
1203     struct process*     pcs;
1204     struct macho_info   macho_info;
1205 };
1206
1207 static BOOL macho_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user)
1208 {
1209     struct macho_sync*  ms = user;
1210
1211     TRACE("(%s, 0x%08lx, %p)\n", debugstr_w(name), addr, user);
1212     macho_search_and_load_file(ms->pcs, name, addr, &ms->macho_info);
1213     return TRUE;
1214 }
1215
1216 /******************************************************************
1217  *              macho_synchronize_module_list
1218  *
1219  * Rescans the debuggee's modules list and synchronizes it with
1220  * the one from 'pcs', ie:
1221  * - if a module is in debuggee and not in pcs, it's loaded into pcs
1222  * - if a module is in pcs and not in debuggee, it's unloaded from pcs
1223  */
1224 BOOL    macho_synchronize_module_list(struct process* pcs)
1225 {
1226     struct module*      module;
1227     struct macho_sync     ms;
1228
1229     TRACE("(%p/%p)\n", pcs, pcs->handle);
1230
1231     for (module = pcs->lmodules; module; module = module->next)
1232     {
1233         if (module->type == DMT_MACHO && !module->is_virtual)
1234             module->macho_info->in_use = 0;
1235     }
1236
1237     ms.pcs = pcs;
1238     ms.macho_info.flags = MACHO_INFO_MODULE;
1239     if (!macho_enum_modules_internal(pcs, NULL, macho_enum_sync_cb, &ms))
1240         return FALSE;
1241
1242     module = pcs->lmodules;
1243     while (module)
1244     {
1245         if (module->type == DMT_MACHO && !module->is_virtual &&
1246             !module->macho_info->in_use && !module->macho_info->is_loader)
1247         {
1248             module_remove(pcs, module);
1249             /* restart all over */
1250             module = pcs->lmodules;
1251         }
1252         else module = module->next;
1253     }
1254     return TRUE;
1255 }
1256
1257 /******************************************************************
1258  *              macho_search_loader
1259  *
1260  * Lookup in a running Mach-O process the loader, and sets its Mach-O link
1261  * address (for accessing the list of loaded images) in pcs.
1262  * If flags is MACHO_INFO_MODULE, the module for the loader is also
1263  * added as a module into pcs.
1264  */
1265 static BOOL macho_search_loader(struct process* pcs, struct macho_info* macho_info)
1266 {
1267     BOOL                ret;
1268     const char*         ptr;
1269
1270     TRACE("(%p/%p, %p)\n", pcs, pcs->handle, macho_info);
1271
1272     /* All binaries are loaded with WINELOADER (if run from tree) or by the
1273      * main executable
1274      */
1275     if ((ptr = getenv("WINELOADER")))
1276     {
1277         WCHAR   tmp[MAX_PATH];
1278         MultiByteToWideChar(CP_UNIXCP, 0, ptr, -1, tmp, sizeof(tmp) / sizeof(WCHAR));
1279         ret = macho_search_and_load_file(pcs, tmp, 0, macho_info);
1280     }
1281     else
1282     {
1283         ret = macho_search_and_load_file(pcs, S_WineW, 0, macho_info);
1284     }
1285     return ret;
1286 }
1287
1288 /******************************************************************
1289  *              macho_read_wine_loader_dbg_info
1290  *
1291  * Try to find a decent wine executable which could have loaded the debuggee
1292  */
1293 BOOL macho_read_wine_loader_dbg_info(struct process* pcs)
1294 {
1295     struct macho_info     macho_info;
1296
1297     TRACE("(%p/%p)\n", pcs, pcs->handle);
1298     macho_info.flags = MACHO_INFO_DEBUG_HEADER | MACHO_INFO_MODULE;
1299     if (!macho_search_loader(pcs, &macho_info)) return FALSE;
1300     macho_info.module->macho_info->is_loader = 1;
1301     module_set_module(macho_info.module, S_WineLoaderW);
1302     return (pcs->dbg_hdr_addr = macho_info.dbg_hdr_addr) != 0;
1303 }
1304
1305 /******************************************************************
1306  *              macho_enum_modules
1307  *
1308  * Enumerates the Mach-O loaded modules from a running target (hProc)
1309  * This function doesn't require that someone has called SymInitialize
1310  * on this very process.
1311  */
1312 BOOL macho_enum_modules(HANDLE hProc, enum_modules_cb cb, void* user)
1313 {
1314     struct process      pcs;
1315     struct macho_info   macho_info;
1316     BOOL                ret;
1317
1318     TRACE("(%p, %p, %p)\n", hProc, cb, user);
1319     memset(&pcs, 0, sizeof(pcs));
1320     pcs.handle = hProc;
1321     macho_info.flags = MACHO_INFO_DEBUG_HEADER | MACHO_INFO_NAME;
1322     if (!macho_search_loader(&pcs, &macho_info)) return FALSE;
1323     pcs.dbg_hdr_addr = macho_info.dbg_hdr_addr;
1324     ret = macho_enum_modules_internal(&pcs, macho_info.module_name, cb, user);
1325     HeapFree(GetProcessHeap(), 0, (char*)macho_info.module_name);
1326     return ret;
1327 }
1328
1329 struct macho_load
1330 {
1331     struct process*     pcs;
1332     struct macho_info   macho_info;
1333     const WCHAR*        name;
1334     BOOL                ret;
1335 };
1336
1337 /******************************************************************
1338  *              macho_load_cb
1339  *
1340  * Callback for macho_load_module, used to walk the list of loaded
1341  * modules.
1342  */
1343 static BOOL macho_load_cb(const WCHAR* name, unsigned long addr, void* user)
1344 {
1345     struct macho_load*  ml = user;
1346     const WCHAR*        p;
1347
1348     TRACE("(%s, 0x%08lx, %p)\n", debugstr_w(name), addr, user);
1349
1350     /* memcmp is needed for matches when bufstr contains also version information
1351      * ml->name: libc.so, name: libc.so.6.0
1352      */
1353     p = strrchrW(name, '/');
1354     if (!p++) p = name;
1355     if (!memcmp(p, ml->name, lstrlenW(ml->name) * sizeof(WCHAR)))
1356     {
1357         ml->ret = macho_search_and_load_file(ml->pcs, name, addr, &ml->macho_info);
1358         return FALSE;
1359     }
1360     return TRUE;
1361 }
1362
1363 /******************************************************************
1364  *              macho_load_module
1365  *
1366  * Loads a Mach-O module and stores it in process' module list.
1367  * Also, find module real name and load address from
1368  * the real loaded modules list in pcs address space.
1369  */
1370 struct module*  macho_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1371 {
1372     struct macho_load   ml;
1373
1374     TRACE("(%p/%p, %s, 0x%08lx)\n", pcs, pcs->handle, debugstr_w(name), addr);
1375
1376     ml.macho_info.flags = MACHO_INFO_MODULE;
1377     ml.ret = FALSE;
1378
1379     if (pcs->dbg_hdr_addr) /* we're debugging a live target */
1380     {
1381         ml.pcs = pcs;
1382         /* do only the lookup from the filename, not the path (as we lookup module
1383          * name in the process' loaded module list)
1384          */
1385         ml.name = strrchrW(name, '/');
1386         if (!ml.name++) ml.name = name;
1387         ml.ret = FALSE;
1388
1389         if (!macho_enum_modules_internal(pcs, NULL, macho_load_cb, &ml))
1390             return NULL;
1391     }
1392     else if (addr)
1393     {
1394         ml.name = name;
1395         ml.ret = macho_search_and_load_file(pcs, ml.name, addr, &ml.macho_info);
1396     }
1397     if (!ml.ret) return NULL;
1398     assert(ml.macho_info.module);
1399     return ml.macho_info.module;
1400 }
1401
1402 #else   /* !__MACH__ */
1403
1404 BOOL    macho_synchronize_module_list(struct process* pcs)
1405 {
1406     return FALSE;
1407 }
1408
1409 BOOL macho_fetch_file_info(const WCHAR* name, DWORD* base,
1410                            DWORD* size, DWORD* checksum)
1411 {
1412     return FALSE;
1413 }
1414
1415 BOOL macho_read_wine_loader_dbg_info(struct process* pcs)
1416 {
1417     return FALSE;
1418 }
1419
1420 BOOL macho_enum_modules(HANDLE hProc, enum_modules_cb cb, void* user)
1421 {
1422     return FALSE;
1423 }
1424
1425 struct module*  macho_load_module(struct process* pcs, const WCHAR* name, unsigned long addr)
1426 {
1427     return NULL;
1428 }
1429
1430 BOOL macho_load_debug_info(struct module* module, struct macho_file_map* fmap)
1431 {
1432     return FALSE;
1433 }
1434 #endif  /* __MACH__ */