1 //===-- ObjectFileMachO.cpp -------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/StringRef.h"
11 
12 #include "lldb/lldb-private-log.h"
13 #include "lldb/Core/ArchSpec.h"
14 #include "lldb/Core/DataBuffer.h"
15 #include "lldb/Core/Debugger.h"
16 #include "lldb/Core/Error.h"
17 #include "lldb/Core/FileSpecList.h"
18 #include "lldb/Core/Log.h"
19 #include "lldb/Core/Module.h"
20 #include "lldb/Core/ModuleSpec.h"
21 #include "lldb/Core/PluginManager.h"
22 #include "lldb/Core/RangeMap.h"
23 #include "lldb/Core/Section.h"
24 #include "lldb/Core/StreamFile.h"
25 #include "lldb/Core/StreamString.h"
26 #include "lldb/Core/Timer.h"
27 #include "lldb/Core/UUID.h"
28 #include "lldb/Host/Host.h"
29 #include "lldb/Host/FileSpec.h"
30 #include "lldb/Symbol/ClangNamespaceDecl.h"
31 #include "lldb/Symbol/DWARFCallFrameInfo.h"
32 #include "lldb/Symbol/ObjectFile.h"
33 #include "lldb/Target/Platform.h"
34 #include "lldb/Target/Process.h"
35 #include "lldb/Target/SectionLoadList.h"
36 #include "lldb/Target/Target.h"
37 #include "lldb/Target/Thread.h"
38 #include "lldb/Target/ThreadList.h"
39 #include "Plugins/Process/Utility/RegisterContextDarwin_arm.h"
40 #include "Plugins/Process/Utility/RegisterContextDarwin_arm64.h"
41 #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
42 #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
43 
44 #include "lldb/Utility/SafeMachO.h"
45 
46 #include "ObjectFileMachO.h"
47 
48 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
49 // GetLLDBSharedCacheUUID() needs to call dlsym()
50 #include <dlfcn.h>
51 #endif
52 
53 #ifndef __APPLE__
54 #include "Utility/UuidCompatibility.h"
55 #endif
56 
57 using namespace lldb;
58 using namespace lldb_private;
59 using namespace llvm::MachO;
60 
61 class RegisterContextDarwin_x86_64_Mach : public RegisterContextDarwin_x86_64
62 {
63 public:
64     RegisterContextDarwin_x86_64_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
65         RegisterContextDarwin_x86_64 (thread, 0)
66     {
67         SetRegisterDataFrom_LC_THREAD (data);
68     }
69 
70     virtual void
71     InvalidateAllRegisters ()
72     {
73         // Do nothing... registers are always valid...
74     }
75 
76     void
77     SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
78     {
79         lldb::offset_t offset = 0;
80         SetError (GPRRegSet, Read, -1);
81         SetError (FPURegSet, Read, -1);
82         SetError (EXCRegSet, Read, -1);
83         bool done = false;
84 
85         while (!done)
86         {
87             int flavor = data.GetU32 (&offset);
88             if (flavor == 0)
89                 done = true;
90             else
91             {
92                 uint32_t i;
93                 uint32_t count = data.GetU32 (&offset);
94                 switch (flavor)
95                 {
96                     case GPRRegSet:
97                         for (i=0; i<count; ++i)
98                             (&gpr.rax)[i] = data.GetU64(&offset);
99                         SetError (GPRRegSet, Read, 0);
100                         done = true;
101 
102                         break;
103                     case FPURegSet:
104                         // TODO: fill in FPU regs....
105                         //SetError (FPURegSet, Read, -1);
106                         done = true;
107 
108                         break;
109                     case EXCRegSet:
110                         exc.trapno = data.GetU32(&offset);
111                         exc.err = data.GetU32(&offset);
112                         exc.faultvaddr = data.GetU64(&offset);
113                         SetError (EXCRegSet, Read, 0);
114                         done = true;
115                         break;
116                     case 7:
117                     case 8:
118                     case 9:
119                         // fancy flavors that encapsulate of the above
120                         // flavors...
121                         break;
122 
123                     default:
124                         done = true;
125                         break;
126                 }
127             }
128         }
129     }
130 
131 
132     static size_t
133     WriteRegister (RegisterContext *reg_ctx, const char *name, const char *alt_name, size_t reg_byte_size, Stream &data)
134     {
135         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name);
136         if (reg_info == NULL)
137             reg_info = reg_ctx->GetRegisterInfoByName(alt_name);
138         if (reg_info)
139         {
140             lldb_private::RegisterValue reg_value;
141             if (reg_ctx->ReadRegister(reg_info, reg_value))
142             {
143                 if (reg_info->byte_size >= reg_byte_size)
144                     data.Write(reg_value.GetBytes(), reg_byte_size);
145                 else
146                 {
147                     data.Write(reg_value.GetBytes(), reg_info->byte_size);
148                     for (size_t i=0, n = reg_byte_size - reg_info->byte_size; i<n; ++ i)
149                         data.PutChar(0);
150                 }
151                 return reg_byte_size;
152             }
153         }
154         // Just write zeros if all else fails
155         for (size_t i=0; i<reg_byte_size; ++ i)
156             data.PutChar(0);
157         return reg_byte_size;
158     }
159 
160     static bool
161     Create_LC_THREAD (Thread *thread, Stream &data)
162     {
163         RegisterContextSP reg_ctx_sp (thread->GetRegisterContext());
164         if (reg_ctx_sp)
165         {
166             RegisterContext *reg_ctx = reg_ctx_sp.get();
167 
168             data.PutHex32 (GPRRegSet);  // Flavor
169             data.PutHex32 (GPRWordCount);
170             WriteRegister (reg_ctx, "rax", NULL, 8, data);
171             WriteRegister (reg_ctx, "rbx", NULL, 8, data);
172             WriteRegister (reg_ctx, "rcx", NULL, 8, data);
173             WriteRegister (reg_ctx, "rdx", NULL, 8, data);
174             WriteRegister (reg_ctx, "rdi", NULL, 8, data);
175             WriteRegister (reg_ctx, "rsi", NULL, 8, data);
176             WriteRegister (reg_ctx, "rbp", NULL, 8, data);
177             WriteRegister (reg_ctx, "rsp", NULL, 8, data);
178             WriteRegister (reg_ctx, "r8", NULL, 8, data);
179             WriteRegister (reg_ctx, "r9", NULL, 8, data);
180             WriteRegister (reg_ctx, "r10", NULL, 8, data);
181             WriteRegister (reg_ctx, "r11", NULL, 8, data);
182             WriteRegister (reg_ctx, "r12", NULL, 8, data);
183             WriteRegister (reg_ctx, "r13", NULL, 8, data);
184             WriteRegister (reg_ctx, "r14", NULL, 8, data);
185             WriteRegister (reg_ctx, "r15", NULL, 8, data);
186             WriteRegister (reg_ctx, "rip", NULL, 8, data);
187             WriteRegister (reg_ctx, "rflags", NULL, 8, data);
188             WriteRegister (reg_ctx, "cs", NULL, 8, data);
189             WriteRegister (reg_ctx, "fs", NULL, 8, data);
190             WriteRegister (reg_ctx, "gs", NULL, 8, data);
191 
192 //            // Write out the FPU registers
193 //            const size_t fpu_byte_size = sizeof(FPU);
194 //            size_t bytes_written = 0;
195 //            data.PutHex32 (FPURegSet);
196 //            data.PutHex32 (fpu_byte_size/sizeof(uint64_t));
197 //            bytes_written += data.PutHex32(0);                                   // uint32_t pad[0]
198 //            bytes_written += data.PutHex32(0);                                   // uint32_t pad[1]
199 //            bytes_written += WriteRegister (reg_ctx, "fcw", "fctrl", 2, data);   // uint16_t    fcw;    // "fctrl"
200 //            bytes_written += WriteRegister (reg_ctx, "fsw" , "fstat", 2, data);  // uint16_t    fsw;    // "fstat"
201 //            bytes_written += WriteRegister (reg_ctx, "ftw" , "ftag", 1, data);   // uint8_t     ftw;    // "ftag"
202 //            bytes_written += data.PutHex8  (0);                                  // uint8_t pad1;
203 //            bytes_written += WriteRegister (reg_ctx, "fop" , NULL, 2, data);     // uint16_t    fop;    // "fop"
204 //            bytes_written += WriteRegister (reg_ctx, "fioff", "ip", 4, data);    // uint32_t    ip;     // "fioff"
205 //            bytes_written += WriteRegister (reg_ctx, "fiseg", NULL, 2, data);    // uint16_t    cs;     // "fiseg"
206 //            bytes_written += data.PutHex16 (0);                                  // uint16_t    pad2;
207 //            bytes_written += WriteRegister (reg_ctx, "dp", "fooff" , 4, data);   // uint32_t    dp;     // "fooff"
208 //            bytes_written += WriteRegister (reg_ctx, "foseg", NULL, 2, data);    // uint16_t    ds;     // "foseg"
209 //            bytes_written += data.PutHex16 (0);                                  // uint16_t    pad3;
210 //            bytes_written += WriteRegister (reg_ctx, "mxcsr", NULL, 4, data);    // uint32_t    mxcsr;
211 //            bytes_written += WriteRegister (reg_ctx, "mxcsrmask", NULL, 4, data);// uint32_t    mxcsrmask;
212 //            bytes_written += WriteRegister (reg_ctx, "stmm0", NULL, sizeof(MMSReg), data);
213 //            bytes_written += WriteRegister (reg_ctx, "stmm1", NULL, sizeof(MMSReg), data);
214 //            bytes_written += WriteRegister (reg_ctx, "stmm2", NULL, sizeof(MMSReg), data);
215 //            bytes_written += WriteRegister (reg_ctx, "stmm3", NULL, sizeof(MMSReg), data);
216 //            bytes_written += WriteRegister (reg_ctx, "stmm4", NULL, sizeof(MMSReg), data);
217 //            bytes_written += WriteRegister (reg_ctx, "stmm5", NULL, sizeof(MMSReg), data);
218 //            bytes_written += WriteRegister (reg_ctx, "stmm6", NULL, sizeof(MMSReg), data);
219 //            bytes_written += WriteRegister (reg_ctx, "stmm7", NULL, sizeof(MMSReg), data);
220 //            bytes_written += WriteRegister (reg_ctx, "xmm0" , NULL, sizeof(XMMReg), data);
221 //            bytes_written += WriteRegister (reg_ctx, "xmm1" , NULL, sizeof(XMMReg), data);
222 //            bytes_written += WriteRegister (reg_ctx, "xmm2" , NULL, sizeof(XMMReg), data);
223 //            bytes_written += WriteRegister (reg_ctx, "xmm3" , NULL, sizeof(XMMReg), data);
224 //            bytes_written += WriteRegister (reg_ctx, "xmm4" , NULL, sizeof(XMMReg), data);
225 //            bytes_written += WriteRegister (reg_ctx, "xmm5" , NULL, sizeof(XMMReg), data);
226 //            bytes_written += WriteRegister (reg_ctx, "xmm6" , NULL, sizeof(XMMReg), data);
227 //            bytes_written += WriteRegister (reg_ctx, "xmm7" , NULL, sizeof(XMMReg), data);
228 //            bytes_written += WriteRegister (reg_ctx, "xmm8" , NULL, sizeof(XMMReg), data);
229 //            bytes_written += WriteRegister (reg_ctx, "xmm9" , NULL, sizeof(XMMReg), data);
230 //            bytes_written += WriteRegister (reg_ctx, "xmm10", NULL, sizeof(XMMReg), data);
231 //            bytes_written += WriteRegister (reg_ctx, "xmm11", NULL, sizeof(XMMReg), data);
232 //            bytes_written += WriteRegister (reg_ctx, "xmm12", NULL, sizeof(XMMReg), data);
233 //            bytes_written += WriteRegister (reg_ctx, "xmm13", NULL, sizeof(XMMReg), data);
234 //            bytes_written += WriteRegister (reg_ctx, "xmm14", NULL, sizeof(XMMReg), data);
235 //            bytes_written += WriteRegister (reg_ctx, "xmm15", NULL, sizeof(XMMReg), data);
236 //
237 //            // Fill rest with zeros
238 //            for (size_t i=0, n = fpu_byte_size - bytes_written; i<n; ++ i)
239 //                data.PutChar(0);
240 
241             // Write out the EXC registers
242             data.PutHex32 (EXCRegSet);
243             data.PutHex32 (EXCWordCount);
244             WriteRegister (reg_ctx, "trapno", NULL, 4, data);
245             WriteRegister (reg_ctx, "err", NULL, 4, data);
246             WriteRegister (reg_ctx, "faultvaddr", NULL, 8, data);
247             return true;
248         }
249         return false;
250     }
251 
252 protected:
253     virtual int
254     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
255     {
256         return 0;
257     }
258 
259     virtual int
260     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
261     {
262         return 0;
263     }
264 
265     virtual int
266     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
267     {
268         return 0;
269     }
270 
271     virtual int
272     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
273     {
274         return 0;
275     }
276 
277     virtual int
278     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
279     {
280         return 0;
281     }
282 
283     virtual int
284     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
285     {
286         return 0;
287     }
288 };
289 
290 
291 class RegisterContextDarwin_i386_Mach : public RegisterContextDarwin_i386
292 {
293 public:
294     RegisterContextDarwin_i386_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
295     RegisterContextDarwin_i386 (thread, 0)
296     {
297         SetRegisterDataFrom_LC_THREAD (data);
298     }
299 
300     virtual void
301     InvalidateAllRegisters ()
302     {
303         // Do nothing... registers are always valid...
304     }
305 
306     void
307     SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
308     {
309         lldb::offset_t offset = 0;
310         SetError (GPRRegSet, Read, -1);
311         SetError (FPURegSet, Read, -1);
312         SetError (EXCRegSet, Read, -1);
313         bool done = false;
314 
315         while (!done)
316         {
317             int flavor = data.GetU32 (&offset);
318             if (flavor == 0)
319                 done = true;
320             else
321             {
322                 uint32_t i;
323                 uint32_t count = data.GetU32 (&offset);
324                 switch (flavor)
325                 {
326                     case GPRRegSet:
327                         for (i=0; i<count; ++i)
328                             (&gpr.eax)[i] = data.GetU32(&offset);
329                         SetError (GPRRegSet, Read, 0);
330                         done = true;
331 
332                         break;
333                     case FPURegSet:
334                         // TODO: fill in FPU regs....
335                         //SetError (FPURegSet, Read, -1);
336                         done = true;
337 
338                         break;
339                     case EXCRegSet:
340                         exc.trapno = data.GetU32(&offset);
341                         exc.err = data.GetU32(&offset);
342                         exc.faultvaddr = data.GetU32(&offset);
343                         SetError (EXCRegSet, Read, 0);
344                         done = true;
345                         break;
346                     case 7:
347                     case 8:
348                     case 9:
349                         // fancy flavors that encapsulate of the above
350                         // flavors...
351                         break;
352 
353                     default:
354                         done = true;
355                         break;
356                 }
357             }
358         }
359     }
360 
361     static size_t
362     WriteRegister (RegisterContext *reg_ctx, const char *name, const char *alt_name, size_t reg_byte_size, Stream &data)
363     {
364         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name);
365         if (reg_info == NULL)
366             reg_info = reg_ctx->GetRegisterInfoByName(alt_name);
367         if (reg_info)
368         {
369             lldb_private::RegisterValue reg_value;
370             if (reg_ctx->ReadRegister(reg_info, reg_value))
371             {
372                 if (reg_info->byte_size >= reg_byte_size)
373                     data.Write(reg_value.GetBytes(), reg_byte_size);
374                 else
375                 {
376                     data.Write(reg_value.GetBytes(), reg_info->byte_size);
377                     for (size_t i=0, n = reg_byte_size - reg_info->byte_size; i<n; ++ i)
378                         data.PutChar(0);
379                 }
380                 return reg_byte_size;
381             }
382         }
383         // Just write zeros if all else fails
384         for (size_t i=0; i<reg_byte_size; ++ i)
385             data.PutChar(0);
386         return reg_byte_size;
387     }
388 
389     static bool
390     Create_LC_THREAD (Thread *thread, Stream &data)
391     {
392         RegisterContextSP reg_ctx_sp (thread->GetRegisterContext());
393         if (reg_ctx_sp)
394         {
395             RegisterContext *reg_ctx = reg_ctx_sp.get();
396 
397             data.PutHex32 (GPRRegSet);  // Flavor
398             data.PutHex32 (GPRWordCount);
399             WriteRegister (reg_ctx, "eax", NULL, 4, data);
400             WriteRegister (reg_ctx, "ebx", NULL, 4, data);
401             WriteRegister (reg_ctx, "ecx", NULL, 4, data);
402             WriteRegister (reg_ctx, "edx", NULL, 4, data);
403             WriteRegister (reg_ctx, "edi", NULL, 4, data);
404             WriteRegister (reg_ctx, "esi", NULL, 4, data);
405             WriteRegister (reg_ctx, "ebp", NULL, 4, data);
406             WriteRegister (reg_ctx, "esp", NULL, 4, data);
407             WriteRegister (reg_ctx, "ss", NULL, 4, data);
408             WriteRegister (reg_ctx, "eflags", NULL, 4, data);
409             WriteRegister (reg_ctx, "eip", NULL, 4, data);
410             WriteRegister (reg_ctx, "cs", NULL, 4, data);
411             WriteRegister (reg_ctx, "ds", NULL, 4, data);
412             WriteRegister (reg_ctx, "es", NULL, 4, data);
413             WriteRegister (reg_ctx, "fs", NULL, 4, data);
414             WriteRegister (reg_ctx, "gs", NULL, 4, data);
415 
416             // Write out the EXC registers
417             data.PutHex32 (EXCRegSet);
418             data.PutHex32 (EXCWordCount);
419             WriteRegister (reg_ctx, "trapno", NULL, 4, data);
420             WriteRegister (reg_ctx, "err", NULL, 4, data);
421             WriteRegister (reg_ctx, "faultvaddr", NULL, 4, data);
422             return true;
423         }
424         return false;
425     }
426 
427 protected:
428     virtual int
429     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
430     {
431         return 0;
432     }
433 
434     virtual int
435     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
436     {
437         return 0;
438     }
439 
440     virtual int
441     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
442     {
443         return 0;
444     }
445 
446     virtual int
447     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
448     {
449         return 0;
450     }
451 
452     virtual int
453     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
454     {
455         return 0;
456     }
457 
458     virtual int
459     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
460     {
461         return 0;
462     }
463 };
464 
465 class RegisterContextDarwin_arm_Mach : public RegisterContextDarwin_arm
466 {
467 public:
468     RegisterContextDarwin_arm_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
469         RegisterContextDarwin_arm (thread, 0)
470     {
471         SetRegisterDataFrom_LC_THREAD (data);
472     }
473 
474     virtual void
475     InvalidateAllRegisters ()
476     {
477         // Do nothing... registers are always valid...
478     }
479 
480     void
481     SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
482     {
483         lldb::offset_t offset = 0;
484         SetError (GPRRegSet, Read, -1);
485         SetError (FPURegSet, Read, -1);
486         SetError (EXCRegSet, Read, -1);
487         bool done = false;
488 
489         while (!done)
490         {
491             int flavor = data.GetU32 (&offset);
492             uint32_t count = data.GetU32 (&offset);
493             lldb::offset_t next_thread_state = offset + (count * 4);
494             switch (flavor)
495             {
496                 case GPRRegSet:
497                     for (uint32_t i=0; i<count; ++i)
498                     {
499                         gpr.r[i] = data.GetU32(&offset);
500                     }
501 
502                     // Note that gpr.cpsr is also copied by the above loop; this loop technically extends
503                     // one element past the end of the gpr.r[] array.
504 
505                     SetError (GPRRegSet, Read, 0);
506                     offset = next_thread_state;
507                     break;
508 
509                 case FPURegSet:
510                     {
511                         uint8_t  *fpu_reg_buf = (uint8_t*) &fpu.floats.s[0];
512                         const int fpu_reg_buf_size = sizeof (fpu.floats);
513                         if (data.ExtractBytes (offset, fpu_reg_buf_size, eByteOrderLittle, fpu_reg_buf) == fpu_reg_buf_size)
514                         {
515                             offset += fpu_reg_buf_size;
516                             fpu.fpscr = data.GetU32(&offset);
517                             SetError (FPURegSet, Read, 0);
518                         }
519                         else
520                         {
521                             done = true;
522                         }
523                     }
524                     offset = next_thread_state;
525                     break;
526 
527                 case EXCRegSet:
528                     if (count == 3)
529                     {
530                         exc.exception = data.GetU32(&offset);
531                         exc.fsr = data.GetU32(&offset);
532                         exc.far = data.GetU32(&offset);
533                         SetError (EXCRegSet, Read, 0);
534                     }
535                     done = true;
536                     offset = next_thread_state;
537                     break;
538 
539                 // Unknown register set flavor, stop trying to parse.
540                 default:
541                     done = true;
542             }
543         }
544     }
545 
546     static size_t
547     WriteRegister (RegisterContext *reg_ctx, const char *name, const char *alt_name, size_t reg_byte_size, Stream &data)
548     {
549         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name);
550         if (reg_info == NULL)
551             reg_info = reg_ctx->GetRegisterInfoByName(alt_name);
552         if (reg_info)
553         {
554             lldb_private::RegisterValue reg_value;
555             if (reg_ctx->ReadRegister(reg_info, reg_value))
556             {
557                 if (reg_info->byte_size >= reg_byte_size)
558                     data.Write(reg_value.GetBytes(), reg_byte_size);
559                 else
560                 {
561                     data.Write(reg_value.GetBytes(), reg_info->byte_size);
562                     for (size_t i=0, n = reg_byte_size - reg_info->byte_size; i<n; ++ i)
563                         data.PutChar(0);
564                 }
565                 return reg_byte_size;
566             }
567         }
568         // Just write zeros if all else fails
569         for (size_t i=0; i<reg_byte_size; ++ i)
570             data.PutChar(0);
571         return reg_byte_size;
572     }
573 
574     static bool
575     Create_LC_THREAD (Thread *thread, Stream &data)
576     {
577         RegisterContextSP reg_ctx_sp (thread->GetRegisterContext());
578         if (reg_ctx_sp)
579         {
580             RegisterContext *reg_ctx = reg_ctx_sp.get();
581 
582             data.PutHex32 (GPRRegSet);  // Flavor
583             data.PutHex32 (GPRWordCount);
584             WriteRegister (reg_ctx, "r0", NULL, 4, data);
585             WriteRegister (reg_ctx, "r1", NULL, 4, data);
586             WriteRegister (reg_ctx, "r2", NULL, 4, data);
587             WriteRegister (reg_ctx, "r3", NULL, 4, data);
588             WriteRegister (reg_ctx, "r4", NULL, 4, data);
589             WriteRegister (reg_ctx, "r5", NULL, 4, data);
590             WriteRegister (reg_ctx, "r6", NULL, 4, data);
591             WriteRegister (reg_ctx, "r7", NULL, 4, data);
592             WriteRegister (reg_ctx, "r8", NULL, 4, data);
593             WriteRegister (reg_ctx, "r9", NULL, 4, data);
594             WriteRegister (reg_ctx, "r10", NULL, 4, data);
595             WriteRegister (reg_ctx, "r11", NULL, 4, data);
596             WriteRegister (reg_ctx, "r12", NULL, 4, data);
597             WriteRegister (reg_ctx, "sp", NULL, 4, data);
598             WriteRegister (reg_ctx, "lr", NULL, 4, data);
599             WriteRegister (reg_ctx, "pc", NULL, 4, data);
600             WriteRegister (reg_ctx, "cpsr", NULL, 4, data);
601 
602             // Write out the EXC registers
603 //            data.PutHex32 (EXCRegSet);
604 //            data.PutHex32 (EXCWordCount);
605 //            WriteRegister (reg_ctx, "exception", NULL, 4, data);
606 //            WriteRegister (reg_ctx, "fsr", NULL, 4, data);
607 //            WriteRegister (reg_ctx, "far", NULL, 4, data);
608             return true;
609         }
610         return false;
611     }
612 
613 protected:
614     virtual int
615     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
616     {
617         return -1;
618     }
619 
620     virtual int
621     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
622     {
623         return -1;
624     }
625 
626     virtual int
627     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
628     {
629         return -1;
630     }
631 
632     virtual int
633     DoReadDBG (lldb::tid_t tid, int flavor, DBG &dbg)
634     {
635         return -1;
636     }
637 
638     virtual int
639     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
640     {
641         return 0;
642     }
643 
644     virtual int
645     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
646     {
647         return 0;
648     }
649 
650     virtual int
651     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
652     {
653         return 0;
654     }
655 
656     virtual int
657     DoWriteDBG (lldb::tid_t tid, int flavor, const DBG &dbg)
658     {
659         return -1;
660     }
661 };
662 
663 class RegisterContextDarwin_arm64_Mach : public RegisterContextDarwin_arm64
664 {
665 public:
666     RegisterContextDarwin_arm64_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
667         RegisterContextDarwin_arm64 (thread, 0)
668     {
669         SetRegisterDataFrom_LC_THREAD (data);
670     }
671 
672     virtual void
673     InvalidateAllRegisters ()
674     {
675         // Do nothing... registers are always valid...
676     }
677 
678     void
679     SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
680     {
681         lldb::offset_t offset = 0;
682         SetError (GPRRegSet, Read, -1);
683         SetError (FPURegSet, Read, -1);
684         SetError (EXCRegSet, Read, -1);
685         bool done = false;
686         while (!done)
687         {
688             int flavor = data.GetU32 (&offset);
689             uint32_t count = data.GetU32 (&offset);
690             lldb::offset_t next_thread_state = offset + (count * 4);
691             switch (flavor)
692             {
693                 case GPRRegSet:
694                     // x0-x29 + fp + lr + sp + pc (== 33 64-bit registers) plus cpsr (1 32-bit register)
695                     if (count >= (33 * 2) + 1)
696                     {
697                         for (uint32_t i=0; i<33; ++i)
698                             gpr.x[i] = data.GetU64(&offset);
699                         gpr.cpsr = data.GetU32(&offset);
700                         SetError (GPRRegSet, Read, 0);
701                     }
702                     offset = next_thread_state;
703                     break;
704                 case FPURegSet:
705                     {
706                         uint8_t *fpu_reg_buf = (uint8_t*) &fpu.v[0];
707                         const int fpu_reg_buf_size = sizeof (fpu);
708                         if (fpu_reg_buf_size == count
709                             && data.ExtractBytes (offset, fpu_reg_buf_size, eByteOrderLittle, fpu_reg_buf) == fpu_reg_buf_size)
710                         {
711                             SetError (FPURegSet, Read, 0);
712                         }
713                         else
714                         {
715                             done = true;
716                         }
717                     }
718                     offset = next_thread_state;
719                     break;
720                 case EXCRegSet:
721                     if (count == 4)
722                     {
723                         exc.far = data.GetU64(&offset);
724                         exc.esr = data.GetU32(&offset);
725                         exc.exception = data.GetU32(&offset);
726                         SetError (EXCRegSet, Read, 0);
727                     }
728                     offset = next_thread_state;
729                     break;
730                 default:
731                     done = true;
732                     break;
733             }
734         }
735     }
736 
737     static size_t
738     WriteRegister (RegisterContext *reg_ctx, const char *name, const char *alt_name, size_t reg_byte_size, Stream &data)
739     {
740         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name);
741         if (reg_info == NULL)
742             reg_info = reg_ctx->GetRegisterInfoByName(alt_name);
743         if (reg_info)
744         {
745             lldb_private::RegisterValue reg_value;
746             if (reg_ctx->ReadRegister(reg_info, reg_value))
747             {
748                 if (reg_info->byte_size >= reg_byte_size)
749                     data.Write(reg_value.GetBytes(), reg_byte_size);
750                 else
751                 {
752                     data.Write(reg_value.GetBytes(), reg_info->byte_size);
753                     for (size_t i=0, n = reg_byte_size - reg_info->byte_size; i<n; ++ i)
754                         data.PutChar(0);
755                 }
756                 return reg_byte_size;
757             }
758         }
759         // Just write zeros if all else fails
760         for (size_t i=0; i<reg_byte_size; ++ i)
761             data.PutChar(0);
762         return reg_byte_size;
763     }
764 
765     static bool
766     Create_LC_THREAD (Thread *thread, Stream &data)
767     {
768         RegisterContextSP reg_ctx_sp (thread->GetRegisterContext());
769         if (reg_ctx_sp)
770         {
771             RegisterContext *reg_ctx = reg_ctx_sp.get();
772 
773             data.PutHex32 (GPRRegSet);  // Flavor
774             data.PutHex32 (GPRWordCount);
775             WriteRegister (reg_ctx, "x0", NULL, 8, data);
776             WriteRegister (reg_ctx, "x1", NULL, 8, data);
777             WriteRegister (reg_ctx, "x2", NULL, 8, data);
778             WriteRegister (reg_ctx, "x3", NULL, 8, data);
779             WriteRegister (reg_ctx, "x4", NULL, 8, data);
780             WriteRegister (reg_ctx, "x5", NULL, 8, data);
781             WriteRegister (reg_ctx, "x6", NULL, 8, data);
782             WriteRegister (reg_ctx, "x7", NULL, 8, data);
783             WriteRegister (reg_ctx, "x8", NULL, 8, data);
784             WriteRegister (reg_ctx, "x9", NULL, 8, data);
785             WriteRegister (reg_ctx, "x10", NULL, 8, data);
786             WriteRegister (reg_ctx, "x11", NULL, 8, data);
787             WriteRegister (reg_ctx, "x12", NULL, 8, data);
788             WriteRegister (reg_ctx, "x13", NULL, 8, data);
789             WriteRegister (reg_ctx, "x14", NULL, 8, data);
790             WriteRegister (reg_ctx, "x15", NULL, 8, data);
791             WriteRegister (reg_ctx, "x16", NULL, 8, data);
792             WriteRegister (reg_ctx, "x17", NULL, 8, data);
793             WriteRegister (reg_ctx, "x18", NULL, 8, data);
794             WriteRegister (reg_ctx, "x19", NULL, 8, data);
795             WriteRegister (reg_ctx, "x20", NULL, 8, data);
796             WriteRegister (reg_ctx, "x21", NULL, 8, data);
797             WriteRegister (reg_ctx, "x22", NULL, 8, data);
798             WriteRegister (reg_ctx, "x23", NULL, 8, data);
799             WriteRegister (reg_ctx, "x24", NULL, 8, data);
800             WriteRegister (reg_ctx, "x25", NULL, 8, data);
801             WriteRegister (reg_ctx, "x26", NULL, 8, data);
802             WriteRegister (reg_ctx, "x27", NULL, 8, data);
803             WriteRegister (reg_ctx, "x28", NULL, 8, data);
804             WriteRegister (reg_ctx, "fp", NULL, 8, data);
805             WriteRegister (reg_ctx, "lr", NULL, 8, data);
806             WriteRegister (reg_ctx, "sp", NULL, 8, data);
807             WriteRegister (reg_ctx, "pc", NULL, 8, data);
808             WriteRegister (reg_ctx, "cpsr", NULL, 4, data);
809 
810             // Write out the EXC registers
811 //            data.PutHex32 (EXCRegSet);
812 //            data.PutHex32 (EXCWordCount);
813 //            WriteRegister (reg_ctx, "far", NULL, 8, data);
814 //            WriteRegister (reg_ctx, "esr", NULL, 4, data);
815 //            WriteRegister (reg_ctx, "exception", NULL, 4, data);
816             return true;
817         }
818         return false;
819     }
820 
821 protected:
822     virtual int
823     DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
824     {
825         return -1;
826     }
827 
828     virtual int
829     DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
830     {
831         return -1;
832     }
833 
834     virtual int
835     DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
836     {
837         return -1;
838     }
839 
840     virtual int
841     DoReadDBG (lldb::tid_t tid, int flavor, DBG &dbg)
842     {
843         return -1;
844     }
845 
846     virtual int
847     DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
848     {
849         return 0;
850     }
851 
852     virtual int
853     DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
854     {
855         return 0;
856     }
857 
858     virtual int
859     DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
860     {
861         return 0;
862     }
863 
864     virtual int
865     DoWriteDBG (lldb::tid_t tid, int flavor, const DBG &dbg)
866     {
867         return -1;
868     }
869 };
870 
871 static uint32_t
872 MachHeaderSizeFromMagic(uint32_t magic)
873 {
874     switch (magic)
875     {
876         case MH_MAGIC:
877         case MH_CIGAM:
878             return sizeof(struct mach_header);
879 
880         case MH_MAGIC_64:
881         case MH_CIGAM_64:
882             return sizeof(struct mach_header_64);
883             break;
884 
885         default:
886             break;
887     }
888     return 0;
889 }
890 
891 #define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008
892 
893 void
894 ObjectFileMachO::Initialize()
895 {
896     PluginManager::RegisterPlugin (GetPluginNameStatic(),
897                                    GetPluginDescriptionStatic(),
898                                    CreateInstance,
899                                    CreateMemoryInstance,
900                                    GetModuleSpecifications,
901                                    SaveCore);
902 }
903 
904 void
905 ObjectFileMachO::Terminate()
906 {
907     PluginManager::UnregisterPlugin (CreateInstance);
908 }
909 
910 
911 lldb_private::ConstString
912 ObjectFileMachO::GetPluginNameStatic()
913 {
914     static ConstString g_name("mach-o");
915     return g_name;
916 }
917 
918 const char *
919 ObjectFileMachO::GetPluginDescriptionStatic()
920 {
921     return "Mach-o object file reader (32 and 64 bit)";
922 }
923 
924 ObjectFile *
925 ObjectFileMachO::CreateInstance (const lldb::ModuleSP &module_sp,
926                                  DataBufferSP& data_sp,
927                                  lldb::offset_t data_offset,
928                                  const FileSpec* file,
929                                  lldb::offset_t file_offset,
930                                  lldb::offset_t length)
931 {
932     if (!data_sp)
933     {
934         data_sp = file->MemoryMapFileContents(file_offset, length);
935         data_offset = 0;
936     }
937 
938     if (ObjectFileMachO::MagicBytesMatch(data_sp, data_offset, length))
939     {
940         // Update the data to contain the entire file if it doesn't already
941         if (data_sp->GetByteSize() < length)
942         {
943             data_sp = file->MemoryMapFileContents(file_offset, length);
944             data_offset = 0;
945         }
946         std::unique_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, data_offset, file, file_offset, length));
947         if (objfile_ap.get() && objfile_ap->ParseHeader())
948             return objfile_ap.release();
949     }
950     return NULL;
951 }
952 
953 ObjectFile *
954 ObjectFileMachO::CreateMemoryInstance (const lldb::ModuleSP &module_sp,
955                                        DataBufferSP& data_sp,
956                                        const ProcessSP &process_sp,
957                                        lldb::addr_t header_addr)
958 {
959     if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
960     {
961         std::unique_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, process_sp, header_addr));
962         if (objfile_ap.get() && objfile_ap->ParseHeader())
963             return objfile_ap.release();
964     }
965     return NULL;
966 }
967 
968 size_t
969 ObjectFileMachO::GetModuleSpecifications (const lldb_private::FileSpec& file,
970                                           lldb::DataBufferSP& data_sp,
971                                           lldb::offset_t data_offset,
972                                           lldb::offset_t file_offset,
973                                           lldb::offset_t length,
974                                           lldb_private::ModuleSpecList &specs)
975 {
976     const size_t initial_count = specs.GetSize();
977 
978     if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
979     {
980         DataExtractor data;
981         data.SetData(data_sp);
982         llvm::MachO::mach_header header;
983         if (ParseHeader (data, &data_offset, header))
984         {
985             size_t header_and_load_cmds = header.sizeofcmds + MachHeaderSizeFromMagic(header.magic);
986             if (header_and_load_cmds >= data_sp->GetByteSize())
987             {
988                 data_sp = file.ReadFileContents(file_offset, header_and_load_cmds);
989                 data.SetData(data_sp);
990                 data_offset = MachHeaderSizeFromMagic(header.magic);
991             }
992             if (data_sp)
993             {
994                 ModuleSpec spec;
995                 spec.GetFileSpec() = file;
996                 spec.SetObjectOffset(file_offset);
997 
998                 if (GetArchitecture (header, data, data_offset, spec.GetArchitecture()))
999                 {
1000                     if (spec.GetArchitecture().IsValid())
1001                     {
1002                         GetUUID (header, data, data_offset, spec.GetUUID());
1003                         specs.Append(spec);
1004                     }
1005                 }
1006             }
1007         }
1008     }
1009     return specs.GetSize() - initial_count;
1010 }
1011 
1012 
1013 
1014 const ConstString &
1015 ObjectFileMachO::GetSegmentNameTEXT()
1016 {
1017     static ConstString g_segment_name_TEXT ("__TEXT");
1018     return g_segment_name_TEXT;
1019 }
1020 
1021 const ConstString &
1022 ObjectFileMachO::GetSegmentNameDATA()
1023 {
1024     static ConstString g_segment_name_DATA ("__DATA");
1025     return g_segment_name_DATA;
1026 }
1027 
1028 const ConstString &
1029 ObjectFileMachO::GetSegmentNameOBJC()
1030 {
1031     static ConstString g_segment_name_OBJC ("__OBJC");
1032     return g_segment_name_OBJC;
1033 }
1034 
1035 const ConstString &
1036 ObjectFileMachO::GetSegmentNameLINKEDIT()
1037 {
1038     static ConstString g_section_name_LINKEDIT ("__LINKEDIT");
1039     return g_section_name_LINKEDIT;
1040 }
1041 
1042 const ConstString &
1043 ObjectFileMachO::GetSectionNameEHFrame()
1044 {
1045     static ConstString g_section_name_eh_frame ("__eh_frame");
1046     return g_section_name_eh_frame;
1047 }
1048 
1049 bool
1050 ObjectFileMachO::MagicBytesMatch (DataBufferSP& data_sp,
1051                                   lldb::addr_t data_offset,
1052                                   lldb::addr_t data_length)
1053 {
1054     DataExtractor data;
1055     data.SetData (data_sp, data_offset, data_length);
1056     lldb::offset_t offset = 0;
1057     uint32_t magic = data.GetU32(&offset);
1058     return MachHeaderSizeFromMagic(magic) != 0;
1059 }
1060 
1061 
1062 ObjectFileMachO::ObjectFileMachO(const lldb::ModuleSP &module_sp,
1063                                  DataBufferSP& data_sp,
1064                                  lldb::offset_t data_offset,
1065                                  const FileSpec* file,
1066                                  lldb::offset_t file_offset,
1067                                  lldb::offset_t length) :
1068     ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
1069     m_mach_segments(),
1070     m_mach_sections(),
1071     m_entry_point_address(),
1072     m_thread_context_offsets(),
1073     m_thread_context_offsets_valid(false)
1074 {
1075     ::memset (&m_header, 0, sizeof(m_header));
1076     ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
1077 }
1078 
1079 ObjectFileMachO::ObjectFileMachO (const lldb::ModuleSP &module_sp,
1080                                   lldb::DataBufferSP& header_data_sp,
1081                                   const lldb::ProcessSP &process_sp,
1082                                   lldb::addr_t header_addr) :
1083     ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
1084     m_mach_segments(),
1085     m_mach_sections(),
1086     m_entry_point_address(),
1087     m_thread_context_offsets(),
1088     m_thread_context_offsets_valid(false)
1089 {
1090     ::memset (&m_header, 0, sizeof(m_header));
1091     ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
1092 }
1093 
1094 ObjectFileMachO::~ObjectFileMachO()
1095 {
1096 }
1097 
1098 bool
1099 ObjectFileMachO::ParseHeader (DataExtractor &data,
1100                               lldb::offset_t *data_offset_ptr,
1101                               llvm::MachO::mach_header &header)
1102 {
1103     data.SetByteOrder (lldb::endian::InlHostByteOrder());
1104     // Leave magic in the original byte order
1105     header.magic = data.GetU32(data_offset_ptr);
1106     bool can_parse = false;
1107     bool is_64_bit = false;
1108     switch (header.magic)
1109     {
1110         case MH_MAGIC:
1111             data.SetByteOrder (lldb::endian::InlHostByteOrder());
1112             data.SetAddressByteSize(4);
1113             can_parse = true;
1114             break;
1115 
1116         case MH_MAGIC_64:
1117             data.SetByteOrder (lldb::endian::InlHostByteOrder());
1118             data.SetAddressByteSize(8);
1119             can_parse = true;
1120             is_64_bit = true;
1121             break;
1122 
1123         case MH_CIGAM:
1124             data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
1125             data.SetAddressByteSize(4);
1126             can_parse = true;
1127             break;
1128 
1129         case MH_CIGAM_64:
1130             data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
1131             data.SetAddressByteSize(8);
1132             is_64_bit = true;
1133             can_parse = true;
1134             break;
1135 
1136         default:
1137             break;
1138     }
1139 
1140     if (can_parse)
1141     {
1142         data.GetU32(data_offset_ptr, &header.cputype, 6);
1143         if (is_64_bit)
1144             *data_offset_ptr += 4;
1145         return true;
1146     }
1147     else
1148     {
1149         memset(&header, 0, sizeof(header));
1150     }
1151     return false;
1152 }
1153 
1154 bool
1155 ObjectFileMachO::ParseHeader ()
1156 {
1157     ModuleSP module_sp(GetModule());
1158     if (module_sp)
1159     {
1160         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
1161         bool can_parse = false;
1162         lldb::offset_t offset = 0;
1163         m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
1164         // Leave magic in the original byte order
1165         m_header.magic = m_data.GetU32(&offset);
1166         switch (m_header.magic)
1167         {
1168         case MH_MAGIC:
1169             m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
1170             m_data.SetAddressByteSize(4);
1171             can_parse = true;
1172             break;
1173 
1174         case MH_MAGIC_64:
1175             m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
1176             m_data.SetAddressByteSize(8);
1177             can_parse = true;
1178             break;
1179 
1180         case MH_CIGAM:
1181             m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
1182             m_data.SetAddressByteSize(4);
1183             can_parse = true;
1184             break;
1185 
1186         case MH_CIGAM_64:
1187             m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
1188             m_data.SetAddressByteSize(8);
1189             can_parse = true;
1190             break;
1191 
1192         default:
1193             break;
1194         }
1195 
1196         if (can_parse)
1197         {
1198             m_data.GetU32(&offset, &m_header.cputype, 6);
1199 
1200 
1201             ArchSpec mach_arch;
1202 
1203             if (GetArchitecture (mach_arch))
1204             {
1205                 // Check if the module has a required architecture
1206                 const ArchSpec &module_arch = module_sp->GetArchitecture();
1207                 if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
1208                     return false;
1209 
1210                 if (SetModulesArchitecture (mach_arch))
1211                 {
1212                     const size_t header_and_lc_size = m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
1213                     if (m_data.GetByteSize() < header_and_lc_size)
1214                     {
1215                         DataBufferSP data_sp;
1216                         ProcessSP process_sp (m_process_wp.lock());
1217                         if (process_sp)
1218                         {
1219                             data_sp = ReadMemory (process_sp, m_memory_addr, header_and_lc_size);
1220                         }
1221                         else
1222                         {
1223                             // Read in all only the load command data from the file on disk
1224                             data_sp = m_file.ReadFileContents(m_file_offset, header_and_lc_size);
1225                             if (data_sp->GetByteSize() != header_and_lc_size)
1226                                 return false;
1227                         }
1228                         if (data_sp)
1229                             m_data.SetData (data_sp);
1230                     }
1231                 }
1232                 return true;
1233             }
1234         }
1235         else
1236         {
1237             memset(&m_header, 0, sizeof(struct mach_header));
1238         }
1239     }
1240     return false;
1241 }
1242 
1243 
1244 ByteOrder
1245 ObjectFileMachO::GetByteOrder () const
1246 {
1247     return m_data.GetByteOrder ();
1248 }
1249 
1250 bool
1251 ObjectFileMachO::IsExecutable() const
1252 {
1253     return m_header.filetype == MH_EXECUTE;
1254 }
1255 
1256 uint32_t
1257 ObjectFileMachO::GetAddressByteSize () const
1258 {
1259     return m_data.GetAddressByteSize ();
1260 }
1261 
1262 AddressClass
1263 ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr)
1264 {
1265     Symtab *symtab = GetSymtab();
1266     if (symtab)
1267     {
1268         Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
1269         if (symbol)
1270         {
1271             if (symbol->ValueIsAddress())
1272             {
1273                 SectionSP section_sp (symbol->GetAddress().GetSection());
1274                 if (section_sp)
1275                 {
1276                     const lldb::SectionType section_type = section_sp->GetType();
1277                     switch (section_type)
1278                     {
1279                     case eSectionTypeInvalid:
1280                         return eAddressClassUnknown;
1281 
1282                     case eSectionTypeCode:
1283                         if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM)
1284                         {
1285                             // For ARM we have a bit in the n_desc field of the symbol
1286                             // that tells us ARM/Thumb which is bit 0x0008.
1287                             if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
1288                                 return eAddressClassCodeAlternateISA;
1289                         }
1290                         return eAddressClassCode;
1291 
1292                     case eSectionTypeContainer:
1293                         return eAddressClassUnknown;
1294 
1295                     case eSectionTypeData:
1296                     case eSectionTypeDataCString:
1297                     case eSectionTypeDataCStringPointers:
1298                     case eSectionTypeDataSymbolAddress:
1299                     case eSectionTypeData4:
1300                     case eSectionTypeData8:
1301                     case eSectionTypeData16:
1302                     case eSectionTypeDataPointers:
1303                     case eSectionTypeZeroFill:
1304                     case eSectionTypeDataObjCMessageRefs:
1305                     case eSectionTypeDataObjCCFStrings:
1306                         return eAddressClassData;
1307 
1308                     case eSectionTypeDebug:
1309                     case eSectionTypeDWARFDebugAbbrev:
1310                     case eSectionTypeDWARFDebugAranges:
1311                     case eSectionTypeDWARFDebugFrame:
1312                     case eSectionTypeDWARFDebugInfo:
1313                     case eSectionTypeDWARFDebugLine:
1314                     case eSectionTypeDWARFDebugLoc:
1315                     case eSectionTypeDWARFDebugMacInfo:
1316                     case eSectionTypeDWARFDebugPubNames:
1317                     case eSectionTypeDWARFDebugPubTypes:
1318                     case eSectionTypeDWARFDebugRanges:
1319                     case eSectionTypeDWARFDebugStr:
1320                     case eSectionTypeDWARFAppleNames:
1321                     case eSectionTypeDWARFAppleTypes:
1322                     case eSectionTypeDWARFAppleNamespaces:
1323                     case eSectionTypeDWARFAppleObjC:
1324                         return eAddressClassDebug;
1325 
1326                     case eSectionTypeEHFrame:
1327                     case eSectionTypeCompactUnwind:
1328                         return eAddressClassRuntime;
1329 
1330                     case eSectionTypeELFSymbolTable:
1331                     case eSectionTypeELFDynamicSymbols:
1332                     case eSectionTypeELFRelocationEntries:
1333                     case eSectionTypeELFDynamicLinkInfo:
1334                     case eSectionTypeOther:
1335                         return eAddressClassUnknown;
1336                     }
1337                 }
1338             }
1339 
1340             const SymbolType symbol_type = symbol->GetType();
1341             switch (symbol_type)
1342             {
1343             case eSymbolTypeAny:            return eAddressClassUnknown;
1344             case eSymbolTypeAbsolute:       return eAddressClassUnknown;
1345 
1346             case eSymbolTypeCode:
1347             case eSymbolTypeTrampoline:
1348             case eSymbolTypeResolver:
1349                 if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM)
1350                 {
1351                     // For ARM we have a bit in the n_desc field of the symbol
1352                     // that tells us ARM/Thumb which is bit 0x0008.
1353                     if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
1354                         return eAddressClassCodeAlternateISA;
1355                 }
1356                 return eAddressClassCode;
1357 
1358             case eSymbolTypeData:           return eAddressClassData;
1359             case eSymbolTypeRuntime:        return eAddressClassRuntime;
1360             case eSymbolTypeException:      return eAddressClassRuntime;
1361             case eSymbolTypeSourceFile:     return eAddressClassDebug;
1362             case eSymbolTypeHeaderFile:     return eAddressClassDebug;
1363             case eSymbolTypeObjectFile:     return eAddressClassDebug;
1364             case eSymbolTypeCommonBlock:    return eAddressClassDebug;
1365             case eSymbolTypeBlock:          return eAddressClassDebug;
1366             case eSymbolTypeLocal:          return eAddressClassData;
1367             case eSymbolTypeParam:          return eAddressClassData;
1368             case eSymbolTypeVariable:       return eAddressClassData;
1369             case eSymbolTypeVariableType:   return eAddressClassDebug;
1370             case eSymbolTypeLineEntry:      return eAddressClassDebug;
1371             case eSymbolTypeLineHeader:     return eAddressClassDebug;
1372             case eSymbolTypeScopeBegin:     return eAddressClassDebug;
1373             case eSymbolTypeScopeEnd:       return eAddressClassDebug;
1374             case eSymbolTypeAdditional:     return eAddressClassUnknown;
1375             case eSymbolTypeCompiler:       return eAddressClassDebug;
1376             case eSymbolTypeInstrumentation:return eAddressClassDebug;
1377             case eSymbolTypeUndefined:      return eAddressClassUnknown;
1378             case eSymbolTypeObjCClass:      return eAddressClassRuntime;
1379             case eSymbolTypeObjCMetaClass:  return eAddressClassRuntime;
1380             case eSymbolTypeObjCIVar:       return eAddressClassRuntime;
1381             case eSymbolTypeReExported:     return eAddressClassRuntime;
1382             }
1383         }
1384     }
1385     return eAddressClassUnknown;
1386 }
1387 
1388 Symtab *
1389 ObjectFileMachO::GetSymtab()
1390 {
1391     ModuleSP module_sp(GetModule());
1392     if (module_sp)
1393     {
1394         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
1395         if (m_symtab_ap.get() == NULL)
1396         {
1397             m_symtab_ap.reset(new Symtab(this));
1398             Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
1399             ParseSymtab ();
1400             m_symtab_ap->Finalize ();
1401         }
1402     }
1403     return m_symtab_ap.get();
1404 }
1405 
1406 bool
1407 ObjectFileMachO::IsStripped ()
1408 {
1409     if (m_dysymtab.cmd == 0)
1410     {
1411         ModuleSP module_sp(GetModule());
1412         if (module_sp)
1413         {
1414             lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
1415             for (uint32_t i=0; i<m_header.ncmds; ++i)
1416             {
1417                 const lldb::offset_t load_cmd_offset = offset;
1418 
1419                 load_command lc;
1420                 if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL)
1421                     break;
1422                 if (lc.cmd == LC_DYSYMTAB)
1423                 {
1424                     m_dysymtab.cmd = lc.cmd;
1425                     m_dysymtab.cmdsize = lc.cmdsize;
1426                     if (m_data.GetU32 (&offset, &m_dysymtab.ilocalsym, (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2) == NULL)
1427                     {
1428                         // Clear m_dysymtab if we were unable to read all items from the load command
1429                         ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
1430                     }
1431                 }
1432                 offset = load_cmd_offset + lc.cmdsize;
1433             }
1434         }
1435     }
1436     if (m_dysymtab.cmd)
1437         return m_dysymtab.nlocalsym <= 1;
1438     return false;
1439 }
1440 
1441 void
1442 ObjectFileMachO::CreateSections (SectionList &unified_section_list)
1443 {
1444     if (!m_sections_ap.get())
1445     {
1446         m_sections_ap.reset(new SectionList());
1447 
1448         const bool is_dsym = (m_header.filetype == MH_DSYM);
1449         lldb::user_id_t segID = 0;
1450         lldb::user_id_t sectID = 0;
1451         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
1452         uint32_t i;
1453         const bool is_core = GetType() == eTypeCoreFile;
1454         //bool dump_sections = false;
1455         ModuleSP module_sp (GetModule());
1456         // First look up any LC_ENCRYPTION_INFO load commands
1457         typedef RangeArray<uint32_t, uint32_t, 8> EncryptedFileRanges;
1458         EncryptedFileRanges encrypted_file_ranges;
1459         encryption_info_command encryption_cmd;
1460         for (i=0; i<m_header.ncmds; ++i)
1461         {
1462             const lldb::offset_t load_cmd_offset = offset;
1463             if (m_data.GetU32(&offset, &encryption_cmd, 2) == NULL)
1464                 break;
1465 
1466             if (encryption_cmd.cmd == LC_ENCRYPTION_INFO)
1467             {
1468                 if (m_data.GetU32(&offset, &encryption_cmd.cryptoff, 3))
1469                 {
1470                     if (encryption_cmd.cryptid != 0)
1471                     {
1472                         EncryptedFileRanges::Entry entry;
1473                         entry.SetRangeBase(encryption_cmd.cryptoff);
1474                         entry.SetByteSize(encryption_cmd.cryptsize);
1475                         encrypted_file_ranges.Append(entry);
1476                     }
1477                 }
1478             }
1479             offset = load_cmd_offset + encryption_cmd.cmdsize;
1480         }
1481 
1482         bool section_file_addresses_changed = false;
1483 
1484         offset = MachHeaderSizeFromMagic(m_header.magic);
1485 
1486         struct segment_command_64 load_cmd;
1487         for (i=0; i<m_header.ncmds; ++i)
1488         {
1489             const lldb::offset_t load_cmd_offset = offset;
1490             if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
1491                 break;
1492 
1493             if (load_cmd.cmd == LC_SEGMENT || load_cmd.cmd == LC_SEGMENT_64)
1494             {
1495                 if (m_data.GetU8(&offset, (uint8_t*)load_cmd.segname, 16))
1496                 {
1497                     bool add_section = true;
1498                     bool add_to_unified = true;
1499                     ConstString const_segname (load_cmd.segname, std::min<size_t>(strlen(load_cmd.segname), sizeof(load_cmd.segname)));
1500 
1501                     SectionSP unified_section_sp(unified_section_list.FindSectionByName(const_segname));
1502                     if (is_dsym && unified_section_sp)
1503                     {
1504                         if (const_segname == GetSegmentNameLINKEDIT())
1505                         {
1506                             // We need to keep the __LINKEDIT segment private to this object file only
1507                             add_to_unified = false;
1508                         }
1509                         else
1510                         {
1511                             // This is the dSYM file and this section has already been created by
1512                             // the object file, no need to create it.
1513                             add_section = false;
1514                         }
1515                     }
1516                     load_cmd.vmaddr = m_data.GetAddress(&offset);
1517                     load_cmd.vmsize = m_data.GetAddress(&offset);
1518                     load_cmd.fileoff = m_data.GetAddress(&offset);
1519                     load_cmd.filesize = m_data.GetAddress(&offset);
1520                     if (m_length != 0 && load_cmd.filesize != 0)
1521                     {
1522                         if (load_cmd.fileoff > m_length)
1523                         {
1524                             // We have a load command that says it extends past the end of the file.  This is likely
1525                             // a corrupt file.  We don't have any way to return an error condition here (this method
1526                             // was likely invoked from something like ObjectFile::GetSectionList()) -- all we can do
1527                             // is null out the SectionList vector and if a process has been set up, dump a message
1528                             // to stdout.  The most common case here is core file debugging with a truncated file.
1529                             const char *lc_segment_name = load_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
1530                             module_sp->ReportWarning("load command %u %s has a fileoff (0x%" PRIx64 ") that extends beyond the end of the file (0x%" PRIx64 "), ignoring this section",
1531                                                    i,
1532                                                    lc_segment_name,
1533                                                    load_cmd.fileoff,
1534                                                    m_length);
1535 
1536                             load_cmd.fileoff = 0;
1537                             load_cmd.filesize = 0;
1538                         }
1539 
1540                         if (load_cmd.fileoff + load_cmd.filesize > m_length)
1541                         {
1542                             // We have a load command that says it extends past the end of the file.  This is likely
1543                             // a corrupt file.  We don't have any way to return an error condition here (this method
1544                             // was likely invoked from something like ObjectFile::GetSectionList()) -- all we can do
1545                             // is null out the SectionList vector and if a process has been set up, dump a message
1546                             // to stdout.  The most common case here is core file debugging with a truncated file.
1547                             const char *lc_segment_name = load_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
1548                             GetModule()->ReportWarning("load command %u %s has a fileoff + filesize (0x%" PRIx64 ") that extends beyond the end of the file (0x%" PRIx64 "), the segment will be truncated to match",
1549                                                      i,
1550                                                      lc_segment_name,
1551                                                      load_cmd.fileoff + load_cmd.filesize,
1552                                                      m_length);
1553 
1554                             // Tuncase the length
1555                             load_cmd.filesize = m_length - load_cmd.fileoff;
1556                         }
1557                     }
1558                     if (m_data.GetU32(&offset, &load_cmd.maxprot, 4))
1559                     {
1560 
1561                         const bool segment_is_encrypted = (load_cmd.flags & SG_PROTECTED_VERSION_1) != 0;
1562 
1563                         // Keep a list of mach segments around in case we need to
1564                         // get at data that isn't stored in the abstracted Sections.
1565                         m_mach_segments.push_back (load_cmd);
1566 
1567                         // Use a segment ID of the segment index shifted left by 8 so they
1568                         // never conflict with any of the sections.
1569                         SectionSP segment_sp;
1570                         if (add_section && (const_segname || is_core))
1571                         {
1572                             segment_sp.reset(new Section (module_sp,              // Module to which this section belongs
1573                                                           this,                   // Object file to which this sections belongs
1574                                                           ++segID << 8,           // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible
1575                                                           const_segname,          // Name of this section
1576                                                           eSectionTypeContainer,  // This section is a container of other sections.
1577                                                           load_cmd.vmaddr,        // File VM address == addresses as they are found in the object file
1578                                                           load_cmd.vmsize,        // VM size in bytes of this section
1579                                                           load_cmd.fileoff,       // Offset to the data for this section in the file
1580                                                           load_cmd.filesize,      // Size in bytes of this section as found in the file
1581                                                           0,                      // Segments have no alignment information
1582                                                           load_cmd.flags));       // Flags for this section
1583 
1584                             segment_sp->SetIsEncrypted (segment_is_encrypted);
1585                             m_sections_ap->AddSection(segment_sp);
1586                             if (add_to_unified)
1587                                 unified_section_list.AddSection(segment_sp);
1588                         }
1589                         else if (unified_section_sp)
1590                         {
1591                             if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr)
1592                             {
1593                                 // Check to see if the module was read from memory?
1594                                 if (module_sp->GetObjectFile()->GetHeaderAddress().IsValid())
1595                                 {
1596                                     // We have a module that is in memory and needs to have its
1597                                     // file address adjusted. We need to do this because when we
1598                                     // load a file from memory, its addresses will be slid already,
1599                                     // yet the addresses in the new symbol file will still be unslid.
1600                                     // Since everything is stored as section offset, this shouldn't
1601                                     // cause any problems.
1602 
1603                                     // Make sure we've parsed the symbol table from the
1604                                     // ObjectFile before we go around changing its Sections.
1605                                     module_sp->GetObjectFile()->GetSymtab();
1606                                     // eh_frame would present the same problems but we parse that on
1607                                     // a per-function basis as-needed so it's more difficult to
1608                                     // remove its use of the Sections.  Realistically, the environments
1609                                     // where this code path will be taken will not have eh_frame sections.
1610 
1611                                     unified_section_sp->SetFileAddress(load_cmd.vmaddr);
1612 
1613                                     // Notify the module that the section addresses have been changed once
1614                                     // we're done so any file-address caches can be updated.
1615                                     section_file_addresses_changed = true;
1616                                 }
1617                             }
1618                             m_sections_ap->AddSection(unified_section_sp);
1619                         }
1620 
1621                         struct section_64 sect64;
1622                         ::memset (&sect64, 0, sizeof(sect64));
1623                         // Push a section into our mach sections for the section at
1624                         // index zero (NO_SECT) if we don't have any mach sections yet...
1625                         if (m_mach_sections.empty())
1626                             m_mach_sections.push_back(sect64);
1627                         uint32_t segment_sect_idx;
1628                         const lldb::user_id_t first_segment_sectID = sectID + 1;
1629 
1630 
1631                         const uint32_t num_u32s = load_cmd.cmd == LC_SEGMENT ? 7 : 8;
1632                         for (segment_sect_idx=0; segment_sect_idx<load_cmd.nsects; ++segment_sect_idx)
1633                         {
1634                             if (m_data.GetU8(&offset, (uint8_t*)sect64.sectname, sizeof(sect64.sectname)) == NULL)
1635                                 break;
1636                             if (m_data.GetU8(&offset, (uint8_t*)sect64.segname, sizeof(sect64.segname)) == NULL)
1637                                 break;
1638                             sect64.addr = m_data.GetAddress(&offset);
1639                             sect64.size = m_data.GetAddress(&offset);
1640 
1641                             if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == NULL)
1642                                 break;
1643 
1644                             // Keep a list of mach sections around in case we need to
1645                             // get at data that isn't stored in the abstracted Sections.
1646                             m_mach_sections.push_back (sect64);
1647 
1648                             if (add_section)
1649                             {
1650                                 ConstString section_name (sect64.sectname, std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname)));
1651                                 if (!const_segname)
1652                                 {
1653                                     // We have a segment with no name so we need to conjure up
1654                                     // segments that correspond to the section's segname if there
1655                                     // isn't already such a section. If there is such a section,
1656                                     // we resize the section so that it spans all sections.
1657                                     // We also mark these sections as fake so address matches don't
1658                                     // hit if they land in the gaps between the child sections.
1659                                     const_segname.SetTrimmedCStringWithLength(sect64.segname, sizeof(sect64.segname));
1660                                     segment_sp = unified_section_list.FindSectionByName (const_segname);
1661                                     if (segment_sp.get())
1662                                     {
1663                                         Section *segment = segment_sp.get();
1664                                         // Grow the section size as needed.
1665                                         const lldb::addr_t sect64_min_addr = sect64.addr;
1666                                         const lldb::addr_t sect64_max_addr = sect64_min_addr + sect64.size;
1667                                         const lldb::addr_t curr_seg_byte_size = segment->GetByteSize();
1668                                         const lldb::addr_t curr_seg_min_addr = segment->GetFileAddress();
1669                                         const lldb::addr_t curr_seg_max_addr = curr_seg_min_addr + curr_seg_byte_size;
1670                                         if (sect64_min_addr >= curr_seg_min_addr)
1671                                         {
1672                                             const lldb::addr_t new_seg_byte_size = sect64_max_addr - curr_seg_min_addr;
1673                                             // Only grow the section size if needed
1674                                             if (new_seg_byte_size > curr_seg_byte_size)
1675                                                 segment->SetByteSize (new_seg_byte_size);
1676                                         }
1677                                         else
1678                                         {
1679                                             // We need to change the base address of the segment and
1680                                             // adjust the child section offsets for all existing children.
1681                                             const lldb::addr_t slide_amount = sect64_min_addr - curr_seg_min_addr;
1682                                             segment->Slide(slide_amount, false);
1683                                             segment->GetChildren().Slide(-slide_amount, false);
1684                                             segment->SetByteSize (curr_seg_max_addr - sect64_min_addr);
1685                                         }
1686 
1687                                         // Grow the section size as needed.
1688                                         if (sect64.offset)
1689                                         {
1690                                             const lldb::addr_t segment_min_file_offset = segment->GetFileOffset();
1691                                             const lldb::addr_t segment_max_file_offset = segment_min_file_offset + segment->GetFileSize();
1692 
1693                                             const lldb::addr_t section_min_file_offset = sect64.offset;
1694                                             const lldb::addr_t section_max_file_offset = section_min_file_offset + sect64.size;
1695                                             const lldb::addr_t new_file_offset = std::min (section_min_file_offset, segment_min_file_offset);
1696                                             const lldb::addr_t new_file_size = std::max (section_max_file_offset, segment_max_file_offset) - new_file_offset;
1697                                             segment->SetFileOffset (new_file_offset);
1698                                             segment->SetFileSize (new_file_size);
1699                                         }
1700                                     }
1701                                     else
1702                                     {
1703                                         // Create a fake section for the section's named segment
1704                                         segment_sp.reset(new Section (segment_sp,            // Parent section
1705                                                                       module_sp,             // Module to which this section belongs
1706                                                                       this,                  // Object file to which this section belongs
1707                                                                       ++segID << 8,          // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible
1708                                                                       const_segname,         // Name of this section
1709                                                                       eSectionTypeContainer, // This section is a container of other sections.
1710                                                                       sect64.addr,           // File VM address == addresses as they are found in the object file
1711                                                                       sect64.size,           // VM size in bytes of this section
1712                                                                       sect64.offset,         // Offset to the data for this section in the file
1713                                                                       sect64.offset ? sect64.size : 0,        // Size in bytes of this section as found in the file
1714                                                                       sect64.align,
1715                                                                       load_cmd.flags));      // Flags for this section
1716                                         segment_sp->SetIsFake(true);
1717 
1718                                         m_sections_ap->AddSection(segment_sp);
1719                                         if (add_to_unified)
1720                                             unified_section_list.AddSection(segment_sp);
1721                                         segment_sp->SetIsEncrypted (segment_is_encrypted);
1722                                     }
1723                                 }
1724                                 assert (segment_sp.get());
1725 
1726                                 lldb::SectionType sect_type = eSectionTypeOther;
1727 
1728                                 if (sect64.flags & (S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS))
1729                                     sect_type = eSectionTypeCode;
1730                                 else
1731                                 {
1732                                     uint32_t mach_sect_type = sect64.flags & SECTION_TYPE;
1733                                     static ConstString g_sect_name_objc_data ("__objc_data");
1734                                     static ConstString g_sect_name_objc_msgrefs ("__objc_msgrefs");
1735                                     static ConstString g_sect_name_objc_selrefs ("__objc_selrefs");
1736                                     static ConstString g_sect_name_objc_classrefs ("__objc_classrefs");
1737                                     static ConstString g_sect_name_objc_superrefs ("__objc_superrefs");
1738                                     static ConstString g_sect_name_objc_const ("__objc_const");
1739                                     static ConstString g_sect_name_objc_classlist ("__objc_classlist");
1740                                     static ConstString g_sect_name_cfstring ("__cfstring");
1741 
1742                                     static ConstString g_sect_name_dwarf_debug_abbrev ("__debug_abbrev");
1743                                     static ConstString g_sect_name_dwarf_debug_aranges ("__debug_aranges");
1744                                     static ConstString g_sect_name_dwarf_debug_frame ("__debug_frame");
1745                                     static ConstString g_sect_name_dwarf_debug_info ("__debug_info");
1746                                     static ConstString g_sect_name_dwarf_debug_line ("__debug_line");
1747                                     static ConstString g_sect_name_dwarf_debug_loc ("__debug_loc");
1748                                     static ConstString g_sect_name_dwarf_debug_macinfo ("__debug_macinfo");
1749                                     static ConstString g_sect_name_dwarf_debug_pubnames ("__debug_pubnames");
1750                                     static ConstString g_sect_name_dwarf_debug_pubtypes ("__debug_pubtypes");
1751                                     static ConstString g_sect_name_dwarf_debug_ranges ("__debug_ranges");
1752                                     static ConstString g_sect_name_dwarf_debug_str ("__debug_str");
1753                                     static ConstString g_sect_name_dwarf_apple_names ("__apple_names");
1754                                     static ConstString g_sect_name_dwarf_apple_types ("__apple_types");
1755                                     static ConstString g_sect_name_dwarf_apple_namespaces ("__apple_namespac");
1756                                     static ConstString g_sect_name_dwarf_apple_objc ("__apple_objc");
1757                                     static ConstString g_sect_name_eh_frame ("__eh_frame");
1758                                     static ConstString g_sect_name_compact_unwind ("__unwind_info");
1759                                     static ConstString g_sect_name_text ("__text");
1760                                     static ConstString g_sect_name_data ("__data");
1761 
1762 
1763                                     if (section_name == g_sect_name_dwarf_debug_abbrev)
1764                                         sect_type = eSectionTypeDWARFDebugAbbrev;
1765                                     else if (section_name == g_sect_name_dwarf_debug_aranges)
1766                                         sect_type = eSectionTypeDWARFDebugAranges;
1767                                     else if (section_name == g_sect_name_dwarf_debug_frame)
1768                                         sect_type = eSectionTypeDWARFDebugFrame;
1769                                     else if (section_name == g_sect_name_dwarf_debug_info)
1770                                         sect_type = eSectionTypeDWARFDebugInfo;
1771                                     else if (section_name == g_sect_name_dwarf_debug_line)
1772                                         sect_type = eSectionTypeDWARFDebugLine;
1773                                     else if (section_name == g_sect_name_dwarf_debug_loc)
1774                                         sect_type = eSectionTypeDWARFDebugLoc;
1775                                     else if (section_name == g_sect_name_dwarf_debug_macinfo)
1776                                         sect_type = eSectionTypeDWARFDebugMacInfo;
1777                                     else if (section_name == g_sect_name_dwarf_debug_pubnames)
1778                                         sect_type = eSectionTypeDWARFDebugPubNames;
1779                                     else if (section_name == g_sect_name_dwarf_debug_pubtypes)
1780                                         sect_type = eSectionTypeDWARFDebugPubTypes;
1781                                     else if (section_name == g_sect_name_dwarf_debug_ranges)
1782                                         sect_type = eSectionTypeDWARFDebugRanges;
1783                                     else if (section_name == g_sect_name_dwarf_debug_str)
1784                                         sect_type = eSectionTypeDWARFDebugStr;
1785                                     else if (section_name == g_sect_name_dwarf_apple_names)
1786                                         sect_type = eSectionTypeDWARFAppleNames;
1787                                     else if (section_name == g_sect_name_dwarf_apple_types)
1788                                         sect_type = eSectionTypeDWARFAppleTypes;
1789                                     else if (section_name == g_sect_name_dwarf_apple_namespaces)
1790                                         sect_type = eSectionTypeDWARFAppleNamespaces;
1791                                     else if (section_name == g_sect_name_dwarf_apple_objc)
1792                                         sect_type = eSectionTypeDWARFAppleObjC;
1793                                     else if (section_name == g_sect_name_objc_selrefs)
1794                                         sect_type = eSectionTypeDataCStringPointers;
1795                                     else if (section_name == g_sect_name_objc_msgrefs)
1796                                         sect_type = eSectionTypeDataObjCMessageRefs;
1797                                     else if (section_name == g_sect_name_eh_frame)
1798                                         sect_type = eSectionTypeEHFrame;
1799                                     else if (section_name == g_sect_name_compact_unwind)
1800                                         sect_type = eSectionTypeCompactUnwind;
1801                                     else if (section_name == g_sect_name_cfstring)
1802                                         sect_type = eSectionTypeDataObjCCFStrings;
1803                                     else if (section_name == g_sect_name_objc_data ||
1804                                              section_name == g_sect_name_objc_classrefs ||
1805                                              section_name == g_sect_name_objc_superrefs ||
1806                                              section_name == g_sect_name_objc_const ||
1807                                              section_name == g_sect_name_objc_classlist)
1808                                     {
1809                                         sect_type = eSectionTypeDataPointers;
1810                                     }
1811 
1812                                     if (sect_type == eSectionTypeOther)
1813                                     {
1814                                         switch (mach_sect_type)
1815                                         {
1816                                         // TODO: categorize sections by other flags for regular sections
1817                                         case S_REGULAR:
1818                                             if (section_name == g_sect_name_text)
1819                                                 sect_type = eSectionTypeCode;
1820                                             else if (section_name == g_sect_name_data)
1821                                                 sect_type = eSectionTypeData;
1822                                             else
1823                                                 sect_type = eSectionTypeOther;
1824                                             break;
1825                                         case S_ZEROFILL:                   sect_type = eSectionTypeZeroFill; break;
1826                                         case S_CSTRING_LITERALS:           sect_type = eSectionTypeDataCString;    break; // section with only literal C strings
1827                                         case S_4BYTE_LITERALS:             sect_type = eSectionTypeData4;    break; // section with only 4 byte literals
1828                                         case S_8BYTE_LITERALS:             sect_type = eSectionTypeData8;    break; // section with only 8 byte literals
1829                                         case S_LITERAL_POINTERS:           sect_type = eSectionTypeDataPointers;  break; // section with only pointers to literals
1830                                         case S_NON_LAZY_SYMBOL_POINTERS:   sect_type = eSectionTypeDataPointers;  break; // section with only non-lazy symbol pointers
1831                                         case S_LAZY_SYMBOL_POINTERS:       sect_type = eSectionTypeDataPointers;  break; // section with only lazy symbol pointers
1832                                         case S_SYMBOL_STUBS:               sect_type = eSectionTypeCode;  break; // section with only symbol stubs, byte size of stub in the reserved2 field
1833                                         case S_MOD_INIT_FUNC_POINTERS:     sect_type = eSectionTypeDataPointers;    break; // section with only function pointers for initialization
1834                                         case S_MOD_TERM_FUNC_POINTERS:     sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination
1835                                         case S_COALESCED:                  sect_type = eSectionTypeOther; break;
1836                                         case S_GB_ZEROFILL:                sect_type = eSectionTypeZeroFill; break;
1837                                         case S_INTERPOSING:                sect_type = eSectionTypeCode;  break; // section with only pairs of function pointers for interposing
1838                                         case S_16BYTE_LITERALS:            sect_type = eSectionTypeData16; break; // section with only 16 byte literals
1839                                         case S_DTRACE_DOF:                 sect_type = eSectionTypeDebug; break;
1840                                         case S_LAZY_DYLIB_SYMBOL_POINTERS: sect_type = eSectionTypeDataPointers;  break;
1841                                         default: break;
1842                                         }
1843                                     }
1844                                 }
1845 
1846                                 SectionSP section_sp(new Section (segment_sp,
1847                                                                   module_sp,
1848                                                                   this,
1849                                                                   ++sectID,
1850                                                                   section_name,
1851                                                                   sect_type,
1852                                                                   sect64.addr - segment_sp->GetFileAddress(),
1853                                                                   sect64.size,
1854                                                                   sect64.offset,
1855                                                                   sect64.offset == 0 ? 0 : sect64.size,
1856                                                                   sect64.align,
1857                                                                   sect64.flags));
1858                                 // Set the section to be encrypted to match the segment
1859 
1860                                 bool section_is_encrypted = false;
1861                                 if (!segment_is_encrypted && load_cmd.filesize != 0)
1862                                     section_is_encrypted = encrypted_file_ranges.FindEntryThatContains(sect64.offset) != NULL;
1863 
1864                                 section_sp->SetIsEncrypted (segment_is_encrypted || section_is_encrypted);
1865                                 segment_sp->GetChildren().AddSection(section_sp);
1866 
1867                                 if (segment_sp->IsFake())
1868                                 {
1869                                     segment_sp.reset();
1870                                     const_segname.Clear();
1871                                 }
1872                             }
1873                         }
1874                         if (segment_sp && is_dsym)
1875                         {
1876                             if (first_segment_sectID <= sectID)
1877                             {
1878                                 lldb::user_id_t sect_uid;
1879                                 for (sect_uid = first_segment_sectID; sect_uid <= sectID; ++sect_uid)
1880                                 {
1881                                     SectionSP curr_section_sp(segment_sp->GetChildren().FindSectionByID (sect_uid));
1882                                     SectionSP next_section_sp;
1883                                     if (sect_uid + 1 <= sectID)
1884                                         next_section_sp = segment_sp->GetChildren().FindSectionByID (sect_uid+1);
1885 
1886                                     if (curr_section_sp.get())
1887                                     {
1888                                         if (curr_section_sp->GetByteSize() == 0)
1889                                         {
1890                                             if (next_section_sp.get() != NULL)
1891                                                 curr_section_sp->SetByteSize ( next_section_sp->GetFileAddress() - curr_section_sp->GetFileAddress() );
1892                                             else
1893                                                 curr_section_sp->SetByteSize ( load_cmd.vmsize );
1894                                         }
1895                                     }
1896                                 }
1897                             }
1898                         }
1899                     }
1900                 }
1901             }
1902             else if (load_cmd.cmd == LC_DYSYMTAB)
1903             {
1904                 m_dysymtab.cmd = load_cmd.cmd;
1905                 m_dysymtab.cmdsize = load_cmd.cmdsize;
1906                 m_data.GetU32 (&offset, &m_dysymtab.ilocalsym, (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2);
1907             }
1908 
1909             offset = load_cmd_offset + load_cmd.cmdsize;
1910         }
1911 
1912 
1913         if (section_file_addresses_changed && module_sp.get())
1914         {
1915             module_sp->SectionFileAddressesChanged();
1916         }
1917     }
1918 }
1919 
1920 class MachSymtabSectionInfo
1921 {
1922 public:
1923 
1924     MachSymtabSectionInfo (SectionList *section_list) :
1925         m_section_list (section_list),
1926         m_section_infos()
1927     {
1928         // Get the number of sections down to a depth of 1 to include
1929         // all segments and their sections, but no other sections that
1930         // may be added for debug map or
1931         m_section_infos.resize(section_list->GetNumSections(1));
1932     }
1933 
1934 
1935     SectionSP
1936     GetSection (uint8_t n_sect, addr_t file_addr)
1937     {
1938         if (n_sect == 0)
1939             return SectionSP();
1940         if (n_sect < m_section_infos.size())
1941         {
1942             if (!m_section_infos[n_sect].section_sp)
1943             {
1944                 SectionSP section_sp (m_section_list->FindSectionByID (n_sect));
1945                 m_section_infos[n_sect].section_sp = section_sp;
1946                 if (section_sp)
1947                 {
1948                     m_section_infos[n_sect].vm_range.SetBaseAddress (section_sp->GetFileAddress());
1949                     m_section_infos[n_sect].vm_range.SetByteSize (section_sp->GetByteSize());
1950                 }
1951                 else
1952                 {
1953                     Host::SystemLog (Host::eSystemLogError, "error: unable to find section for section %u\n", n_sect);
1954                 }
1955             }
1956             if (m_section_infos[n_sect].vm_range.Contains(file_addr))
1957             {
1958                 // Symbol is in section.
1959                 return m_section_infos[n_sect].section_sp;
1960             }
1961             else if (m_section_infos[n_sect].vm_range.GetByteSize () == 0 &&
1962                      m_section_infos[n_sect].vm_range.GetBaseAddress() == file_addr)
1963             {
1964                 // Symbol is in section with zero size, but has the same start
1965                 // address as the section. This can happen with linker symbols
1966                 // (symbols that start with the letter 'l' or 'L'.
1967                 return m_section_infos[n_sect].section_sp;
1968             }
1969         }
1970         return m_section_list->FindSectionContainingFileAddress(file_addr);
1971     }
1972 
1973 protected:
1974     struct SectionInfo
1975     {
1976         SectionInfo () :
1977             vm_range(),
1978             section_sp ()
1979         {
1980         }
1981 
1982         VMRange vm_range;
1983         SectionSP section_sp;
1984     };
1985     SectionList *m_section_list;
1986     std::vector<SectionInfo> m_section_infos;
1987 };
1988 
1989 struct TrieEntry
1990 {
1991     TrieEntry () :
1992         name(),
1993         address(LLDB_INVALID_ADDRESS),
1994         flags (0),
1995         other(0),
1996         import_name()
1997     {
1998     }
1999 
2000     void
2001     Clear ()
2002     {
2003         name.Clear();
2004         address = LLDB_INVALID_ADDRESS;
2005         flags = 0;
2006         other = 0;
2007         import_name.Clear();
2008     }
2009 
2010     void
2011     Dump () const
2012     {
2013         printf ("0x%16.16llx 0x%16.16llx 0x%16.16llx \"%s\"",
2014                 static_cast<unsigned long long>(address),
2015                 static_cast<unsigned long long>(flags),
2016                 static_cast<unsigned long long>(other), name.GetCString());
2017         if (import_name)
2018             printf (" -> \"%s\"\n", import_name.GetCString());
2019         else
2020             printf ("\n");
2021     }
2022     ConstString		name;
2023     uint64_t		address;
2024     uint64_t		flags;
2025     uint64_t		other;
2026     ConstString		import_name;
2027 };
2028 
2029 struct TrieEntryWithOffset
2030 {
2031 	lldb::offset_t nodeOffset;
2032 	TrieEntry entry;
2033 
2034     TrieEntryWithOffset (lldb::offset_t offset) :
2035         nodeOffset (offset),
2036         entry()
2037     {
2038     }
2039 
2040     void
2041     Dump (uint32_t idx) const
2042     {
2043         printf ("[%3u] 0x%16.16llx: ", idx,
2044                 static_cast<unsigned long long>(nodeOffset));
2045         entry.Dump();
2046     }
2047 
2048 	bool
2049     operator<(const TrieEntryWithOffset& other) const
2050     {
2051         return ( nodeOffset < other.nodeOffset );
2052     }
2053 };
2054 
2055 static void
2056 ParseTrieEntries (DataExtractor &data,
2057                   lldb::offset_t offset,
2058                   std::vector<llvm::StringRef> &nameSlices,
2059                   std::set<lldb::addr_t> &resolver_addresses,
2060                   std::vector<TrieEntryWithOffset>& output)
2061 {
2062 	if (!data.ValidOffset(offset))
2063         return;
2064 
2065 	const uint64_t terminalSize = data.GetULEB128(&offset);
2066 	lldb::offset_t children_offset = offset + terminalSize;
2067 	if ( terminalSize != 0 ) {
2068 		TrieEntryWithOffset e (offset);
2069 		e.entry.flags = data.GetULEB128(&offset);
2070         const char *import_name = NULL;
2071 		if ( e.entry.flags & EXPORT_SYMBOL_FLAGS_REEXPORT ) {
2072 			e.entry.address = 0;
2073 			e.entry.other = data.GetULEB128(&offset); // dylib ordinal
2074             import_name = data.GetCStr(&offset);
2075 		}
2076 		else {
2077 			e.entry.address = data.GetULEB128(&offset);
2078 			if ( e.entry.flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER )
2079             {
2080                 //resolver_addresses.insert(e.entry.address);
2081 				e.entry.other = data.GetULEB128(&offset);
2082                 resolver_addresses.insert(e.entry.other);
2083             }
2084 			else
2085 				e.entry.other = 0;
2086 		}
2087         // Only add symbols that are reexport symbols with a valid import name
2088         if (EXPORT_SYMBOL_FLAGS_REEXPORT & e.entry.flags && import_name && import_name[0])
2089         {
2090             std::string name;
2091             if (!nameSlices.empty())
2092             {
2093                 for (auto name_slice: nameSlices)
2094                     name.append(name_slice.data(), name_slice.size());
2095             }
2096             if (name.size() > 1)
2097             {
2098                 // Skip the leading '_'
2099                 e.entry.name.SetCStringWithLength(name.c_str() + 1,name.size() - 1);
2100             }
2101             if (import_name)
2102             {
2103                 // Skip the leading '_'
2104                 e.entry.import_name.SetCString(import_name+1);
2105             }
2106             output.push_back(e);
2107         }
2108 	}
2109 
2110 	const uint8_t childrenCount = data.GetU8(&children_offset);
2111 	for (uint8_t i=0; i < childrenCount; ++i) {
2112         nameSlices.push_back(data.GetCStr(&children_offset));
2113         lldb::offset_t childNodeOffset = data.GetULEB128(&children_offset);
2114 		if (childNodeOffset)
2115         {
2116             ParseTrieEntries(data,
2117                              childNodeOffset,
2118                              nameSlices,
2119                              resolver_addresses,
2120                              output);
2121         }
2122         nameSlices.pop_back();
2123 	}
2124 }
2125 
2126 size_t
2127 ObjectFileMachO::ParseSymtab ()
2128 {
2129     Timer scoped_timer(__PRETTY_FUNCTION__,
2130                        "ObjectFileMachO::ParseSymtab () module = %s",
2131                        m_file.GetFilename().AsCString(""));
2132     ModuleSP module_sp (GetModule());
2133     if (!module_sp)
2134         return 0;
2135 
2136     struct symtab_command symtab_load_command = { 0, 0, 0, 0, 0, 0 };
2137     struct linkedit_data_command function_starts_load_command = { 0, 0, 0, 0 };
2138     struct dyld_info_command dyld_info = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2139     typedef AddressDataArray<lldb::addr_t, bool, 100> FunctionStarts;
2140     FunctionStarts function_starts;
2141     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
2142     uint32_t i;
2143     FileSpecList dylib_files;
2144     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
2145 
2146     for (i=0; i<m_header.ncmds; ++i)
2147     {
2148         const lldb::offset_t cmd_offset = offset;
2149         // Read in the load command and load command size
2150         struct load_command lc;
2151         if (m_data.GetU32(&offset, &lc, 2) == NULL)
2152             break;
2153         // Watch for the symbol table load command
2154         switch (lc.cmd)
2155         {
2156         case LC_SYMTAB:
2157             symtab_load_command.cmd = lc.cmd;
2158             symtab_load_command.cmdsize = lc.cmdsize;
2159             // Read in the rest of the symtab load command
2160             if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4) == 0) // fill in symoff, nsyms, stroff, strsize fields
2161                 return 0;
2162             if (symtab_load_command.symoff == 0)
2163             {
2164                 if (log)
2165                     module_sp->LogMessage(log, "LC_SYMTAB.symoff == 0");
2166                 return 0;
2167             }
2168 
2169             if (symtab_load_command.stroff == 0)
2170             {
2171                 if (log)
2172                     module_sp->LogMessage(log, "LC_SYMTAB.stroff == 0");
2173                 return 0;
2174             }
2175 
2176             if (symtab_load_command.nsyms == 0)
2177             {
2178                 if (log)
2179                     module_sp->LogMessage(log, "LC_SYMTAB.nsyms == 0");
2180                 return 0;
2181             }
2182 
2183             if (symtab_load_command.strsize == 0)
2184             {
2185                 if (log)
2186                     module_sp->LogMessage(log, "LC_SYMTAB.strsize == 0");
2187                 return 0;
2188             }
2189             break;
2190 
2191         case LC_DYLD_INFO:
2192         case LC_DYLD_INFO_ONLY:
2193             if (m_data.GetU32(&offset, &dyld_info.rebase_off, 10))
2194             {
2195                 dyld_info.cmd = lc.cmd;
2196                 dyld_info.cmdsize = lc.cmdsize;
2197             }
2198             else
2199             {
2200                 memset (&dyld_info, 0, sizeof(dyld_info));
2201             }
2202             break;
2203 
2204         case LC_LOAD_DYLIB:
2205         case LC_LOAD_WEAK_DYLIB:
2206         case LC_REEXPORT_DYLIB:
2207         case LC_LOADFVMLIB:
2208         case LC_LOAD_UPWARD_DYLIB:
2209             {
2210                 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
2211                 const char *path = m_data.PeekCStr(name_offset);
2212                 if (path)
2213                 {
2214                     FileSpec file_spec(path, false);
2215                     // Strip the path if there is @rpath, @executable, etc so we just use the basename
2216                     if (path[0] == '@')
2217                         file_spec.GetDirectory().Clear();
2218 
2219                     if (lc.cmd == LC_REEXPORT_DYLIB)
2220                     {
2221                         m_reexported_dylibs.AppendIfUnique(file_spec);
2222                     }
2223 
2224                     dylib_files.Append(file_spec);
2225                 }
2226             }
2227             break;
2228 
2229         case LC_FUNCTION_STARTS:
2230             function_starts_load_command.cmd = lc.cmd;
2231             function_starts_load_command.cmdsize = lc.cmdsize;
2232             if (m_data.GetU32(&offset, &function_starts_load_command.dataoff, 2) == NULL) // fill in symoff, nsyms, stroff, strsize fields
2233                 memset (&function_starts_load_command, 0, sizeof(function_starts_load_command));
2234             break;
2235 
2236         default:
2237             break;
2238         }
2239         offset = cmd_offset + lc.cmdsize;
2240     }
2241 
2242     if (symtab_load_command.cmd)
2243     {
2244         Symtab *symtab = m_symtab_ap.get();
2245         SectionList *section_list = GetSectionList();
2246         if (section_list == NULL)
2247             return 0;
2248 
2249         const uint32_t addr_byte_size = m_data.GetAddressByteSize();
2250         const ByteOrder byte_order = m_data.GetByteOrder();
2251         bool bit_width_32 = addr_byte_size == 4;
2252         const size_t nlist_byte_size = bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
2253 
2254         DataExtractor nlist_data (NULL, 0, byte_order, addr_byte_size);
2255         DataExtractor strtab_data (NULL, 0, byte_order, addr_byte_size);
2256         DataExtractor function_starts_data (NULL, 0, byte_order, addr_byte_size);
2257         DataExtractor indirect_symbol_index_data (NULL, 0, byte_order, addr_byte_size);
2258         DataExtractor dyld_trie_data (NULL, 0, byte_order, addr_byte_size);
2259 
2260         const addr_t nlist_data_byte_size = symtab_load_command.nsyms * nlist_byte_size;
2261         const addr_t strtab_data_byte_size = symtab_load_command.strsize;
2262         addr_t strtab_addr = LLDB_INVALID_ADDRESS;
2263 
2264         ProcessSP process_sp (m_process_wp.lock());
2265         Process *process = process_sp.get();
2266 
2267         uint32_t memory_module_load_level = eMemoryModuleLoadLevelComplete;
2268 
2269         if (process && m_header.filetype != llvm::MachO::MH_OBJECT)
2270         {
2271             Target &target = process->GetTarget();
2272 
2273             memory_module_load_level = target.GetMemoryModuleLoadLevel();
2274 
2275             SectionSP linkedit_section_sp(section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
2276             // Reading mach file from memory in a process or core file...
2277 
2278             if (linkedit_section_sp)
2279             {
2280                 const addr_t linkedit_load_addr = linkedit_section_sp->GetLoadBaseAddress(&target);
2281                 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
2282                 const addr_t symoff_addr = linkedit_load_addr + symtab_load_command.symoff - linkedit_file_offset;
2283                 strtab_addr = linkedit_load_addr + symtab_load_command.stroff - linkedit_file_offset;
2284 
2285                 bool data_was_read = false;
2286 
2287 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
2288                 if (m_header.flags & 0x80000000u && process->GetAddressByteSize() == sizeof (void*))
2289                 {
2290                     // This mach-o memory file is in the dyld shared cache. If this
2291                     // program is not remote and this is iOS, then this process will
2292                     // share the same shared cache as the process we are debugging and
2293                     // we can read the entire __LINKEDIT from the address space in this
2294                     // process. This is a needed optimization that is used for local iOS
2295                     // debugging only since all shared libraries in the shared cache do
2296                     // not have corresponding files that exist in the file system of the
2297                     // device. They have been combined into a single file. This means we
2298                     // always have to load these files from memory. All of the symbol and
2299                     // string tables from all of the __LINKEDIT sections from the shared
2300                     // libraries in the shared cache have been merged into a single large
2301                     // symbol and string table. Reading all of this symbol and string table
2302                     // data across can slow down debug launch times, so we optimize this by
2303                     // reading the memory for the __LINKEDIT section from this process.
2304 
2305                     UUID lldb_shared_cache(GetLLDBSharedCacheUUID());
2306                     UUID process_shared_cache(GetProcessSharedCacheUUID(process));
2307                     bool use_lldb_cache = true;
2308                     if (lldb_shared_cache.IsValid() && process_shared_cache.IsValid() && lldb_shared_cache != process_shared_cache)
2309                     {
2310                             use_lldb_cache = false;
2311                             ModuleSP module_sp (GetModule());
2312                             if (module_sp)
2313                                 module_sp->ReportWarning ("shared cache in process does not match lldb's own shared cache, startup will be slow.");
2314 
2315                     }
2316 
2317                     PlatformSP platform_sp (target.GetPlatform());
2318                     if (platform_sp && platform_sp->IsHost() && use_lldb_cache)
2319                     {
2320                         data_was_read = true;
2321                         nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size, eByteOrderLittle);
2322                         strtab_data.SetData((void *)strtab_addr, strtab_data_byte_size, eByteOrderLittle);
2323                         if (function_starts_load_command.cmd)
2324                         {
2325                             const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
2326                             function_starts_data.SetData ((void *)func_start_addr, function_starts_load_command.datasize, eByteOrderLittle);
2327                         }
2328                     }
2329                 }
2330 #endif
2331 
2332                 if (!data_was_read)
2333                 {
2334                     if (memory_module_load_level == eMemoryModuleLoadLevelComplete)
2335                     {
2336                         DataBufferSP nlist_data_sp (ReadMemory (process_sp, symoff_addr, nlist_data_byte_size));
2337                         if (nlist_data_sp)
2338                             nlist_data.SetData (nlist_data_sp, 0, nlist_data_sp->GetByteSize());
2339                         // Load strings individually from memory when loading from memory since shared cache
2340                         // string tables contain strings for all symbols from all shared cached libraries
2341                         //DataBufferSP strtab_data_sp (ReadMemory (process_sp, strtab_addr, strtab_data_byte_size));
2342                         //if (strtab_data_sp)
2343                         //    strtab_data.SetData (strtab_data_sp, 0, strtab_data_sp->GetByteSize());
2344                         if (m_dysymtab.nindirectsyms != 0)
2345                         {
2346                             const addr_t indirect_syms_addr = linkedit_load_addr + m_dysymtab.indirectsymoff - linkedit_file_offset;
2347                             DataBufferSP indirect_syms_data_sp (ReadMemory (process_sp, indirect_syms_addr, m_dysymtab.nindirectsyms * 4));
2348                             if (indirect_syms_data_sp)
2349                                 indirect_symbol_index_data.SetData (indirect_syms_data_sp, 0, indirect_syms_data_sp->GetByteSize());
2350                         }
2351                     }
2352 
2353                     if (memory_module_load_level >= eMemoryModuleLoadLevelPartial)
2354                     {
2355                         if (function_starts_load_command.cmd)
2356                         {
2357                             const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
2358                             DataBufferSP func_start_data_sp (ReadMemory (process_sp, func_start_addr, function_starts_load_command.datasize));
2359                             if (func_start_data_sp)
2360                                 function_starts_data.SetData (func_start_data_sp, 0, func_start_data_sp->GetByteSize());
2361                         }
2362                     }
2363                 }
2364             }
2365         }
2366         else
2367         {
2368             nlist_data.SetData (m_data,
2369                                 symtab_load_command.symoff,
2370                                 nlist_data_byte_size);
2371             strtab_data.SetData (m_data,
2372                                  symtab_load_command.stroff,
2373                                  strtab_data_byte_size);
2374 
2375             if (dyld_info.export_size > 0)
2376             {
2377                 dyld_trie_data.SetData (m_data,
2378                                         dyld_info.export_off,
2379                                         dyld_info.export_size);
2380             }
2381 
2382             if (m_dysymtab.nindirectsyms != 0)
2383             {
2384                 indirect_symbol_index_data.SetData (m_data,
2385                                                     m_dysymtab.indirectsymoff,
2386                                                     m_dysymtab.nindirectsyms * 4);
2387             }
2388             if (function_starts_load_command.cmd)
2389             {
2390                 function_starts_data.SetData (m_data,
2391                                               function_starts_load_command.dataoff,
2392                                               function_starts_load_command.datasize);
2393             }
2394         }
2395 
2396         if (nlist_data.GetByteSize() == 0 && memory_module_load_level == eMemoryModuleLoadLevelComplete)
2397         {
2398             if (log)
2399                 module_sp->LogMessage(log, "failed to read nlist data");
2400             return 0;
2401         }
2402 
2403 
2404         const bool have_strtab_data = strtab_data.GetByteSize() > 0;
2405         if (!have_strtab_data)
2406         {
2407             if (process)
2408             {
2409                 if (strtab_addr == LLDB_INVALID_ADDRESS)
2410                 {
2411                     if (log)
2412                         module_sp->LogMessage(log, "failed to locate the strtab in memory");
2413                     return 0;
2414                 }
2415             }
2416             else
2417             {
2418                 if (log)
2419                     module_sp->LogMessage(log, "failed to read strtab data");
2420                 return 0;
2421             }
2422         }
2423 
2424         const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT();
2425         const ConstString &g_segment_name_DATA = GetSegmentNameDATA();
2426         const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC();
2427         const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame();
2428         SectionSP text_section_sp(section_list->FindSectionByName(g_segment_name_TEXT));
2429         SectionSP data_section_sp(section_list->FindSectionByName(g_segment_name_DATA));
2430         SectionSP objc_section_sp(section_list->FindSectionByName(g_segment_name_OBJC));
2431         SectionSP eh_frame_section_sp;
2432         if (text_section_sp.get())
2433             eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName (g_section_name_eh_frame);
2434         else
2435             eh_frame_section_sp = section_list->FindSectionByName (g_section_name_eh_frame);
2436 
2437         const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
2438 
2439         // lldb works best if it knows the start address of all functions in a module.
2440         // Linker symbols or debug info are normally the best source of information for start addr / size but
2441         // they may be stripped in a released binary.
2442         // Two additional sources of information exist in Mach-O binaries:
2443         //    LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each function's start address in the
2444         //                         binary, relative to the text section.
2445         //    eh_frame           - the eh_frame FDEs have the start addr & size of each function
2446         //  LC_FUNCTION_STARTS is the fastest source to read in, and is present on all modern binaries.
2447         //  Binaries built to run on older releases may need to use eh_frame information.
2448 
2449         if (text_section_sp && function_starts_data.GetByteSize())
2450         {
2451             FunctionStarts::Entry function_start_entry;
2452             function_start_entry.data = false;
2453             lldb::offset_t function_start_offset = 0;
2454             function_start_entry.addr = text_section_sp->GetFileAddress();
2455             uint64_t delta;
2456             while ((delta = function_starts_data.GetULEB128(&function_start_offset)) > 0)
2457             {
2458                 // Now append the current entry
2459                 function_start_entry.addr += delta;
2460                 function_starts.Append(function_start_entry);
2461             }
2462         }
2463         else
2464         {
2465             // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the load command claiming an eh_frame
2466             // but it doesn't actually have the eh_frame content.  And if we have a dSYM, we don't need to do any
2467             // of this fill-in-the-missing-symbols works anyway - the debug info should give us all the functions in
2468             // the module.
2469             if (text_section_sp.get() && eh_frame_section_sp.get() && m_type != eTypeDebugInfo)
2470             {
2471                 DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp, eRegisterKindGCC, true);
2472                 DWARFCallFrameInfo::FunctionAddressAndSizeVector functions;
2473                 eh_frame.GetFunctionAddressAndSizeVector (functions);
2474                 addr_t text_base_addr = text_section_sp->GetFileAddress();
2475                 size_t count = functions.GetSize();
2476                 for (size_t i = 0; i < count; ++i)
2477                 {
2478                     const DWARFCallFrameInfo::FunctionAddressAndSizeVector::Entry *func = functions.GetEntryAtIndex (i);
2479                     if (func)
2480                     {
2481                         FunctionStarts::Entry function_start_entry;
2482                         function_start_entry.addr = func->base - text_base_addr;
2483                         function_starts.Append(function_start_entry);
2484                     }
2485                 }
2486             }
2487         }
2488 
2489         const size_t function_starts_count = function_starts.GetSize();
2490 
2491         const user_id_t TEXT_eh_frame_sectID =
2492             eh_frame_section_sp.get() ? eh_frame_section_sp->GetID()
2493                                       : static_cast<user_id_t>(NO_SECT);
2494 
2495         lldb::offset_t nlist_data_offset = 0;
2496 
2497         uint32_t N_SO_index = UINT32_MAX;
2498 
2499         MachSymtabSectionInfo section_info (section_list);
2500         std::vector<uint32_t> N_FUN_indexes;
2501         std::vector<uint32_t> N_NSYM_indexes;
2502         std::vector<uint32_t> N_INCL_indexes;
2503         std::vector<uint32_t> N_BRAC_indexes;
2504         std::vector<uint32_t> N_COMM_indexes;
2505         typedef std::multimap <uint64_t, uint32_t> ValueToSymbolIndexMap;
2506         typedef std::map <uint32_t, uint32_t> NListIndexToSymbolIndexMap;
2507         typedef std::map <const char *, uint32_t> ConstNameToSymbolIndexMap;
2508         ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
2509         ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
2510         ConstNameToSymbolIndexMap N_GSYM_name_to_sym_idx;
2511         // Any symbols that get merged into another will get an entry
2512         // in this map so we know
2513         NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
2514         uint32_t nlist_idx = 0;
2515         Symbol *symbol_ptr = NULL;
2516 
2517         uint32_t sym_idx = 0;
2518         Symbol *sym = NULL;
2519         size_t num_syms = 0;
2520         std::string memory_symbol_name;
2521         uint32_t unmapped_local_symbols_found = 0;
2522 
2523         std::vector<TrieEntryWithOffset> trie_entries;
2524         std::set<lldb::addr_t> resolver_addresses;
2525 
2526         if (dyld_trie_data.GetByteSize() > 0)
2527         {
2528             std::vector<llvm::StringRef> nameSlices;
2529             ParseTrieEntries (dyld_trie_data,
2530                               0,
2531                               nameSlices,
2532                               resolver_addresses,
2533                               trie_entries);
2534 
2535             ConstString text_segment_name ("__TEXT");
2536             SectionSP text_segment_sp = GetSectionList()->FindSectionByName(text_segment_name);
2537             if (text_segment_sp)
2538             {
2539                 const lldb::addr_t text_segment_file_addr = text_segment_sp->GetFileAddress();
2540                 if (text_segment_file_addr != LLDB_INVALID_ADDRESS)
2541                 {
2542                     for (auto &e : trie_entries)
2543                         e.entry.address += text_segment_file_addr;
2544                 }
2545             }
2546         }
2547 
2548 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
2549 
2550         // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been optimized by moving LOCAL
2551         // symbols out of the memory mapped portion of the DSC. The symbol information has all been retained,
2552         // but it isn't available in the normal nlist data. However, there *are* duplicate entries of *some*
2553         // LOCAL symbols in the normal nlist data. To handle this situation correctly, we must first attempt
2554         // to parse any DSC unmapped symbol information. If we find any, we set a flag that tells the normal
2555         // nlist parser to ignore all LOCAL symbols.
2556 
2557         if (m_header.flags & 0x80000000u)
2558         {
2559             // Before we can start mapping the DSC, we need to make certain the target process is actually
2560             // using the cache we can find.
2561 
2562             // Next we need to determine the correct path for the dyld shared cache.
2563 
2564             ArchSpec header_arch;
2565             GetArchitecture(header_arch);
2566             char dsc_path[PATH_MAX];
2567 
2568             snprintf(dsc_path, sizeof(dsc_path), "%s%s%s",
2569                      "/System/Library/Caches/com.apple.dyld/",  /* IPHONE_DYLD_SHARED_CACHE_DIR */
2570                      "dyld_shared_cache_",          /* DYLD_SHARED_CACHE_BASE_NAME */
2571                      header_arch.GetArchitectureName());
2572 
2573             FileSpec dsc_filespec(dsc_path, false);
2574 
2575             // We need definitions of two structures in the on-disk DSC, copy them here manually
2576             struct lldb_copy_dyld_cache_header_v0
2577             {
2578                 char        magic[16];            // e.g. "dyld_v0    i386", "dyld_v1   armv7", etc.
2579                 uint32_t    mappingOffset;        // file offset to first dyld_cache_mapping_info
2580                 uint32_t    mappingCount;         // number of dyld_cache_mapping_info entries
2581                 uint32_t    imagesOffset;
2582                 uint32_t    imagesCount;
2583                 uint64_t    dyldBaseAddress;
2584                 uint64_t    codeSignatureOffset;
2585                 uint64_t    codeSignatureSize;
2586                 uint64_t    slideInfoOffset;
2587                 uint64_t    slideInfoSize;
2588                 uint64_t    localSymbolsOffset;   // file offset of where local symbols are stored
2589                 uint64_t    localSymbolsSize;     // size of local symbols information
2590             };
2591             struct lldb_copy_dyld_cache_header_v1
2592             {
2593                 char        magic[16];            // e.g. "dyld_v0    i386", "dyld_v1   armv7", etc.
2594                 uint32_t    mappingOffset;        // file offset to first dyld_cache_mapping_info
2595                 uint32_t    mappingCount;         // number of dyld_cache_mapping_info entries
2596                 uint32_t    imagesOffset;
2597                 uint32_t    imagesCount;
2598                 uint64_t    dyldBaseAddress;
2599                 uint64_t    codeSignatureOffset;
2600                 uint64_t    codeSignatureSize;
2601                 uint64_t    slideInfoOffset;
2602                 uint64_t    slideInfoSize;
2603                 uint64_t    localSymbolsOffset;
2604                 uint64_t    localSymbolsSize;
2605                 uint8_t     uuid[16];             // v1 and above, also recorded in dyld_all_image_infos v13 and later
2606             };
2607 
2608             struct lldb_copy_dyld_cache_mapping_info
2609             {
2610                 uint64_t        address;
2611                 uint64_t        size;
2612                 uint64_t        fileOffset;
2613                 uint32_t        maxProt;
2614                 uint32_t        initProt;
2615             };
2616 
2617             struct lldb_copy_dyld_cache_local_symbols_info
2618             {
2619                 uint32_t        nlistOffset;
2620                 uint32_t        nlistCount;
2621                 uint32_t        stringsOffset;
2622                 uint32_t        stringsSize;
2623                 uint32_t        entriesOffset;
2624                 uint32_t        entriesCount;
2625             };
2626             struct lldb_copy_dyld_cache_local_symbols_entry
2627             {
2628                 uint32_t        dylibOffset;
2629                 uint32_t        nlistStartIndex;
2630                 uint32_t        nlistCount;
2631             };
2632 
2633             /* The dyld_cache_header has a pointer to the dyld_cache_local_symbols_info structure (localSymbolsOffset).
2634                The dyld_cache_local_symbols_info structure gives us three things:
2635                  1. The start and count of the nlist records in the dyld_shared_cache file
2636                  2. The start and size of the strings for these nlist records
2637                  3. The start and count of dyld_cache_local_symbols_entry entries
2638 
2639                There is one dyld_cache_local_symbols_entry per dylib/framework in the dyld shared cache.
2640                The "dylibOffset" field is the Mach-O header of this dylib/framework in the dyld shared cache.
2641                The dyld_cache_local_symbols_entry also lists the start of this dylib/framework's nlist records
2642                and the count of how many nlist records there are for this dylib/framework.
2643             */
2644 
2645             // Process the dsc header to find the unmapped symbols
2646             //
2647             // Save some VM space, do not map the entire cache in one shot.
2648 
2649             DataBufferSP dsc_data_sp;
2650             dsc_data_sp = dsc_filespec.MemoryMapFileContents(0, sizeof(struct lldb_copy_dyld_cache_header_v1));
2651 
2652             if (dsc_data_sp)
2653             {
2654                 DataExtractor dsc_header_data(dsc_data_sp, byte_order, addr_byte_size);
2655 
2656                 char version_str[17];
2657                 int version = -1;
2658                 lldb::offset_t offset = 0;
2659                 memcpy (version_str, dsc_header_data.GetData (&offset, 16), 16);
2660                 version_str[16] = '\0';
2661                 if (strncmp (version_str, "dyld_v", 6) == 0 && isdigit (version_str[6]))
2662                 {
2663                     int v;
2664                     if (::sscanf (version_str + 6, "%d", &v) == 1)
2665                     {
2666                         version = v;
2667                     }
2668                 }
2669 
2670                 UUID dsc_uuid;
2671                 if (version >= 1)
2672                 {
2673                     offset = offsetof (struct lldb_copy_dyld_cache_header_v1, uuid);
2674                     uint8_t uuid_bytes[sizeof (uuid_t)];
2675                     memcpy (uuid_bytes, dsc_header_data.GetData (&offset, sizeof (uuid_t)), sizeof (uuid_t));
2676                     dsc_uuid.SetBytes (uuid_bytes);
2677                 }
2678 
2679                 bool uuid_match = true;
2680                 if (dsc_uuid.IsValid() && process)
2681                 {
2682                     UUID shared_cache_uuid(GetProcessSharedCacheUUID(process));
2683 
2684                     if (shared_cache_uuid.IsValid() && dsc_uuid != shared_cache_uuid)
2685                     {
2686                         // The on-disk dyld_shared_cache file is not the same as the one in this
2687                         // process' memory, don't use it.
2688                         uuid_match = false;
2689                         ModuleSP module_sp (GetModule());
2690                         if (module_sp)
2691                             module_sp->ReportWarning ("process shared cache does not match on-disk dyld_shared_cache file, some symbol names will be missing.");
2692                     }
2693                 }
2694 
2695                 offset = offsetof (struct lldb_copy_dyld_cache_header_v1, mappingOffset);
2696 
2697                 uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
2698 
2699                 // If the mappingOffset points to a location inside the header, we've
2700                 // opened an old dyld shared cache, and should not proceed further.
2701                 if (uuid_match && mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header_v0))
2702                 {
2703 
2704                     DataBufferSP dsc_mapping_info_data_sp = dsc_filespec.MemoryMapFileContents(mappingOffset, sizeof (struct lldb_copy_dyld_cache_mapping_info));
2705                     DataExtractor dsc_mapping_info_data(dsc_mapping_info_data_sp, byte_order, addr_byte_size);
2706                     offset = 0;
2707 
2708                     // The File addresses (from the in-memory Mach-O load commands) for the shared libraries
2709                     // in the shared library cache need to be adjusted by an offset to match up with the
2710                     // dylibOffset identifying field in the dyld_cache_local_symbol_entry's.  This offset is
2711                     // recorded in mapping_offset_value.
2712                     const uint64_t mapping_offset_value = dsc_mapping_info_data.GetU64(&offset);
2713 
2714                     offset = offsetof (struct lldb_copy_dyld_cache_header_v1, localSymbolsOffset);
2715                     uint64_t localSymbolsOffset = dsc_header_data.GetU64(&offset);
2716                     uint64_t localSymbolsSize = dsc_header_data.GetU64(&offset);
2717 
2718                     if (localSymbolsOffset && localSymbolsSize)
2719                     {
2720                         // Map the local symbols
2721                         if (DataBufferSP dsc_local_symbols_data_sp = dsc_filespec.MemoryMapFileContents(localSymbolsOffset, localSymbolsSize))
2722                         {
2723                             DataExtractor dsc_local_symbols_data(dsc_local_symbols_data_sp, byte_order, addr_byte_size);
2724 
2725                             offset = 0;
2726 
2727                             // Read the local_symbols_infos struct in one shot
2728                             struct lldb_copy_dyld_cache_local_symbols_info local_symbols_info;
2729                             dsc_local_symbols_data.GetU32(&offset, &local_symbols_info.nlistOffset, 6);
2730 
2731                             SectionSP text_section_sp(section_list->FindSectionByName(GetSegmentNameTEXT()));
2732 
2733                             uint32_t header_file_offset = (text_section_sp->GetFileAddress() - mapping_offset_value);
2734 
2735                             offset = local_symbols_info.entriesOffset;
2736                             for (uint32_t entry_index = 0; entry_index < local_symbols_info.entriesCount; entry_index++)
2737                             {
2738                                 struct lldb_copy_dyld_cache_local_symbols_entry local_symbols_entry;
2739                                 local_symbols_entry.dylibOffset = dsc_local_symbols_data.GetU32(&offset);
2740                                 local_symbols_entry.nlistStartIndex = dsc_local_symbols_data.GetU32(&offset);
2741                                 local_symbols_entry.nlistCount = dsc_local_symbols_data.GetU32(&offset);
2742 
2743                                 if (header_file_offset == local_symbols_entry.dylibOffset)
2744                                 {
2745                                     unmapped_local_symbols_found = local_symbols_entry.nlistCount;
2746 
2747                                     // The normal nlist code cannot correctly size the Symbols array, we need to allocate it here.
2748                                     sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms + unmapped_local_symbols_found - m_dysymtab.nlocalsym);
2749                                     num_syms = symtab->GetNumSymbols();
2750 
2751                                     nlist_data_offset = local_symbols_info.nlistOffset + (nlist_byte_size * local_symbols_entry.nlistStartIndex);
2752                                     uint32_t string_table_offset = local_symbols_info.stringsOffset;
2753 
2754                                     for (uint32_t nlist_index = 0; nlist_index < local_symbols_entry.nlistCount; nlist_index++)
2755                                     {
2756                                         /////////////////////////////
2757                                         {
2758                                             struct nlist_64 nlist;
2759                                             if (!dsc_local_symbols_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
2760                                                 break;
2761 
2762                                             nlist.n_strx  = dsc_local_symbols_data.GetU32_unchecked(&nlist_data_offset);
2763                                             nlist.n_type  = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
2764                                             nlist.n_sect  = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
2765                                             nlist.n_desc  = dsc_local_symbols_data.GetU16_unchecked (&nlist_data_offset);
2766                                             nlist.n_value = dsc_local_symbols_data.GetAddress_unchecked (&nlist_data_offset);
2767 
2768                                             SymbolType type = eSymbolTypeInvalid;
2769                                             const char *symbol_name = dsc_local_symbols_data.PeekCStr(string_table_offset + nlist.n_strx);
2770 
2771                                             if (symbol_name == NULL)
2772                                             {
2773                                                 // No symbol should be NULL, even the symbols with no
2774                                                 // string values should have an offset zero which points
2775                                                 // to an empty C-string
2776                                                 Host::SystemLog (Host::eSystemLogError,
2777                                                                  "error: DSC unmapped local symbol[%u] has invalid string table offset 0x%x in %s, ignoring symbol\n",
2778                                                                  entry_index,
2779                                                                  nlist.n_strx,
2780                                                                  module_sp->GetFileSpec().GetPath().c_str());
2781                                                 continue;
2782                                             }
2783                                             if (symbol_name[0] == '\0')
2784                                                 symbol_name = NULL;
2785 
2786                                             const char *symbol_name_non_abi_mangled = NULL;
2787 
2788                                             SectionSP symbol_section;
2789                                             uint32_t symbol_byte_size = 0;
2790                                             bool add_nlist = true;
2791                                             bool is_debug = ((nlist.n_type & N_STAB) != 0);
2792                                             bool demangled_is_synthesized = false;
2793                                             bool is_gsym = false;
2794 
2795                                             assert (sym_idx < num_syms);
2796 
2797                                             sym[sym_idx].SetDebug (is_debug);
2798 
2799                                             if (is_debug)
2800                                             {
2801                                                 switch (nlist.n_type)
2802                                                 {
2803                                                     case N_GSYM:
2804                                                         // global symbol: name,,NO_SECT,type,0
2805                                                         // Sometimes the N_GSYM value contains the address.
2806 
2807                                                         // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data.  They
2808                                                         // have the same address, but we want to ensure that we always find only the real symbol,
2809                                                         // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
2810                                                         // symbol type.  This is a temporary hack to make sure the ObjectiveC symbols get treated
2811                                                         // correctly.  To do this right, we should coalesce all the GSYM & global symbols that have the
2812                                                         // same address.
2813 
2814                                                         if (symbol_name && symbol_name[0] == '_' && symbol_name[1] ==  'O'
2815                                                             && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
2816                                                                 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
2817                                                                 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
2818                                                             add_nlist = false;
2819                                                         else
2820                                                         {
2821                                                             is_gsym = true;
2822                                                             sym[sym_idx].SetExternal(true);
2823                                                             if (nlist.n_value != 0)
2824                                                                 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2825                                                             type = eSymbolTypeData;
2826                                                         }
2827                                                         break;
2828 
2829                                                     case N_FNAME:
2830                                                         // procedure name (f77 kludge): name,,NO_SECT,0,0
2831                                                         type = eSymbolTypeCompiler;
2832                                                         break;
2833 
2834                                                     case N_FUN:
2835                                                         // procedure: name,,n_sect,linenumber,address
2836                                                         if (symbol_name)
2837                                                         {
2838                                                             type = eSymbolTypeCode;
2839                                                             symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2840 
2841                                                             N_FUN_addr_to_sym_idx.insert(std::make_pair(nlist.n_value, sym_idx));
2842                                                             // We use the current number of symbols in the symbol table in lieu of
2843                                                             // using nlist_idx in case we ever start trimming entries out
2844                                                             N_FUN_indexes.push_back(sym_idx);
2845                                                         }
2846                                                         else
2847                                                         {
2848                                                             type = eSymbolTypeCompiler;
2849 
2850                                                             if ( !N_FUN_indexes.empty() )
2851                                                             {
2852                                                                 // Copy the size of the function into the original STAB entry so we don't have
2853                                                                 // to hunt for it later
2854                                                                 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
2855                                                                 N_FUN_indexes.pop_back();
2856                                                                 // We don't really need the end function STAB as it contains the size which
2857                                                                 // we already placed with the original symbol, so don't add it if we want a
2858                                                                 // minimal symbol table
2859                                                                 add_nlist = false;
2860                                                             }
2861                                                         }
2862                                                         break;
2863 
2864                                                     case N_STSYM:
2865                                                         // static symbol: name,,n_sect,type,address
2866                                                         N_STSYM_addr_to_sym_idx.insert(std::make_pair(nlist.n_value, sym_idx));
2867                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2868                                                         type = eSymbolTypeData;
2869                                                         break;
2870 
2871                                                     case N_LCSYM:
2872                                                         // .lcomm symbol: name,,n_sect,type,address
2873                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2874                                                         type = eSymbolTypeCommonBlock;
2875                                                         break;
2876 
2877                                                     case N_BNSYM:
2878                                                         // We use the current number of symbols in the symbol table in lieu of
2879                                                         // using nlist_idx in case we ever start trimming entries out
2880                                                         // Skip these if we want minimal symbol tables
2881                                                         add_nlist = false;
2882                                                         break;
2883 
2884                                                     case N_ENSYM:
2885                                                         // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
2886                                                         // so that we can always skip the entire symbol if we need to navigate
2887                                                         // more quickly at the source level when parsing STABS
2888                                                         // Skip these if we want minimal symbol tables
2889                                                         add_nlist = false;
2890                                                         break;
2891 
2892 
2893                                                     case N_OPT:
2894                                                         // emitted with gcc2_compiled and in gcc source
2895                                                         type = eSymbolTypeCompiler;
2896                                                         break;
2897 
2898                                                     case N_RSYM:
2899                                                         // register sym: name,,NO_SECT,type,register
2900                                                         type = eSymbolTypeVariable;
2901                                                         break;
2902 
2903                                                     case N_SLINE:
2904                                                         // src line: 0,,n_sect,linenumber,address
2905                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2906                                                         type = eSymbolTypeLineEntry;
2907                                                         break;
2908 
2909                                                     case N_SSYM:
2910                                                         // structure elt: name,,NO_SECT,type,struct_offset
2911                                                         type = eSymbolTypeVariableType;
2912                                                         break;
2913 
2914                                                     case N_SO:
2915                                                         // source file name
2916                                                         type = eSymbolTypeSourceFile;
2917                                                         if (symbol_name == NULL)
2918                                                         {
2919                                                             add_nlist = false;
2920                                                             if (N_SO_index != UINT32_MAX)
2921                                                             {
2922                                                                 // Set the size of the N_SO to the terminating index of this N_SO
2923                                                                 // so that we can always skip the entire N_SO if we need to navigate
2924                                                                 // more quickly at the source level when parsing STABS
2925                                                                 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
2926                                                                 symbol_ptr->SetByteSize(sym_idx);
2927                                                                 symbol_ptr->SetSizeIsSibling(true);
2928                                                             }
2929                                                             N_NSYM_indexes.clear();
2930                                                             N_INCL_indexes.clear();
2931                                                             N_BRAC_indexes.clear();
2932                                                             N_COMM_indexes.clear();
2933                                                             N_FUN_indexes.clear();
2934                                                             N_SO_index = UINT32_MAX;
2935                                                         }
2936                                                         else
2937                                                         {
2938                                                             // We use the current number of symbols in the symbol table in lieu of
2939                                                             // using nlist_idx in case we ever start trimming entries out
2940                                                             const bool N_SO_has_full_path = symbol_name[0] == '/';
2941                                                             if (N_SO_has_full_path)
2942                                                             {
2943                                                                 if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2944                                                                 {
2945                                                                     // We have two consecutive N_SO entries where the first contains a directory
2946                                                                     // and the second contains a full path.
2947                                                                     sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
2948                                                                     m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2949                                                                     add_nlist = false;
2950                                                                 }
2951                                                                 else
2952                                                                 {
2953                                                                     // This is the first entry in a N_SO that contains a directory or
2954                                                                     // a full path to the source file
2955                                                                     N_SO_index = sym_idx;
2956                                                                 }
2957                                                             }
2958                                                             else if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2959                                                             {
2960                                                                 // This is usually the second N_SO entry that contains just the filename,
2961                                                                 // so here we combine it with the first one if we are minimizing the symbol table
2962                                                                 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
2963                                                                 if (so_path && so_path[0])
2964                                                                 {
2965                                                                     std::string full_so_path (so_path);
2966                                                                     const size_t double_slash_pos = full_so_path.find("//");
2967                                                                     if (double_slash_pos != std::string::npos)
2968                                                                     {
2969                                                                         // The linker has been generating bad N_SO entries with doubled up paths
2970                                                                         // in the format "%s%s" where the first string in the DW_AT_comp_dir,
2971                                                                         // and the second is the directory for the source file so you end up with
2972                                                                         // a path that looks like "/tmp/src//tmp/src/"
2973                                                                         FileSpec so_dir(so_path, false);
2974                                                                         if (!so_dir.Exists())
2975                                                                         {
2976                                                                             so_dir.SetFile(&full_so_path[double_slash_pos + 1], false);
2977                                                                             if (so_dir.Exists())
2978                                                                             {
2979                                                                                 // Trim off the incorrect path
2980                                                                                 full_so_path.erase(0, double_slash_pos + 1);
2981                                                                             }
2982                                                                         }
2983                                                                     }
2984                                                                     if (*full_so_path.rbegin() != '/')
2985                                                                         full_so_path += '/';
2986                                                                     full_so_path += symbol_name;
2987                                                                     sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
2988                                                                     add_nlist = false;
2989                                                                     m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2990                                                                 }
2991                                                             }
2992                                                             else
2993                                                             {
2994                                                                 // This could be a relative path to a N_SO
2995                                                                 N_SO_index = sym_idx;
2996                                                             }
2997                                                         }
2998                                                         break;
2999 
3000                                                     case N_OSO:
3001                                                         // object file name: name,,0,0,st_mtime
3002                                                         type = eSymbolTypeObjectFile;
3003                                                         break;
3004 
3005                                                     case N_LSYM:
3006                                                         // local sym: name,,NO_SECT,type,offset
3007                                                         type = eSymbolTypeLocal;
3008                                                         break;
3009 
3010                                                         //----------------------------------------------------------------------
3011                                                         // INCL scopes
3012                                                         //----------------------------------------------------------------------
3013                                                     case N_BINCL:
3014                                                         // include file beginning: name,,NO_SECT,0,sum
3015                                                         // We use the current number of symbols in the symbol table in lieu of
3016                                                         // using nlist_idx in case we ever start trimming entries out
3017                                                         N_INCL_indexes.push_back(sym_idx);
3018                                                         type = eSymbolTypeScopeBegin;
3019                                                         break;
3020 
3021                                                     case N_EINCL:
3022                                                         // include file end: name,,NO_SECT,0,0
3023                                                         // Set the size of the N_BINCL to the terminating index of this N_EINCL
3024                                                         // so that we can always skip the entire symbol if we need to navigate
3025                                                         // more quickly at the source level when parsing STABS
3026                                                         if ( !N_INCL_indexes.empty() )
3027                                                         {
3028                                                             symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
3029                                                             symbol_ptr->SetByteSize(sym_idx + 1);
3030                                                             symbol_ptr->SetSizeIsSibling(true);
3031                                                             N_INCL_indexes.pop_back();
3032                                                         }
3033                                                         type = eSymbolTypeScopeEnd;
3034                                                         break;
3035 
3036                                                     case N_SOL:
3037                                                         // #included file name: name,,n_sect,0,address
3038                                                         type = eSymbolTypeHeaderFile;
3039 
3040                                                         // We currently don't use the header files on darwin
3041                                                         add_nlist = false;
3042                                                         break;
3043 
3044                                                     case N_PARAMS:
3045                                                         // compiler parameters: name,,NO_SECT,0,0
3046                                                         type = eSymbolTypeCompiler;
3047                                                         break;
3048 
3049                                                     case N_VERSION:
3050                                                         // compiler version: name,,NO_SECT,0,0
3051                                                         type = eSymbolTypeCompiler;
3052                                                         break;
3053 
3054                                                     case N_OLEVEL:
3055                                                         // compiler -O level: name,,NO_SECT,0,0
3056                                                         type = eSymbolTypeCompiler;
3057                                                         break;
3058 
3059                                                     case N_PSYM:
3060                                                         // parameter: name,,NO_SECT,type,offset
3061                                                         type = eSymbolTypeVariable;
3062                                                         break;
3063 
3064                                                     case N_ENTRY:
3065                                                         // alternate entry: name,,n_sect,linenumber,address
3066                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3067                                                         type = eSymbolTypeLineEntry;
3068                                                         break;
3069 
3070                                                         //----------------------------------------------------------------------
3071                                                         // Left and Right Braces
3072                                                         //----------------------------------------------------------------------
3073                                                     case N_LBRAC:
3074                                                         // left bracket: 0,,NO_SECT,nesting level,address
3075                                                         // We use the current number of symbols in the symbol table in lieu of
3076                                                         // using nlist_idx in case we ever start trimming entries out
3077                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3078                                                         N_BRAC_indexes.push_back(sym_idx);
3079                                                         type = eSymbolTypeScopeBegin;
3080                                                         break;
3081 
3082                                                     case N_RBRAC:
3083                                                         // right bracket: 0,,NO_SECT,nesting level,address
3084                                                         // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
3085                                                         // so that we can always skip the entire symbol if we need to navigate
3086                                                         // more quickly at the source level when parsing STABS
3087                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3088                                                         if ( !N_BRAC_indexes.empty() )
3089                                                         {
3090                                                             symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
3091                                                             symbol_ptr->SetByteSize(sym_idx + 1);
3092                                                             symbol_ptr->SetSizeIsSibling(true);
3093                                                             N_BRAC_indexes.pop_back();
3094                                                         }
3095                                                         type = eSymbolTypeScopeEnd;
3096                                                         break;
3097 
3098                                                     case N_EXCL:
3099                                                         // deleted include file: name,,NO_SECT,0,sum
3100                                                         type = eSymbolTypeHeaderFile;
3101                                                         break;
3102 
3103                                                         //----------------------------------------------------------------------
3104                                                         // COMM scopes
3105                                                         //----------------------------------------------------------------------
3106                                                     case N_BCOMM:
3107                                                         // begin common: name,,NO_SECT,0,0
3108                                                         // We use the current number of symbols in the symbol table in lieu of
3109                                                         // using nlist_idx in case we ever start trimming entries out
3110                                                         type = eSymbolTypeScopeBegin;
3111                                                         N_COMM_indexes.push_back(sym_idx);
3112                                                         break;
3113 
3114                                                     case N_ECOML:
3115                                                         // end common (local name): 0,,n_sect,0,address
3116                                                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3117                                                         // Fall through
3118 
3119                                                     case N_ECOMM:
3120                                                         // end common: name,,n_sect,0,0
3121                                                         // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
3122                                                         // so that we can always skip the entire symbol if we need to navigate
3123                                                         // more quickly at the source level when parsing STABS
3124                                                         if ( !N_COMM_indexes.empty() )
3125                                                         {
3126                                                             symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
3127                                                             symbol_ptr->SetByteSize(sym_idx + 1);
3128                                                             symbol_ptr->SetSizeIsSibling(true);
3129                                                             N_COMM_indexes.pop_back();
3130                                                         }
3131                                                         type = eSymbolTypeScopeEnd;
3132                                                         break;
3133 
3134                                                     case N_LENG:
3135                                                         // second stab entry with length information
3136                                                         type = eSymbolTypeAdditional;
3137                                                         break;
3138 
3139                                                     default: break;
3140                                                 }
3141                                             }
3142                                             else
3143                                             {
3144                                                 //uint8_t n_pext    = N_PEXT & nlist.n_type;
3145                                                 uint8_t n_type  = N_TYPE & nlist.n_type;
3146                                                 sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
3147 
3148                                                 switch (n_type)
3149                                                 {
3150                                                     case N_INDR: // Fall through
3151                                                     case N_PBUD: // Fall through
3152                                                     case N_UNDF:
3153                                                         type = eSymbolTypeUndefined;
3154                                                         break;
3155 
3156                                                     case N_ABS:
3157                                                         type = eSymbolTypeAbsolute;
3158                                                         break;
3159 
3160                                                     case N_SECT:
3161                                                         {
3162                                                             symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3163 
3164                                                             if (symbol_section == NULL)
3165                                                             {
3166                                                                 // TODO: warn about this?
3167                                                                 add_nlist = false;
3168                                                                 break;
3169                                                             }
3170 
3171                                                             if (TEXT_eh_frame_sectID == nlist.n_sect)
3172                                                             {
3173                                                                 type = eSymbolTypeException;
3174                                                             }
3175                                                             else
3176                                                             {
3177                                                                 uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
3178 
3179                                                                 switch (section_type)
3180                                                                 {
3181                                                                     case S_CSTRING_LITERALS:           type = eSymbolTypeData;    break; // section with only literal C strings
3182                                                                     case S_4BYTE_LITERALS:             type = eSymbolTypeData;    break; // section with only 4 byte literals
3183                                                                     case S_8BYTE_LITERALS:             type = eSymbolTypeData;    break; // section with only 8 byte literals
3184                                                                     case S_LITERAL_POINTERS:           type = eSymbolTypeTrampoline; break; // section with only pointers to literals
3185                                                                     case S_NON_LAZY_SYMBOL_POINTERS:   type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
3186                                                                     case S_LAZY_SYMBOL_POINTERS:       type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
3187                                                                     case S_SYMBOL_STUBS:               type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
3188                                                                     case S_MOD_INIT_FUNC_POINTERS:     type = eSymbolTypeCode;    break; // section with only function pointers for initialization
3189                                                                     case S_MOD_TERM_FUNC_POINTERS:     type = eSymbolTypeCode;    break; // section with only function pointers for termination
3190                                                                     case S_INTERPOSING:                type = eSymbolTypeTrampoline;  break; // section with only pairs of function pointers for interposing
3191                                                                     case S_16BYTE_LITERALS:            type = eSymbolTypeData;    break; // section with only 16 byte literals
3192                                                                     case S_DTRACE_DOF:                 type = eSymbolTypeInstrumentation; break;
3193                                                                     case S_LAZY_DYLIB_SYMBOL_POINTERS: type = eSymbolTypeTrampoline; break;
3194                                                                     default:
3195                                                                         switch (symbol_section->GetType())
3196                                                                         {
3197                                                                             case lldb::eSectionTypeCode:
3198                                                                                 type = eSymbolTypeCode;
3199                                                                                 break;
3200                                                                             case eSectionTypeData:
3201                                                                             case eSectionTypeDataCString:            // Inlined C string data
3202                                                                             case eSectionTypeDataCStringPointers:    // Pointers to C string data
3203                                                                             case eSectionTypeDataSymbolAddress:      // Address of a symbol in the symbol table
3204                                                                             case eSectionTypeData4:
3205                                                                             case eSectionTypeData8:
3206                                                                             case eSectionTypeData16:
3207                                                                                 type = eSymbolTypeData;
3208                                                                                 break;
3209                                                                             default:
3210                                                                                 break;
3211                                                                         }
3212                                                                         break;
3213                                                                 }
3214 
3215                                                                 if (type == eSymbolTypeInvalid)
3216                                                                 {
3217                                                                     const char *symbol_sect_name = symbol_section->GetName().AsCString();
3218                                                                     if (symbol_section->IsDescendant (text_section_sp.get()))
3219                                                                     {
3220                                                                         if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
3221                                                                                                     S_ATTR_SELF_MODIFYING_CODE |
3222                                                                                                     S_ATTR_SOME_INSTRUCTIONS))
3223                                                                             type = eSymbolTypeData;
3224                                                                         else
3225                                                                             type = eSymbolTypeCode;
3226                                                                     }
3227                                                                     else if (symbol_section->IsDescendant(data_section_sp.get()))
3228                                                                     {
3229                                                                         if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
3230                                                                         {
3231                                                                             type = eSymbolTypeRuntime;
3232 
3233                                                                             if (symbol_name &&
3234                                                                                 symbol_name[0] == '_' &&
3235                                                                                 symbol_name[1] == 'O' &&
3236                                                                                 symbol_name[2] == 'B')
3237                                                                             {
3238                                                                                 llvm::StringRef symbol_name_ref(symbol_name);
3239                                                                                 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
3240                                                                                 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
3241                                                                                 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
3242                                                                                 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
3243                                                                                 {
3244                                                                                     symbol_name_non_abi_mangled = symbol_name + 1;
3245                                                                                     symbol_name = symbol_name + g_objc_v2_prefix_class.size();
3246                                                                                     type = eSymbolTypeObjCClass;
3247                                                                                     demangled_is_synthesized = true;
3248                                                                                 }
3249                                                                                 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
3250                                                                                 {
3251                                                                                     symbol_name_non_abi_mangled = symbol_name + 1;
3252                                                                                     symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
3253                                                                                     type = eSymbolTypeObjCMetaClass;
3254                                                                                     demangled_is_synthesized = true;
3255                                                                                 }
3256                                                                                 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
3257                                                                                 {
3258                                                                                     symbol_name_non_abi_mangled = symbol_name + 1;
3259                                                                                     symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
3260                                                                                     type = eSymbolTypeObjCIVar;
3261                                                                                     demangled_is_synthesized = true;
3262                                                                                 }
3263                                                                             }
3264                                                                         }
3265                                                                         else if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
3266                                                                         {
3267                                                                             type = eSymbolTypeException;
3268                                                                         }
3269                                                                         else
3270                                                                         {
3271                                                                             type = eSymbolTypeData;
3272                                                                         }
3273                                                                     }
3274                                                                     else if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
3275                                                                     {
3276                                                                         type = eSymbolTypeTrampoline;
3277                                                                     }
3278                                                                     else if (symbol_section->IsDescendant(objc_section_sp.get()))
3279                                                                     {
3280                                                                         type = eSymbolTypeRuntime;
3281                                                                         if (symbol_name && symbol_name[0] == '.')
3282                                                                         {
3283                                                                             llvm::StringRef symbol_name_ref(symbol_name);
3284                                                                             static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
3285                                                                             if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
3286                                                                             {
3287                                                                                 symbol_name_non_abi_mangled = symbol_name;
3288                                                                                 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
3289                                                                                 type = eSymbolTypeObjCClass;
3290                                                                                 demangled_is_synthesized = true;
3291                                                                             }
3292                                                                         }
3293                                                                     }
3294                                                                 }
3295                                                             }
3296                                                         }
3297                                                         break;
3298                                                 }
3299                                             }
3300 
3301                                             if (add_nlist)
3302                                             {
3303                                                 uint64_t symbol_value = nlist.n_value;
3304                                                 if (symbol_name_non_abi_mangled)
3305                                                 {
3306                                                     sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
3307                                                     sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
3308                                                 }
3309                                                 else
3310                                                 {
3311                                                     bool symbol_name_is_mangled = false;
3312 
3313                                                     if (symbol_name && symbol_name[0] == '_')
3314                                                     {
3315                                                         symbol_name_is_mangled = symbol_name[1] == '_';
3316                                                         symbol_name++;  // Skip the leading underscore
3317                                                     }
3318 
3319                                                     if (symbol_name)
3320                                                     {
3321                                                         ConstString const_symbol_name(symbol_name);
3322                                                         sym[sym_idx].GetMangled().SetValue(const_symbol_name, symbol_name_is_mangled);
3323                                                         if (is_gsym && is_debug)
3324                                                             N_GSYM_name_to_sym_idx[sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled).GetCString()] = sym_idx;
3325                                                     }
3326                                                 }
3327                                                 if (symbol_section)
3328                                                 {
3329                                                     const addr_t section_file_addr = symbol_section->GetFileAddress();
3330                                                     if (symbol_byte_size == 0 && function_starts_count > 0)
3331                                                     {
3332                                                         addr_t symbol_lookup_file_addr = nlist.n_value;
3333                                                         // Do an exact address match for non-ARM addresses, else get the closest since
3334                                                         // the symbol might be a thumb symbol which has an address with bit zero set
3335                                                         FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
3336                                                         if (is_arm && func_start_entry)
3337                                                         {
3338                                                             // Verify that the function start address is the symbol address (ARM)
3339                                                             // or the symbol address + 1 (thumb)
3340                                                             if (func_start_entry->addr != symbol_lookup_file_addr &&
3341                                                                 func_start_entry->addr != (symbol_lookup_file_addr + 1))
3342                                                             {
3343                                                                 // Not the right entry, NULL it out...
3344                                                                 func_start_entry = NULL;
3345                                                             }
3346                                                         }
3347                                                         if (func_start_entry)
3348                                                         {
3349                                                             func_start_entry->data = true;
3350 
3351                                                             addr_t symbol_file_addr = func_start_entry->addr;
3352                                                             uint32_t symbol_flags = 0;
3353                                                             if (is_arm)
3354                                                             {
3355                                                                 if (symbol_file_addr & 1)
3356                                                                     symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
3357                                                                 symbol_file_addr &= 0xfffffffffffffffeull;
3358                                                             }
3359 
3360                                                             const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
3361                                                             const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
3362                                                             if (next_func_start_entry)
3363                                                             {
3364                                                                 addr_t next_symbol_file_addr = next_func_start_entry->addr;
3365                                                                 // Be sure the clear the Thumb address bit when we calculate the size
3366                                                                 // from the current and next address
3367                                                                 if (is_arm)
3368                                                                     next_symbol_file_addr &= 0xfffffffffffffffeull;
3369                                                                 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
3370                                                             }
3371                                                             else
3372                                                             {
3373                                                                 symbol_byte_size = section_end_file_addr - symbol_file_addr;
3374                                                             }
3375                                                         }
3376                                                     }
3377                                                     symbol_value -= section_file_addr;
3378                                                 }
3379 
3380                                                 if (is_debug == false)
3381                                                 {
3382                                                     if (type == eSymbolTypeCode)
3383                                                     {
3384                                                         // See if we can find a N_FUN entry for any code symbols.
3385                                                         // If we do find a match, and the name matches, then we
3386                                                         // can merge the two into just the function symbol to avoid
3387                                                         // duplicate entries in the symbol table
3388                                                         std::pair<ValueToSymbolIndexMap::const_iterator, ValueToSymbolIndexMap::const_iterator> range;
3389                                                         range = N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
3390                                                         if (range.first != range.second)
3391                                                         {
3392                                                             bool found_it = false;
3393                                                             for (ValueToSymbolIndexMap::const_iterator pos = range.first; pos != range.second; ++pos)
3394                                                             {
3395                                                                 if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) == sym[pos->second].GetMangled().GetName(Mangled::ePreferMangled))
3396                                                                 {
3397                                                                     m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3398                                                                     // We just need the flags from the linker symbol, so put these flags
3399                                                                     // into the N_FUN flags to avoid duplicate symbols in the symbol table
3400                                                                     sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
3401                                                                     sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3402                                                                     if (resolver_addresses.find(nlist.n_value) != resolver_addresses.end())
3403                                                                         sym[pos->second].SetType (eSymbolTypeResolver);
3404                                                                     sym[sym_idx].Clear();
3405                                                                     found_it = true;
3406                                                                     break;
3407                                                                 }
3408                                                             }
3409                                                             if (found_it)
3410                                                                 continue;
3411                                                         }
3412                                                         else
3413                                                         {
3414                                                             if (resolver_addresses.find(nlist.n_value) != resolver_addresses.end())
3415                                                                 type = eSymbolTypeResolver;
3416                                                         }
3417                                                     }
3418                                                     else if (type == eSymbolTypeData)
3419                                                     {
3420                                                         // See if we can find a N_STSYM entry for any data symbols.
3421                                                         // If we do find a match, and the name matches, then we
3422                                                         // can merge the two into just the Static symbol to avoid
3423                                                         // duplicate entries in the symbol table
3424                                                         std::pair<ValueToSymbolIndexMap::const_iterator, ValueToSymbolIndexMap::const_iterator> range;
3425                                                         range = N_STSYM_addr_to_sym_idx.equal_range(nlist.n_value);
3426                                                         if (range.first != range.second)
3427                                                         {
3428                                                             bool found_it = false;
3429                                                             for (ValueToSymbolIndexMap::const_iterator pos = range.first; pos != range.second; ++pos)
3430                                                             {
3431                                                                 if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) == sym[pos->second].GetMangled().GetName(Mangled::ePreferMangled))
3432                                                                 {
3433                                                                     m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3434                                                                     // We just need the flags from the linker symbol, so put these flags
3435                                                                     // into the N_STSYM flags to avoid duplicate symbols in the symbol table
3436                                                                     sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
3437                                                                     sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3438                                                                     sym[sym_idx].Clear();
3439                                                                     found_it = true;
3440                                                                     break;
3441                                                                 }
3442                                                             }
3443                                                             if (found_it)
3444                                                                 continue;
3445                                                         }
3446                                                         else
3447                                                         {
3448                                                             // Combine N_GSYM stab entries with the non stab symbol
3449                                                             ConstNameToSymbolIndexMap::const_iterator pos = N_GSYM_name_to_sym_idx.find(sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled).GetCString());
3450                                                             if (pos != N_GSYM_name_to_sym_idx.end())
3451                                                             {
3452                                                                 const uint32_t GSYM_sym_idx = pos->second;
3453                                                                 m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
3454                                                                 // Copy the address, because often the N_GSYM address has an invalid address of zero
3455                                                                 // when the global is a common symbol
3456                                                                 sym[GSYM_sym_idx].GetAddress().SetSection (symbol_section);
3457                                                                 sym[GSYM_sym_idx].GetAddress().SetOffset (symbol_value);
3458                                                                 // We just need the flags from the linker symbol, so put these flags
3459                                                                 // into the N_STSYM flags to avoid duplicate symbols in the symbol table
3460                                                                 sym[GSYM_sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3461                                                                 sym[sym_idx].Clear();
3462                                                                 continue;
3463                                                             }
3464                                                         }
3465                                                     }
3466                                                 }
3467 
3468                                                 sym[sym_idx].SetID (nlist_idx);
3469                                                 sym[sym_idx].SetType (type);
3470                                                 sym[sym_idx].GetAddress().SetSection (symbol_section);
3471                                                 sym[sym_idx].GetAddress().SetOffset (symbol_value);
3472                                                 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3473 
3474                                                 if (symbol_byte_size > 0)
3475                                                     sym[sym_idx].SetByteSize(symbol_byte_size);
3476 
3477                                                 if (demangled_is_synthesized)
3478                                                     sym[sym_idx].SetDemangledNameIsSynthesized(true);
3479                                                 ++sym_idx;
3480                                             }
3481                                             else
3482                                             {
3483                                                 sym[sym_idx].Clear();
3484                                             }
3485 
3486                                         }
3487                                         /////////////////////////////
3488                                     }
3489                                     break; // No more entries to consider
3490                                 }
3491                             }
3492                         }
3493                     }
3494                 }
3495             }
3496         }
3497 
3498         // Must reset this in case it was mutated above!
3499         nlist_data_offset = 0;
3500 #endif
3501 
3502         if (nlist_data.GetByteSize() > 0)
3503         {
3504 
3505             // If the sym array was not created while parsing the DSC unmapped
3506             // symbols, create it now.
3507             if (sym == NULL)
3508             {
3509                 sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
3510                 num_syms = symtab->GetNumSymbols();
3511             }
3512 
3513             if (unmapped_local_symbols_found)
3514             {
3515                 assert(m_dysymtab.ilocalsym == 0);
3516                 nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
3517                 nlist_idx = m_dysymtab.nlocalsym;
3518             }
3519             else
3520             {
3521                 nlist_idx = 0;
3522             }
3523 
3524             for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx)
3525             {
3526                 struct nlist_64 nlist;
3527                 if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
3528                     break;
3529 
3530                 nlist.n_strx  = nlist_data.GetU32_unchecked(&nlist_data_offset);
3531                 nlist.n_type  = nlist_data.GetU8_unchecked (&nlist_data_offset);
3532                 nlist.n_sect  = nlist_data.GetU8_unchecked (&nlist_data_offset);
3533                 nlist.n_desc  = nlist_data.GetU16_unchecked (&nlist_data_offset);
3534                 nlist.n_value = nlist_data.GetAddress_unchecked (&nlist_data_offset);
3535 
3536                 SymbolType type = eSymbolTypeInvalid;
3537                 const char *symbol_name = NULL;
3538 
3539                 if (have_strtab_data)
3540                 {
3541                     symbol_name = strtab_data.PeekCStr(nlist.n_strx);
3542 
3543                     if (symbol_name == NULL)
3544                     {
3545                         // No symbol should be NULL, even the symbols with no
3546                         // string values should have an offset zero which points
3547                         // to an empty C-string
3548                         Host::SystemLog (Host::eSystemLogError,
3549                                          "error: symbol[%u] has invalid string table offset 0x%x in %s, ignoring symbol\n",
3550                                          nlist_idx,
3551                                          nlist.n_strx,
3552                                          module_sp->GetFileSpec().GetPath().c_str());
3553                         continue;
3554                     }
3555                     if (symbol_name[0] == '\0')
3556                         symbol_name = NULL;
3557                 }
3558                 else
3559                 {
3560                     const addr_t str_addr = strtab_addr + nlist.n_strx;
3561                     Error str_error;
3562                     if (process->ReadCStringFromMemory(str_addr, memory_symbol_name, str_error))
3563                         symbol_name = memory_symbol_name.c_str();
3564                 }
3565                 const char *symbol_name_non_abi_mangled = NULL;
3566 
3567                 SectionSP symbol_section;
3568                 lldb::addr_t symbol_byte_size = 0;
3569                 bool add_nlist = true;
3570                 bool is_gsym = false;
3571                 bool is_debug = ((nlist.n_type & N_STAB) != 0);
3572                 bool demangled_is_synthesized = false;
3573 
3574                 assert (sym_idx < num_syms);
3575 
3576                 sym[sym_idx].SetDebug (is_debug);
3577 
3578                 if (is_debug)
3579                 {
3580                     switch (nlist.n_type)
3581                     {
3582                     case N_GSYM:
3583                         // global symbol: name,,NO_SECT,type,0
3584                         // Sometimes the N_GSYM value contains the address.
3585 
3586                         // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data.  They
3587                         // have the same address, but we want to ensure that we always find only the real symbol,
3588                         // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
3589                         // symbol type.  This is a temporary hack to make sure the ObjectiveC symbols get treated
3590                         // correctly.  To do this right, we should coalesce all the GSYM & global symbols that have the
3591                         // same address.
3592 
3593                         if (symbol_name && symbol_name[0] == '_' && symbol_name[1] ==  'O'
3594                             && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
3595                                 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
3596                                 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
3597                             add_nlist = false;
3598                         else
3599                         {
3600                             is_gsym = true;
3601                             sym[sym_idx].SetExternal(true);
3602                             if (nlist.n_value != 0)
3603                                 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3604                             type = eSymbolTypeData;
3605                         }
3606                         break;
3607 
3608                     case N_FNAME:
3609                         // procedure name (f77 kludge): name,,NO_SECT,0,0
3610                         type = eSymbolTypeCompiler;
3611                         break;
3612 
3613                     case N_FUN:
3614                         // procedure: name,,n_sect,linenumber,address
3615                         if (symbol_name)
3616                         {
3617                             type = eSymbolTypeCode;
3618                             symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3619 
3620                             N_FUN_addr_to_sym_idx.insert(std::make_pair(nlist.n_value, sym_idx));
3621                             // We use the current number of symbols in the symbol table in lieu of
3622                             // using nlist_idx in case we ever start trimming entries out
3623                             N_FUN_indexes.push_back(sym_idx);
3624                         }
3625                         else
3626                         {
3627                             type = eSymbolTypeCompiler;
3628 
3629                             if ( !N_FUN_indexes.empty() )
3630                             {
3631                                 // Copy the size of the function into the original STAB entry so we don't have
3632                                 // to hunt for it later
3633                                 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
3634                                 N_FUN_indexes.pop_back();
3635                                 // We don't really need the end function STAB as it contains the size which
3636                                 // we already placed with the original symbol, so don't add it if we want a
3637                                 // minimal symbol table
3638                                 add_nlist = false;
3639                             }
3640                         }
3641                         break;
3642 
3643                     case N_STSYM:
3644                         // static symbol: name,,n_sect,type,address
3645                         N_STSYM_addr_to_sym_idx.insert(std::make_pair(nlist.n_value, sym_idx));
3646                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3647                         type = eSymbolTypeData;
3648                         break;
3649 
3650                     case N_LCSYM:
3651                         // .lcomm symbol: name,,n_sect,type,address
3652                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3653                         type = eSymbolTypeCommonBlock;
3654                         break;
3655 
3656                     case N_BNSYM:
3657                         // We use the current number of symbols in the symbol table in lieu of
3658                         // using nlist_idx in case we ever start trimming entries out
3659                         // Skip these if we want minimal symbol tables
3660                         add_nlist = false;
3661                         break;
3662 
3663                     case N_ENSYM:
3664                         // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
3665                         // so that we can always skip the entire symbol if we need to navigate
3666                         // more quickly at the source level when parsing STABS
3667                         // Skip these if we want minimal symbol tables
3668                         add_nlist = false;
3669                         break;
3670 
3671 
3672                     case N_OPT:
3673                         // emitted with gcc2_compiled and in gcc source
3674                         type = eSymbolTypeCompiler;
3675                         break;
3676 
3677                     case N_RSYM:
3678                         // register sym: name,,NO_SECT,type,register
3679                         type = eSymbolTypeVariable;
3680                         break;
3681 
3682                     case N_SLINE:
3683                         // src line: 0,,n_sect,linenumber,address
3684                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3685                         type = eSymbolTypeLineEntry;
3686                         break;
3687 
3688                     case N_SSYM:
3689                         // structure elt: name,,NO_SECT,type,struct_offset
3690                         type = eSymbolTypeVariableType;
3691                         break;
3692 
3693                     case N_SO:
3694                         // source file name
3695                         type = eSymbolTypeSourceFile;
3696                         if (symbol_name == NULL)
3697                         {
3698                             add_nlist = false;
3699                             if (N_SO_index != UINT32_MAX)
3700                             {
3701                                 // Set the size of the N_SO to the terminating index of this N_SO
3702                                 // so that we can always skip the entire N_SO if we need to navigate
3703                                 // more quickly at the source level when parsing STABS
3704                                 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
3705                                 symbol_ptr->SetByteSize(sym_idx);
3706                                 symbol_ptr->SetSizeIsSibling(true);
3707                             }
3708                             N_NSYM_indexes.clear();
3709                             N_INCL_indexes.clear();
3710                             N_BRAC_indexes.clear();
3711                             N_COMM_indexes.clear();
3712                             N_FUN_indexes.clear();
3713                             N_SO_index = UINT32_MAX;
3714                         }
3715                         else
3716                         {
3717                             // We use the current number of symbols in the symbol table in lieu of
3718                             // using nlist_idx in case we ever start trimming entries out
3719                             const bool N_SO_has_full_path = symbol_name[0] == '/';
3720                             if (N_SO_has_full_path)
3721                             {
3722                                 if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
3723                                 {
3724                                     // We have two consecutive N_SO entries where the first contains a directory
3725                                     // and the second contains a full path.
3726                                     sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
3727                                     m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3728                                     add_nlist = false;
3729                                 }
3730                                 else
3731                                 {
3732                                     // This is the first entry in a N_SO that contains a directory or
3733                                     // a full path to the source file
3734                                     N_SO_index = sym_idx;
3735                                 }
3736                             }
3737                             else if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
3738                             {
3739                                 // This is usually the second N_SO entry that contains just the filename,
3740                                 // so here we combine it with the first one if we are minimizing the symbol table
3741                                 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
3742                                 if (so_path && so_path[0])
3743                                 {
3744                                     std::string full_so_path (so_path);
3745                                     const size_t double_slash_pos = full_so_path.find("//");
3746                                     if (double_slash_pos != std::string::npos)
3747                                     {
3748                                         // The linker has been generating bad N_SO entries with doubled up paths
3749                                         // in the format "%s%s" where the first string in the DW_AT_comp_dir,
3750                                         // and the second is the directory for the source file so you end up with
3751                                         // a path that looks like "/tmp/src//tmp/src/"
3752                                         FileSpec so_dir(so_path, false);
3753                                         if (!so_dir.Exists())
3754                                         {
3755                                             so_dir.SetFile(&full_so_path[double_slash_pos + 1], false);
3756                                             if (so_dir.Exists())
3757                                             {
3758                                                 // Trim off the incorrect path
3759                                                 full_so_path.erase(0, double_slash_pos + 1);
3760                                             }
3761                                         }
3762                                     }
3763                                     if (*full_so_path.rbegin() != '/')
3764                                         full_so_path += '/';
3765                                     full_so_path += symbol_name;
3766                                     sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
3767                                     add_nlist = false;
3768                                     m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3769                                 }
3770                             }
3771                             else
3772                             {
3773                                 // This could be a relative path to a N_SO
3774                                 N_SO_index = sym_idx;
3775                             }
3776                         }
3777 
3778                         break;
3779 
3780                     case N_OSO:
3781                         // object file name: name,,0,0,st_mtime
3782                         type = eSymbolTypeObjectFile;
3783                         break;
3784 
3785                     case N_LSYM:
3786                         // local sym: name,,NO_SECT,type,offset
3787                         type = eSymbolTypeLocal;
3788                         break;
3789 
3790                     //----------------------------------------------------------------------
3791                     // INCL scopes
3792                     //----------------------------------------------------------------------
3793                     case N_BINCL:
3794                         // include file beginning: name,,NO_SECT,0,sum
3795                         // We use the current number of symbols in the symbol table in lieu of
3796                         // using nlist_idx in case we ever start trimming entries out
3797                         N_INCL_indexes.push_back(sym_idx);
3798                         type = eSymbolTypeScopeBegin;
3799                         break;
3800 
3801                     case N_EINCL:
3802                         // include file end: name,,NO_SECT,0,0
3803                         // Set the size of the N_BINCL to the terminating index of this N_EINCL
3804                         // so that we can always skip the entire symbol if we need to navigate
3805                         // more quickly at the source level when parsing STABS
3806                         if ( !N_INCL_indexes.empty() )
3807                         {
3808                             symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
3809                             symbol_ptr->SetByteSize(sym_idx + 1);
3810                             symbol_ptr->SetSizeIsSibling(true);
3811                             N_INCL_indexes.pop_back();
3812                         }
3813                         type = eSymbolTypeScopeEnd;
3814                         break;
3815 
3816                     case N_SOL:
3817                         // #included file name: name,,n_sect,0,address
3818                         type = eSymbolTypeHeaderFile;
3819 
3820                         // We currently don't use the header files on darwin
3821                         add_nlist = false;
3822                         break;
3823 
3824                     case N_PARAMS:
3825                         // compiler parameters: name,,NO_SECT,0,0
3826                         type = eSymbolTypeCompiler;
3827                         break;
3828 
3829                     case N_VERSION:
3830                         // compiler version: name,,NO_SECT,0,0
3831                         type = eSymbolTypeCompiler;
3832                         break;
3833 
3834                     case N_OLEVEL:
3835                         // compiler -O level: name,,NO_SECT,0,0
3836                         type = eSymbolTypeCompiler;
3837                         break;
3838 
3839                     case N_PSYM:
3840                         // parameter: name,,NO_SECT,type,offset
3841                         type = eSymbolTypeVariable;
3842                         break;
3843 
3844                     case N_ENTRY:
3845                         // alternate entry: name,,n_sect,linenumber,address
3846                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3847                         type = eSymbolTypeLineEntry;
3848                         break;
3849 
3850                     //----------------------------------------------------------------------
3851                     // Left and Right Braces
3852                     //----------------------------------------------------------------------
3853                     case N_LBRAC:
3854                         // left bracket: 0,,NO_SECT,nesting level,address
3855                         // We use the current number of symbols in the symbol table in lieu of
3856                         // using nlist_idx in case we ever start trimming entries out
3857                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3858                         N_BRAC_indexes.push_back(sym_idx);
3859                         type = eSymbolTypeScopeBegin;
3860                         break;
3861 
3862                     case N_RBRAC:
3863                         // right bracket: 0,,NO_SECT,nesting level,address
3864                         // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
3865                         // so that we can always skip the entire symbol if we need to navigate
3866                         // more quickly at the source level when parsing STABS
3867                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3868                         if ( !N_BRAC_indexes.empty() )
3869                         {
3870                             symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
3871                             symbol_ptr->SetByteSize(sym_idx + 1);
3872                             symbol_ptr->SetSizeIsSibling(true);
3873                             N_BRAC_indexes.pop_back();
3874                         }
3875                         type = eSymbolTypeScopeEnd;
3876                         break;
3877 
3878                     case N_EXCL:
3879                         // deleted include file: name,,NO_SECT,0,sum
3880                         type = eSymbolTypeHeaderFile;
3881                         break;
3882 
3883                     //----------------------------------------------------------------------
3884                     // COMM scopes
3885                     //----------------------------------------------------------------------
3886                     case N_BCOMM:
3887                         // begin common: name,,NO_SECT,0,0
3888                         // We use the current number of symbols in the symbol table in lieu of
3889                         // using nlist_idx in case we ever start trimming entries out
3890                         type = eSymbolTypeScopeBegin;
3891                         N_COMM_indexes.push_back(sym_idx);
3892                         break;
3893 
3894                     case N_ECOML:
3895                         // end common (local name): 0,,n_sect,0,address
3896                         symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3897                         // Fall through
3898 
3899                     case N_ECOMM:
3900                         // end common: name,,n_sect,0,0
3901                         // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
3902                         // so that we can always skip the entire symbol if we need to navigate
3903                         // more quickly at the source level when parsing STABS
3904                         if ( !N_COMM_indexes.empty() )
3905                         {
3906                             symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
3907                             symbol_ptr->SetByteSize(sym_idx + 1);
3908                             symbol_ptr->SetSizeIsSibling(true);
3909                             N_COMM_indexes.pop_back();
3910                         }
3911                         type = eSymbolTypeScopeEnd;
3912                         break;
3913 
3914                     case N_LENG:
3915                         // second stab entry with length information
3916                         type = eSymbolTypeAdditional;
3917                         break;
3918 
3919                     default: break;
3920                     }
3921                 }
3922                 else
3923                 {
3924                     //uint8_t n_pext    = N_PEXT & nlist.n_type;
3925                     uint8_t n_type  = N_TYPE & nlist.n_type;
3926                     sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
3927 
3928                     switch (n_type)
3929                     {
3930                     case N_INDR:// Fall through
3931                     case N_PBUD:// Fall through
3932                     case N_UNDF:
3933                         type = eSymbolTypeUndefined;
3934                         break;
3935 
3936                     case N_ABS:
3937                         type = eSymbolTypeAbsolute;
3938                         break;
3939 
3940                     case N_SECT:
3941                         {
3942                             symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
3943 
3944                             if (!symbol_section)
3945                             {
3946                                 // TODO: warn about this?
3947                                 add_nlist = false;
3948                                 break;
3949                             }
3950 
3951                             if (TEXT_eh_frame_sectID == nlist.n_sect)
3952                             {
3953                                 type = eSymbolTypeException;
3954                             }
3955                             else
3956                             {
3957                                 uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
3958 
3959                                 switch (section_type)
3960                                 {
3961                                 case S_CSTRING_LITERALS:           type = eSymbolTypeData;    break; // section with only literal C strings
3962                                 case S_4BYTE_LITERALS:             type = eSymbolTypeData;    break; // section with only 4 byte literals
3963                                 case S_8BYTE_LITERALS:             type = eSymbolTypeData;    break; // section with only 8 byte literals
3964                                 case S_LITERAL_POINTERS:           type = eSymbolTypeTrampoline; break; // section with only pointers to literals
3965                                 case S_NON_LAZY_SYMBOL_POINTERS:   type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
3966                                 case S_LAZY_SYMBOL_POINTERS:       type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
3967                                 case S_SYMBOL_STUBS:               type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
3968                                 case S_MOD_INIT_FUNC_POINTERS:     type = eSymbolTypeCode;    break; // section with only function pointers for initialization
3969                                 case S_MOD_TERM_FUNC_POINTERS:     type = eSymbolTypeCode;    break; // section with only function pointers for termination
3970                                 case S_INTERPOSING:                type = eSymbolTypeTrampoline;  break; // section with only pairs of function pointers for interposing
3971                                 case S_16BYTE_LITERALS:            type = eSymbolTypeData;    break; // section with only 16 byte literals
3972                                 case S_DTRACE_DOF:                 type = eSymbolTypeInstrumentation; break;
3973                                 case S_LAZY_DYLIB_SYMBOL_POINTERS: type = eSymbolTypeTrampoline; break;
3974                                 default:
3975                                     switch (symbol_section->GetType())
3976                                     {
3977                                         case lldb::eSectionTypeCode:
3978                                             type = eSymbolTypeCode;
3979                                             break;
3980                                         case eSectionTypeData:
3981                                         case eSectionTypeDataCString:            // Inlined C string data
3982                                         case eSectionTypeDataCStringPointers:    // Pointers to C string data
3983                                         case eSectionTypeDataSymbolAddress:      // Address of a symbol in the symbol table
3984                                         case eSectionTypeData4:
3985                                         case eSectionTypeData8:
3986                                         case eSectionTypeData16:
3987                                             type = eSymbolTypeData;
3988                                             break;
3989                                         default:
3990                                             break;
3991                                     }
3992                                     break;
3993                                 }
3994 
3995                                 if (type == eSymbolTypeInvalid)
3996                                 {
3997                                     const char *symbol_sect_name = symbol_section->GetName().AsCString();
3998                                     if (symbol_section->IsDescendant (text_section_sp.get()))
3999                                     {
4000                                         if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
4001                                                                     S_ATTR_SELF_MODIFYING_CODE |
4002                                                                     S_ATTR_SOME_INSTRUCTIONS))
4003                                             type = eSymbolTypeData;
4004                                         else
4005                                             type = eSymbolTypeCode;
4006                                     }
4007                                     else
4008                                     if (symbol_section->IsDescendant(data_section_sp.get()))
4009                                     {
4010                                         if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
4011                                         {
4012                                             type = eSymbolTypeRuntime;
4013 
4014                                             if (symbol_name &&
4015                                                 symbol_name[0] == '_' &&
4016                                                 symbol_name[1] == 'O' &&
4017                                                 symbol_name[2] == 'B')
4018                                             {
4019                                                 llvm::StringRef symbol_name_ref(symbol_name);
4020                                                 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
4021                                                 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
4022                                                 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
4023                                                 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
4024                                                 {
4025                                                     symbol_name_non_abi_mangled = symbol_name + 1;
4026                                                     symbol_name = symbol_name + g_objc_v2_prefix_class.size();
4027                                                     type = eSymbolTypeObjCClass;
4028                                                     demangled_is_synthesized = true;
4029                                                 }
4030                                                 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
4031                                                 {
4032                                                     symbol_name_non_abi_mangled = symbol_name + 1;
4033                                                     symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
4034                                                     type = eSymbolTypeObjCMetaClass;
4035                                                     demangled_is_synthesized = true;
4036                                                 }
4037                                                 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
4038                                                 {
4039                                                     symbol_name_non_abi_mangled = symbol_name + 1;
4040                                                     symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
4041                                                     type = eSymbolTypeObjCIVar;
4042                                                     demangled_is_synthesized = true;
4043                                                 }
4044                                             }
4045                                         }
4046                                         else
4047                                         if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
4048                                         {
4049                                             type = eSymbolTypeException;
4050                                         }
4051                                         else
4052                                         {
4053                                             type = eSymbolTypeData;
4054                                         }
4055                                     }
4056                                     else
4057                                     if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
4058                                     {
4059                                         type = eSymbolTypeTrampoline;
4060                                     }
4061                                     else
4062                                     if (symbol_section->IsDescendant(objc_section_sp.get()))
4063                                     {
4064                                         type = eSymbolTypeRuntime;
4065                                         if (symbol_name && symbol_name[0] == '.')
4066                                         {
4067                                             llvm::StringRef symbol_name_ref(symbol_name);
4068                                             static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
4069                                             if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
4070                                             {
4071                                                 symbol_name_non_abi_mangled = symbol_name;
4072                                                 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
4073                                                 type = eSymbolTypeObjCClass;
4074                                                 demangled_is_synthesized = true;
4075                                             }
4076                                         }
4077                                     }
4078                                 }
4079                             }
4080                         }
4081                         break;
4082                     }
4083                 }
4084 
4085                 if (add_nlist)
4086                 {
4087                     uint64_t symbol_value = nlist.n_value;
4088 
4089                     if (symbol_name_non_abi_mangled)
4090                     {
4091                         sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
4092                         sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
4093                     }
4094                     else
4095                     {
4096                         bool symbol_name_is_mangled = false;
4097 
4098                         if (symbol_name && symbol_name[0] == '_')
4099                         {
4100                             symbol_name_is_mangled = symbol_name[1] == '_';
4101                             symbol_name++;  // Skip the leading underscore
4102                         }
4103 
4104                         if (symbol_name)
4105                         {
4106                             ConstString const_symbol_name(symbol_name);
4107                             sym[sym_idx].GetMangled().SetValue(const_symbol_name, symbol_name_is_mangled);
4108                             if (is_gsym && is_debug)
4109                             {
4110                                 N_GSYM_name_to_sym_idx[sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled).GetCString()] = sym_idx;
4111                             }
4112                         }
4113                     }
4114                     if (symbol_section)
4115                     {
4116                         const addr_t section_file_addr = symbol_section->GetFileAddress();
4117                         if (symbol_byte_size == 0 && function_starts_count > 0)
4118                         {
4119                             addr_t symbol_lookup_file_addr = nlist.n_value;
4120                             // Do an exact address match for non-ARM addresses, else get the closest since
4121                             // the symbol might be a thumb symbol which has an address with bit zero set
4122                             FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
4123                             if (is_arm && func_start_entry)
4124                             {
4125                                 // Verify that the function start address is the symbol address (ARM)
4126                                 // or the symbol address + 1 (thumb)
4127                                 if (func_start_entry->addr != symbol_lookup_file_addr &&
4128                                     func_start_entry->addr != (symbol_lookup_file_addr + 1))
4129                                 {
4130                                     // Not the right entry, NULL it out...
4131                                     func_start_entry = NULL;
4132                                 }
4133                             }
4134                             if (func_start_entry)
4135                             {
4136                                 func_start_entry->data = true;
4137 
4138                                 addr_t symbol_file_addr = func_start_entry->addr;
4139                                 if (is_arm)
4140                                     symbol_file_addr &= 0xfffffffffffffffeull;
4141 
4142                                 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
4143                                 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
4144                                 if (next_func_start_entry)
4145                                 {
4146                                     addr_t next_symbol_file_addr = next_func_start_entry->addr;
4147                                     // Be sure the clear the Thumb address bit when we calculate the size
4148                                     // from the current and next address
4149                                     if (is_arm)
4150                                         next_symbol_file_addr &= 0xfffffffffffffffeull;
4151                                     symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
4152                                 }
4153                                 else
4154                                 {
4155                                     symbol_byte_size = section_end_file_addr - symbol_file_addr;
4156                                 }
4157                             }
4158                         }
4159                         symbol_value -= section_file_addr;
4160                     }
4161 
4162                     if (is_debug == false)
4163                     {
4164                         if (type == eSymbolTypeCode)
4165                         {
4166                             // See if we can find a N_FUN entry for any code symbols.
4167                             // If we do find a match, and the name matches, then we
4168                             // can merge the two into just the function symbol to avoid
4169                             // duplicate entries in the symbol table
4170                             std::pair<ValueToSymbolIndexMap::const_iterator, ValueToSymbolIndexMap::const_iterator> range;
4171                             range = N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
4172                             if (range.first != range.second)
4173                             {
4174                                 bool found_it = false;
4175                                 for (ValueToSymbolIndexMap::const_iterator pos = range.first; pos != range.second; ++pos)
4176                                 {
4177                                     if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) == sym[pos->second].GetMangled().GetName(Mangled::ePreferMangled))
4178                                     {
4179                                         m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4180                                         // We just need the flags from the linker symbol, so put these flags
4181                                         // into the N_FUN flags to avoid duplicate symbols in the symbol table
4182                                         sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
4183                                         sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
4184                                         if (resolver_addresses.find(nlist.n_value) != resolver_addresses.end())
4185                                             sym[pos->second].SetType (eSymbolTypeResolver);
4186                                         sym[sym_idx].Clear();
4187                                         found_it = true;
4188                                         break;
4189                                     }
4190                                 }
4191                                 if (found_it)
4192                                     continue;
4193                             }
4194                             else
4195                             {
4196                                 if (resolver_addresses.find(nlist.n_value) != resolver_addresses.end())
4197                                     type = eSymbolTypeResolver;
4198                             }
4199                         }
4200                         else if (type == eSymbolTypeData)
4201                         {
4202                             // See if we can find a N_STSYM entry for any data symbols.
4203                             // If we do find a match, and the name matches, then we
4204                             // can merge the two into just the Static symbol to avoid
4205                             // duplicate entries in the symbol table
4206                             std::pair<ValueToSymbolIndexMap::const_iterator, ValueToSymbolIndexMap::const_iterator> range;
4207                             range = N_STSYM_addr_to_sym_idx.equal_range(nlist.n_value);
4208                             if (range.first != range.second)
4209                             {
4210                                 bool found_it = false;
4211                                 for (ValueToSymbolIndexMap::const_iterator pos = range.first; pos != range.second; ++pos)
4212                                 {
4213                                     if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) == sym[pos->second].GetMangled().GetName(Mangled::ePreferMangled))
4214                                     {
4215                                         m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4216                                         // We just need the flags from the linker symbol, so put these flags
4217                                         // into the N_STSYM flags to avoid duplicate symbols in the symbol table
4218                                         sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
4219                                         sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
4220                                         sym[sym_idx].Clear();
4221                                         found_it = true;
4222                                         break;
4223                                     }
4224                                 }
4225                                 if (found_it)
4226                                     continue;
4227                             }
4228                             else
4229                             {
4230                                 // Combine N_GSYM stab entries with the non stab symbol
4231                                 ConstNameToSymbolIndexMap::const_iterator pos = N_GSYM_name_to_sym_idx.find(sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled).GetCString());
4232                                 if (pos != N_GSYM_name_to_sym_idx.end())
4233                                 {
4234                                     const uint32_t GSYM_sym_idx = pos->second;
4235                                     m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
4236                                     // Copy the address, because often the N_GSYM address has an invalid address of zero
4237                                     // when the global is a common symbol
4238                                     sym[GSYM_sym_idx].GetAddress().SetSection (symbol_section);
4239                                     sym[GSYM_sym_idx].GetAddress().SetOffset (symbol_value);
4240                                     // We just need the flags from the linker symbol, so put these flags
4241                                     // into the N_STSYM flags to avoid duplicate symbols in the symbol table
4242                                     sym[GSYM_sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
4243                                     sym[sym_idx].Clear();
4244                                     continue;
4245                                 }
4246                             }
4247                         }
4248                     }
4249 
4250                     sym[sym_idx].SetID (nlist_idx);
4251                     sym[sym_idx].SetType (type);
4252                     sym[sym_idx].GetAddress().SetSection (symbol_section);
4253                     sym[sym_idx].GetAddress().SetOffset (symbol_value);
4254                     sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
4255 
4256                     if (symbol_byte_size > 0)
4257                         sym[sym_idx].SetByteSize(symbol_byte_size);
4258 
4259                     if (demangled_is_synthesized)
4260                         sym[sym_idx].SetDemangledNameIsSynthesized(true);
4261 
4262                     ++sym_idx;
4263                 }
4264                 else
4265                 {
4266                     sym[sym_idx].Clear();
4267                 }
4268             }
4269         }
4270 
4271         uint32_t synthetic_sym_id = symtab_load_command.nsyms;
4272 
4273         if (function_starts_count > 0)
4274         {
4275             char synthetic_function_symbol[PATH_MAX];
4276             uint32_t num_synthetic_function_symbols = 0;
4277             for (i=0; i<function_starts_count; ++i)
4278             {
4279                 if (function_starts.GetEntryRef (i).data == false)
4280                     ++num_synthetic_function_symbols;
4281             }
4282 
4283             if (num_synthetic_function_symbols > 0)
4284             {
4285                 if (num_syms < sym_idx + num_synthetic_function_symbols)
4286                 {
4287                     num_syms = sym_idx + num_synthetic_function_symbols;
4288                     sym = symtab->Resize (num_syms);
4289                 }
4290                 uint32_t synthetic_function_symbol_idx = 0;
4291                 for (i=0; i<function_starts_count; ++i)
4292                 {
4293                     const FunctionStarts::Entry *func_start_entry = function_starts.GetEntryAtIndex (i);
4294                     if (func_start_entry->data == false)
4295                     {
4296                         addr_t symbol_file_addr = func_start_entry->addr;
4297                         uint32_t symbol_flags = 0;
4298                         if (is_arm)
4299                         {
4300                             if (symbol_file_addr & 1)
4301                                 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
4302                             symbol_file_addr &= 0xfffffffffffffffeull;
4303                         }
4304                         Address symbol_addr;
4305                         if (module_sp->ResolveFileAddress (symbol_file_addr, symbol_addr))
4306                         {
4307                             SectionSP symbol_section (symbol_addr.GetSection());
4308                             uint32_t symbol_byte_size = 0;
4309                             if (symbol_section)
4310                             {
4311                                 const addr_t section_file_addr = symbol_section->GetFileAddress();
4312                                 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
4313                                 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
4314                                 if (next_func_start_entry)
4315                                 {
4316                                     addr_t next_symbol_file_addr = next_func_start_entry->addr;
4317                                     if (is_arm)
4318                                         next_symbol_file_addr &= 0xfffffffffffffffeull;
4319                                     symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
4320                                 }
4321                                 else
4322                                 {
4323                                     symbol_byte_size = section_end_file_addr - symbol_file_addr;
4324                                 }
4325                                 snprintf (synthetic_function_symbol,
4326                                           sizeof(synthetic_function_symbol),
4327                                           "___lldb_unnamed_function%u$$%s",
4328                                           ++synthetic_function_symbol_idx,
4329                                           module_sp->GetFileSpec().GetFilename().GetCString());
4330                                 sym[sym_idx].SetID (synthetic_sym_id++);
4331                                 sym[sym_idx].GetMangled().SetDemangledName(ConstString(synthetic_function_symbol));
4332                                 sym[sym_idx].SetType (eSymbolTypeCode);
4333                                 sym[sym_idx].SetIsSynthetic (true);
4334                                 sym[sym_idx].GetAddress() = symbol_addr;
4335                                 if (symbol_flags)
4336                                     sym[sym_idx].SetFlags (symbol_flags);
4337                                 if (symbol_byte_size)
4338                                     sym[sym_idx].SetByteSize (symbol_byte_size);
4339                                 ++sym_idx;
4340                             }
4341                         }
4342                     }
4343                 }
4344             }
4345         }
4346 
4347         // Trim our symbols down to just what we ended up with after
4348         // removing any symbols.
4349         if (sym_idx < num_syms)
4350         {
4351             num_syms = sym_idx;
4352             sym = symtab->Resize (num_syms);
4353         }
4354 
4355         // Now synthesize indirect symbols
4356         if (m_dysymtab.nindirectsyms != 0)
4357         {
4358             if (indirect_symbol_index_data.GetByteSize())
4359             {
4360                 NListIndexToSymbolIndexMap::const_iterator end_index_pos = m_nlist_idx_to_sym_idx.end();
4361 
4362                 for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size(); ++sect_idx)
4363                 {
4364                     if ((m_mach_sections[sect_idx].flags & SECTION_TYPE) == S_SYMBOL_STUBS)
4365                     {
4366                         uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2;
4367                         if (symbol_stub_byte_size == 0)
4368                             continue;
4369 
4370                         const uint32_t num_symbol_stubs = m_mach_sections[sect_idx].size / symbol_stub_byte_size;
4371 
4372                         if (num_symbol_stubs == 0)
4373                             continue;
4374 
4375                         const uint32_t symbol_stub_index_offset = m_mach_sections[sect_idx].reserved1;
4376                         for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx)
4377                         {
4378                             const uint32_t symbol_stub_index = symbol_stub_index_offset + stub_idx;
4379                             const lldb::addr_t symbol_stub_addr = m_mach_sections[sect_idx].addr + (stub_idx * symbol_stub_byte_size);
4380                             lldb::offset_t symbol_stub_offset = symbol_stub_index * 4;
4381                             if (indirect_symbol_index_data.ValidOffsetForDataOfSize(symbol_stub_offset, 4))
4382                             {
4383                                 const uint32_t stub_sym_id = indirect_symbol_index_data.GetU32 (&symbol_stub_offset);
4384                                 if (stub_sym_id & (INDIRECT_SYMBOL_ABS | INDIRECT_SYMBOL_LOCAL))
4385                                     continue;
4386 
4387                                 NListIndexToSymbolIndexMap::const_iterator index_pos = m_nlist_idx_to_sym_idx.find (stub_sym_id);
4388                                 Symbol *stub_symbol = NULL;
4389                                 if (index_pos != end_index_pos)
4390                                 {
4391                                     // We have a remapping from the original nlist index to
4392                                     // a current symbol index, so just look this up by index
4393                                     stub_symbol = symtab->SymbolAtIndex (index_pos->second);
4394                                 }
4395                                 else
4396                                 {
4397                                     // We need to lookup a symbol using the original nlist
4398                                     // symbol index since this index is coming from the
4399                                     // S_SYMBOL_STUBS
4400                                     stub_symbol = symtab->FindSymbolByID (stub_sym_id);
4401                                 }
4402 
4403                                 if (stub_symbol)
4404                                 {
4405                                     Address so_addr(symbol_stub_addr, section_list);
4406 
4407                                     if (stub_symbol->GetType() == eSymbolTypeUndefined)
4408                                     {
4409                                         // Change the external symbol into a trampoline that makes sense
4410                                         // These symbols were N_UNDF N_EXT, and are useless to us, so we
4411                                         // can re-use them so we don't have to make up a synthetic symbol
4412                                         // for no good reason.
4413                                         if (resolver_addresses.find(symbol_stub_addr) == resolver_addresses.end())
4414                                             stub_symbol->SetType (eSymbolTypeTrampoline);
4415                                         else
4416                                             stub_symbol->SetType (eSymbolTypeResolver);
4417                                         stub_symbol->SetExternal (false);
4418                                         stub_symbol->GetAddress() = so_addr;
4419                                         stub_symbol->SetByteSize (symbol_stub_byte_size);
4420                                     }
4421                                     else
4422                                     {
4423                                         // Make a synthetic symbol to describe the trampoline stub
4424                                         Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
4425                                         if (sym_idx >= num_syms)
4426                                         {
4427                                             sym = symtab->Resize (++num_syms);
4428                                             stub_symbol = NULL;  // this pointer no longer valid
4429                                         }
4430                                         sym[sym_idx].SetID (synthetic_sym_id++);
4431                                         sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
4432                                         if (resolver_addresses.find(symbol_stub_addr) == resolver_addresses.end())
4433                                             sym[sym_idx].SetType (eSymbolTypeTrampoline);
4434                                         else
4435                                             sym[sym_idx].SetType (eSymbolTypeResolver);
4436                                         sym[sym_idx].SetIsSynthetic (true);
4437                                         sym[sym_idx].GetAddress() = so_addr;
4438                                         sym[sym_idx].SetByteSize (symbol_stub_byte_size);
4439                                         ++sym_idx;
4440                                     }
4441                                 }
4442                                 else
4443                                 {
4444                                     if (log)
4445                                         log->Warning ("symbol stub referencing symbol table symbol %u that isn't in our minimal symbol table, fix this!!!", stub_sym_id);
4446                                 }
4447                             }
4448                         }
4449                     }
4450                 }
4451             }
4452         }
4453 
4454 
4455         if (!trie_entries.empty())
4456         {
4457             for (const auto &e : trie_entries)
4458             {
4459                 if (e.entry.import_name)
4460                 {
4461                     // Make a synthetic symbol to describe re-exported symbol.
4462                     if (sym_idx >= num_syms)
4463                         sym = symtab->Resize (++num_syms);
4464                     sym[sym_idx].SetID (synthetic_sym_id++);
4465                     sym[sym_idx].GetMangled() = Mangled(e.entry.name);
4466                     sym[sym_idx].SetType (eSymbolTypeReExported);
4467                     sym[sym_idx].SetIsSynthetic (true);
4468                     sym[sym_idx].SetReExportedSymbolName(e.entry.import_name);
4469                     if (e.entry.other > 0 && e.entry.other <= dylib_files.GetSize())
4470                     {
4471                         sym[sym_idx].SetReExportedSymbolSharedLibrary(dylib_files.GetFileSpecAtIndex(e.entry.other-1));
4472                     }
4473                     ++sym_idx;
4474                 }
4475             }
4476         }
4477 
4478 
4479 
4480 //        StreamFile s(stdout, false);
4481 //        s.Printf ("Symbol table before CalculateSymbolSizes():\n");
4482 //        symtab->Dump(&s, NULL, eSortOrderNone);
4483         // Set symbol byte sizes correctly since mach-o nlist entries don't have sizes
4484         symtab->CalculateSymbolSizes();
4485 
4486 //        s.Printf ("Symbol table after CalculateSymbolSizes():\n");
4487 //        symtab->Dump(&s, NULL, eSortOrderNone);
4488 
4489         return symtab->GetNumSymbols();
4490     }
4491     return 0;
4492 }
4493 
4494 
4495 void
4496 ObjectFileMachO::Dump (Stream *s)
4497 {
4498     ModuleSP module_sp(GetModule());
4499     if (module_sp)
4500     {
4501         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4502         s->Printf("%p: ", static_cast<void*>(this));
4503         s->Indent();
4504         if (m_header.magic == MH_MAGIC_64 || m_header.magic == MH_CIGAM_64)
4505             s->PutCString("ObjectFileMachO64");
4506         else
4507             s->PutCString("ObjectFileMachO32");
4508 
4509         ArchSpec header_arch;
4510         GetArchitecture(header_arch);
4511 
4512         *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n";
4513 
4514         SectionList *sections = GetSectionList();
4515         if (sections)
4516             sections->Dump(s, NULL, true, UINT32_MAX);
4517 
4518         if (m_symtab_ap.get())
4519             m_symtab_ap->Dump(s, NULL, eSortOrderNone);
4520     }
4521 }
4522 
4523 bool
4524 ObjectFileMachO::GetUUID (const llvm::MachO::mach_header &header,
4525                           const lldb_private::DataExtractor &data,
4526                           lldb::offset_t lc_offset,
4527                           lldb_private::UUID& uuid)
4528 {
4529     uint32_t i;
4530     struct uuid_command load_cmd;
4531 
4532     lldb::offset_t offset = lc_offset;
4533     for (i=0; i<header.ncmds; ++i)
4534     {
4535         const lldb::offset_t cmd_offset = offset;
4536         if (data.GetU32(&offset, &load_cmd, 2) == NULL)
4537             break;
4538 
4539         if (load_cmd.cmd == LC_UUID)
4540         {
4541             const uint8_t *uuid_bytes = data.PeekData(offset, 16);
4542 
4543             if (uuid_bytes)
4544             {
4545                 // OpenCL on Mac OS X uses the same UUID for each of its object files.
4546                 // We pretend these object files have no UUID to prevent crashing.
4547 
4548                 const uint8_t opencl_uuid[] = { 0x8c, 0x8e, 0xb3, 0x9b,
4549                     0x3b, 0xa8,
4550                     0x4b, 0x16,
4551                     0xb6, 0xa4,
4552                     0x27, 0x63, 0xbb, 0x14, 0xf0, 0x0d };
4553 
4554                 if (!memcmp(uuid_bytes, opencl_uuid, 16))
4555                     return false;
4556 
4557                 uuid.SetBytes (uuid_bytes);
4558                 return true;
4559             }
4560             return false;
4561         }
4562         offset = cmd_offset + load_cmd.cmdsize;
4563     }
4564     return false;
4565 }
4566 
4567 
4568 bool
4569 ObjectFileMachO::GetArchitecture (const llvm::MachO::mach_header &header,
4570                                   const lldb_private::DataExtractor &data,
4571                                   lldb::offset_t lc_offset,
4572                                   ArchSpec &arch)
4573 {
4574     arch.SetArchitecture (eArchTypeMachO, header.cputype, header.cpusubtype);
4575 
4576     if (arch.IsValid())
4577     {
4578         llvm::Triple &triple = arch.GetTriple();
4579         if (header.filetype == MH_PRELOAD)
4580         {
4581             // Set OS to "unknown" - this is a standalone binary with no dyld et al
4582             triple.setOS(llvm::Triple::UnknownOS);
4583             return true;
4584         }
4585         else
4586         {
4587             struct load_command load_cmd;
4588 
4589             lldb::offset_t offset = lc_offset;
4590             for (uint32_t i=0; i<header.ncmds; ++i)
4591             {
4592                 const lldb::offset_t cmd_offset = offset;
4593                 if (data.GetU32(&offset, &load_cmd, 2) == NULL)
4594                     break;
4595 
4596                 switch (load_cmd.cmd)
4597                 {
4598                     case LC_VERSION_MIN_IPHONEOS:
4599                         triple.setOS (llvm::Triple::IOS);
4600                         return true;
4601 
4602                     case LC_VERSION_MIN_MACOSX:
4603                         triple.setOS (llvm::Triple::MacOSX);
4604                         return true;
4605 
4606                     default:
4607                         break;
4608                 }
4609 
4610                 offset = cmd_offset + load_cmd.cmdsize;
4611             }
4612 
4613             // Only set the OS to iOS for ARM, we don't want to set it for x86 and x86_64.
4614             // We do this because we now have MacOSX or iOS as the OS value for x86 and
4615             // x86_64 for normal desktop (MacOSX) and simulator (iOS) binaries. And if
4616             // we compare a "x86_64-apple-ios" to a "x86_64-apple-" triple, it will say
4617             // it is compatible (because the OS is unspecified in the second one and will
4618             // match anything in the first
4619             if (header.cputype == CPU_TYPE_ARM || header.cputype == CPU_TYPE_ARM64)
4620                 triple.setOS (llvm::Triple::IOS);
4621         }
4622     }
4623     return arch.IsValid();
4624 }
4625 
4626 bool
4627 ObjectFileMachO::GetUUID (lldb_private::UUID* uuid)
4628 {
4629     ModuleSP module_sp(GetModule());
4630     if (module_sp)
4631     {
4632         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4633         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
4634         return GetUUID (m_header, m_data, offset, *uuid);
4635     }
4636     return false;
4637 }
4638 
4639 
4640 uint32_t
4641 ObjectFileMachO::GetDependentModules (FileSpecList& files)
4642 {
4643     uint32_t count = 0;
4644     ModuleSP module_sp(GetModule());
4645     if (module_sp)
4646     {
4647         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4648         struct load_command load_cmd;
4649         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
4650         const bool resolve_path = false; // Don't resolve the dependent file paths since they may not reside on this system
4651         uint32_t i;
4652         for (i=0; i<m_header.ncmds; ++i)
4653         {
4654             const uint32_t cmd_offset = offset;
4655             if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
4656                 break;
4657 
4658             switch (load_cmd.cmd)
4659             {
4660             case LC_LOAD_DYLIB:
4661             case LC_LOAD_WEAK_DYLIB:
4662             case LC_REEXPORT_DYLIB:
4663             case LC_LOAD_DYLINKER:
4664             case LC_LOADFVMLIB:
4665             case LC_LOAD_UPWARD_DYLIB:
4666                 {
4667                     uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
4668                     const char *path = m_data.PeekCStr(name_offset);
4669                     // Skip any path that starts with '@' since these are usually:
4670                     // @executable_path/.../file
4671                     // @rpath/.../file
4672                     if (path && path[0] != '@')
4673                     {
4674                         FileSpec file_spec(path, resolve_path);
4675                         if (files.AppendIfUnique(file_spec))
4676                             count++;
4677                     }
4678                 }
4679                 break;
4680 
4681             default:
4682                 break;
4683             }
4684             offset = cmd_offset + load_cmd.cmdsize;
4685         }
4686     }
4687     return count;
4688 }
4689 
4690 lldb_private::Address
4691 ObjectFileMachO::GetEntryPointAddress ()
4692 {
4693     // If the object file is not an executable it can't hold the entry point.  m_entry_point_address
4694     // is initialized to an invalid address, so we can just return that.
4695     // If m_entry_point_address is valid it means we've found it already, so return the cached value.
4696 
4697     if (!IsExecutable() || m_entry_point_address.IsValid())
4698         return m_entry_point_address;
4699 
4700     // Otherwise, look for the UnixThread or Thread command.  The data for the Thread command is given in
4701     // /usr/include/mach-o.h, but it is basically:
4702     //
4703     //  uint32_t flavor  - this is the flavor argument you would pass to thread_get_state
4704     //  uint32_t count   - this is the count of longs in the thread state data
4705     //  struct XXX_thread_state state - this is the structure from <machine/thread_status.h> corresponding to the flavor.
4706     //  <repeat this trio>
4707     //
4708     // So we just keep reading the various register flavors till we find the GPR one, then read the PC out of there.
4709     // FIXME: We will need to have a "RegisterContext data provider" class at some point that can get all the registers
4710     // out of data in this form & attach them to a given thread.  That should underlie the MacOS X User process plugin,
4711     // and we'll also need it for the MacOS X Core File process plugin.  When we have that we can also use it here.
4712     //
4713     // For now we hard-code the offsets and flavors we need:
4714     //
4715     //
4716 
4717     ModuleSP module_sp(GetModule());
4718     if (module_sp)
4719     {
4720         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4721         struct load_command load_cmd;
4722         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
4723         uint32_t i;
4724         lldb::addr_t start_address = LLDB_INVALID_ADDRESS;
4725         bool done = false;
4726 
4727         for (i=0; i<m_header.ncmds; ++i)
4728         {
4729             const lldb::offset_t cmd_offset = offset;
4730             if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
4731                 break;
4732 
4733             switch (load_cmd.cmd)
4734             {
4735             case LC_UNIXTHREAD:
4736             case LC_THREAD:
4737                 {
4738                     while (offset < cmd_offset + load_cmd.cmdsize)
4739                     {
4740                         uint32_t flavor = m_data.GetU32(&offset);
4741                         uint32_t count = m_data.GetU32(&offset);
4742                         if (count == 0)
4743                         {
4744                             // We've gotten off somehow, log and exit;
4745                             return m_entry_point_address;
4746                         }
4747 
4748                         switch (m_header.cputype)
4749                         {
4750                         case llvm::MachO::CPU_TYPE_ARM:
4751                            if (flavor == 1) // ARM_THREAD_STATE from mach/arm/thread_status.h
4752                            {
4753                                offset += 60;  // This is the offset of pc in the GPR thread state data structure.
4754                                start_address = m_data.GetU32(&offset);
4755                                done = true;
4756                             }
4757                         break;
4758                         case llvm::MachO::CPU_TYPE_ARM64:
4759                            if (flavor == 6) // ARM_THREAD_STATE64 from mach/arm/thread_status.h
4760                            {
4761                                offset += 256;  // This is the offset of pc in the GPR thread state data structure.
4762                                start_address = m_data.GetU64(&offset);
4763                                done = true;
4764                             }
4765                         break;
4766                         case llvm::MachO::CPU_TYPE_I386:
4767                            if (flavor == 1) // x86_THREAD_STATE32 from mach/i386/thread_status.h
4768                            {
4769                                offset += 40;  // This is the offset of eip in the GPR thread state data structure.
4770                                start_address = m_data.GetU32(&offset);
4771                                done = true;
4772                             }
4773                         break;
4774                         case llvm::MachO::CPU_TYPE_X86_64:
4775                            if (flavor == 4) // x86_THREAD_STATE64 from mach/i386/thread_status.h
4776                            {
4777                                offset += 16 * 8;  // This is the offset of rip in the GPR thread state data structure.
4778                                start_address = m_data.GetU64(&offset);
4779                                done = true;
4780                             }
4781                         break;
4782                         default:
4783                             return m_entry_point_address;
4784                         }
4785                         // Haven't found the GPR flavor yet, skip over the data for this flavor:
4786                         if (done)
4787                             break;
4788                         offset += count * 4;
4789                     }
4790                 }
4791                 break;
4792             case LC_MAIN:
4793                 {
4794                     ConstString text_segment_name ("__TEXT");
4795                     uint64_t entryoffset = m_data.GetU64(&offset);
4796                     SectionSP text_segment_sp = GetSectionList()->FindSectionByName(text_segment_name);
4797                     if (text_segment_sp)
4798                     {
4799                         done = true;
4800                         start_address = text_segment_sp->GetFileAddress() + entryoffset;
4801                     }
4802                 }
4803 
4804             default:
4805                 break;
4806             }
4807             if (done)
4808                 break;
4809 
4810             // Go to the next load command:
4811             offset = cmd_offset + load_cmd.cmdsize;
4812         }
4813 
4814         if (start_address != LLDB_INVALID_ADDRESS)
4815         {
4816             // We got the start address from the load commands, so now resolve that address in the sections
4817             // of this ObjectFile:
4818             if (!m_entry_point_address.ResolveAddressUsingFileSections (start_address, GetSectionList()))
4819             {
4820                 m_entry_point_address.Clear();
4821             }
4822         }
4823         else
4824         {
4825             // We couldn't read the UnixThread load command - maybe it wasn't there.  As a fallback look for the
4826             // "start" symbol in the main executable.
4827 
4828             ModuleSP module_sp (GetModule());
4829 
4830             if (module_sp)
4831             {
4832                 SymbolContextList contexts;
4833                 SymbolContext context;
4834                 if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), eSymbolTypeCode, contexts))
4835                 {
4836                     if (contexts.GetContextAtIndex(0, context))
4837                         m_entry_point_address = context.symbol->GetAddress();
4838                 }
4839             }
4840         }
4841     }
4842 
4843     return m_entry_point_address;
4844 
4845 }
4846 
4847 lldb_private::Address
4848 ObjectFileMachO::GetHeaderAddress ()
4849 {
4850     lldb_private::Address header_addr;
4851     SectionList *section_list = GetSectionList();
4852     if (section_list)
4853     {
4854         SectionSP text_segment_sp (section_list->FindSectionByName (GetSegmentNameTEXT()));
4855         if (text_segment_sp)
4856         {
4857             header_addr.SetSection (text_segment_sp);
4858             header_addr.SetOffset (0);
4859         }
4860     }
4861     return header_addr;
4862 }
4863 
4864 uint32_t
4865 ObjectFileMachO::GetNumThreadContexts ()
4866 {
4867     ModuleSP module_sp(GetModule());
4868     if (module_sp)
4869     {
4870         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4871         if (!m_thread_context_offsets_valid)
4872         {
4873             m_thread_context_offsets_valid = true;
4874             lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
4875             FileRangeArray::Entry file_range;
4876             thread_command thread_cmd;
4877             for (uint32_t i=0; i<m_header.ncmds; ++i)
4878             {
4879                 const uint32_t cmd_offset = offset;
4880                 if (m_data.GetU32(&offset, &thread_cmd, 2) == NULL)
4881                     break;
4882 
4883                 if (thread_cmd.cmd == LC_THREAD)
4884                 {
4885                     file_range.SetRangeBase (offset);
4886                     file_range.SetByteSize (thread_cmd.cmdsize - 8);
4887                     m_thread_context_offsets.Append (file_range);
4888                 }
4889                 offset = cmd_offset + thread_cmd.cmdsize;
4890             }
4891         }
4892     }
4893     return m_thread_context_offsets.GetSize();
4894 }
4895 
4896 lldb::RegisterContextSP
4897 ObjectFileMachO::GetThreadContextAtIndex (uint32_t idx, lldb_private::Thread &thread)
4898 {
4899     lldb::RegisterContextSP reg_ctx_sp;
4900 
4901     ModuleSP module_sp(GetModule());
4902     if (module_sp)
4903     {
4904         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
4905         if (!m_thread_context_offsets_valid)
4906             GetNumThreadContexts ();
4907 
4908         const FileRangeArray::Entry *thread_context_file_range = m_thread_context_offsets.GetEntryAtIndex (idx);
4909         if (thread_context_file_range)
4910         {
4911 
4912             DataExtractor data (m_data,
4913                                 thread_context_file_range->GetRangeBase(),
4914                                 thread_context_file_range->GetByteSize());
4915 
4916             switch (m_header.cputype)
4917             {
4918                 case llvm::MachO::CPU_TYPE_ARM64:
4919                     reg_ctx_sp.reset (new RegisterContextDarwin_arm64_Mach (thread, data));
4920                     break;
4921 
4922                 case llvm::MachO::CPU_TYPE_ARM:
4923                     reg_ctx_sp.reset (new RegisterContextDarwin_arm_Mach (thread, data));
4924                     break;
4925 
4926                 case llvm::MachO::CPU_TYPE_I386:
4927                     reg_ctx_sp.reset (new RegisterContextDarwin_i386_Mach (thread, data));
4928                     break;
4929 
4930                 case llvm::MachO::CPU_TYPE_X86_64:
4931                     reg_ctx_sp.reset (new RegisterContextDarwin_x86_64_Mach (thread, data));
4932                     break;
4933             }
4934         }
4935     }
4936     return reg_ctx_sp;
4937 }
4938 
4939 
4940 ObjectFile::Type
4941 ObjectFileMachO::CalculateType()
4942 {
4943     switch (m_header.filetype)
4944     {
4945         case MH_OBJECT:                                         // 0x1u
4946             if (GetAddressByteSize () == 4)
4947             {
4948                 // 32 bit kexts are just object files, but they do have a valid
4949                 // UUID load command.
4950                 UUID uuid;
4951                 if (GetUUID(&uuid))
4952                 {
4953                     // this checking for the UUID load command is not enough
4954                     // we could eventually look for the symbol named
4955                     // "OSKextGetCurrentIdentifier" as this is required of kexts
4956                     if (m_strata == eStrataInvalid)
4957                         m_strata = eStrataKernel;
4958                     return eTypeSharedLibrary;
4959                 }
4960             }
4961             return eTypeObjectFile;
4962 
4963         case MH_EXECUTE:            return eTypeExecutable;     // 0x2u
4964         case MH_FVMLIB:             return eTypeSharedLibrary;  // 0x3u
4965         case MH_CORE:               return eTypeCoreFile;       // 0x4u
4966         case MH_PRELOAD:            return eTypeSharedLibrary;  // 0x5u
4967         case MH_DYLIB:              return eTypeSharedLibrary;  // 0x6u
4968         case MH_DYLINKER:           return eTypeDynamicLinker;  // 0x7u
4969         case MH_BUNDLE:             return eTypeSharedLibrary;  // 0x8u
4970         case MH_DYLIB_STUB:         return eTypeStubLibrary;    // 0x9u
4971         case MH_DSYM:               return eTypeDebugInfo;      // 0xAu
4972         case MH_KEXT_BUNDLE:        return eTypeSharedLibrary;  // 0xBu
4973         default:
4974             break;
4975     }
4976     return eTypeUnknown;
4977 }
4978 
4979 ObjectFile::Strata
4980 ObjectFileMachO::CalculateStrata()
4981 {
4982     switch (m_header.filetype)
4983     {
4984         case MH_OBJECT:                                  // 0x1u
4985             {
4986                 // 32 bit kexts are just object files, but they do have a valid
4987                 // UUID load command.
4988                 UUID uuid;
4989                 if (GetUUID(&uuid))
4990                 {
4991                     // this checking for the UUID load command is not enough
4992                     // we could eventually look for the symbol named
4993                     // "OSKextGetCurrentIdentifier" as this is required of kexts
4994                     if (m_type == eTypeInvalid)
4995                         m_type = eTypeSharedLibrary;
4996 
4997                     return eStrataKernel;
4998                 }
4999             }
5000             return eStrataUnknown;
5001 
5002         case MH_EXECUTE:                                 // 0x2u
5003             // Check for the MH_DYLDLINK bit in the flags
5004             if (m_header.flags & MH_DYLDLINK)
5005             {
5006                 return eStrataUser;
5007             }
5008             else
5009             {
5010                 SectionList *section_list = GetSectionList();
5011                 if (section_list)
5012                 {
5013                     static ConstString g_kld_section_name ("__KLD");
5014                     if (section_list->FindSectionByName(g_kld_section_name))
5015                         return eStrataKernel;
5016                 }
5017             }
5018             return eStrataRawImage;
5019 
5020         case MH_FVMLIB:      return eStrataUser;         // 0x3u
5021         case MH_CORE:        return eStrataUnknown;      // 0x4u
5022         case MH_PRELOAD:     return eStrataRawImage;     // 0x5u
5023         case MH_DYLIB:       return eStrataUser;         // 0x6u
5024         case MH_DYLINKER:    return eStrataUser;         // 0x7u
5025         case MH_BUNDLE:      return eStrataUser;         // 0x8u
5026         case MH_DYLIB_STUB:  return eStrataUser;         // 0x9u
5027         case MH_DSYM:        return eStrataUnknown;      // 0xAu
5028         case MH_KEXT_BUNDLE: return eStrataKernel;       // 0xBu
5029         default:
5030             break;
5031     }
5032     return eStrataUnknown;
5033 }
5034 
5035 
5036 uint32_t
5037 ObjectFileMachO::GetVersion (uint32_t *versions, uint32_t num_versions)
5038 {
5039     ModuleSP module_sp(GetModule());
5040     if (module_sp)
5041     {
5042         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
5043         struct dylib_command load_cmd;
5044         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
5045         uint32_t version_cmd = 0;
5046         uint64_t version = 0;
5047         uint32_t i;
5048         for (i=0; i<m_header.ncmds; ++i)
5049         {
5050             const lldb::offset_t cmd_offset = offset;
5051             if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
5052                 break;
5053 
5054             if (load_cmd.cmd == LC_ID_DYLIB)
5055             {
5056                 if (version_cmd == 0)
5057                 {
5058                     version_cmd = load_cmd.cmd;
5059                     if (m_data.GetU32(&offset, &load_cmd.dylib, 4) == NULL)
5060                         break;
5061                     version = load_cmd.dylib.current_version;
5062                 }
5063                 break; // Break for now unless there is another more complete version
5064                        // number load command in the future.
5065             }
5066             offset = cmd_offset + load_cmd.cmdsize;
5067         }
5068 
5069         if (version_cmd == LC_ID_DYLIB)
5070         {
5071             if (versions != NULL && num_versions > 0)
5072             {
5073                 if (num_versions > 0)
5074                     versions[0] = (version & 0xFFFF0000ull) >> 16;
5075                 if (num_versions > 1)
5076                     versions[1] = (version & 0x0000FF00ull) >> 8;
5077                 if (num_versions > 2)
5078                     versions[2] = (version & 0x000000FFull);
5079                 // Fill in an remaining version numbers with invalid values
5080                 for (i=3; i<num_versions; ++i)
5081                     versions[i] = UINT32_MAX;
5082             }
5083             // The LC_ID_DYLIB load command has a version with 3 version numbers
5084             // in it, so always return 3
5085             return 3;
5086         }
5087     }
5088     return false;
5089 }
5090 
5091 bool
5092 ObjectFileMachO::GetArchitecture (ArchSpec &arch)
5093 {
5094     ModuleSP module_sp(GetModule());
5095     if (module_sp)
5096     {
5097         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
5098         return GetArchitecture (m_header, m_data, MachHeaderSizeFromMagic(m_header.magic), arch);
5099     }
5100     return false;
5101 }
5102 
5103 
5104 UUID
5105 ObjectFileMachO::GetProcessSharedCacheUUID (Process *process)
5106 {
5107     UUID uuid;
5108     if (process)
5109     {
5110         addr_t all_image_infos = process->GetImageInfoAddress();
5111 
5112         // The address returned by GetImageInfoAddress may be the address of dyld (don't want)
5113         // or it may be the address of the dyld_all_image_infos structure (want).  The first four
5114         // bytes will be either the version field (all_image_infos) or a Mach-O file magic constant.
5115         // Version 13 and higher of dyld_all_image_infos is required to get the sharedCacheUUID field.
5116 
5117         Error err;
5118         uint32_t version_or_magic = process->ReadUnsignedIntegerFromMemory (all_image_infos, 4, -1, err);
5119         if (version_or_magic != static_cast<uint32_t>(-1)
5120             && version_or_magic != MH_MAGIC
5121             && version_or_magic != MH_CIGAM
5122             && version_or_magic != MH_MAGIC_64
5123             && version_or_magic != MH_CIGAM_64
5124             && version_or_magic >= 13)
5125         {
5126             addr_t sharedCacheUUID_address = LLDB_INVALID_ADDRESS;
5127             int wordsize = process->GetAddressByteSize();
5128             if (wordsize == 8)
5129             {
5130                 sharedCacheUUID_address = all_image_infos + 160;  // sharedCacheUUID <mach-o/dyld_images.h>
5131             }
5132             if (wordsize == 4)
5133             {
5134                 sharedCacheUUID_address = all_image_infos + 84;   // sharedCacheUUID <mach-o/dyld_images.h>
5135             }
5136             if (sharedCacheUUID_address != LLDB_INVALID_ADDRESS)
5137             {
5138                 uuid_t shared_cache_uuid;
5139                 if (process->ReadMemory (sharedCacheUUID_address, shared_cache_uuid, sizeof (uuid_t), err) == sizeof (uuid_t))
5140                 {
5141                     uuid.SetBytes (shared_cache_uuid);
5142                 }
5143             }
5144         }
5145     }
5146     return uuid;
5147 }
5148 
5149 UUID
5150 ObjectFileMachO::GetLLDBSharedCacheUUID ()
5151 {
5152     UUID uuid;
5153 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
5154     uint8_t *(*dyld_get_all_image_infos)(void);
5155     dyld_get_all_image_infos = (uint8_t*(*)()) dlsym (RTLD_DEFAULT, "_dyld_get_all_image_infos");
5156     if (dyld_get_all_image_infos)
5157     {
5158         uint8_t *dyld_all_image_infos_address = dyld_get_all_image_infos();
5159         if (dyld_all_image_infos_address)
5160         {
5161             uint32_t *version = (uint32_t*) dyld_all_image_infos_address;              // version <mach-o/dyld_images.h>
5162             if (*version >= 13)
5163             {
5164                 uuid_t *sharedCacheUUID_address = 0;
5165                 int wordsize = sizeof (uint8_t *);
5166                 if (wordsize == 8)
5167                 {
5168                     sharedCacheUUID_address = (uuid_t*) ((uint8_t*) dyld_all_image_infos_address + 160); // sharedCacheUUID <mach-o/dyld_images.h>
5169                 }
5170                 else
5171                 {
5172                     sharedCacheUUID_address = (uuid_t*) ((uint8_t*) dyld_all_image_infos_address + 84);  // sharedCacheUUID <mach-o/dyld_images.h>
5173                 }
5174                 uuid.SetBytes (sharedCacheUUID_address);
5175             }
5176         }
5177     }
5178 #endif
5179     return uuid;
5180 }
5181 
5182 uint32_t
5183 ObjectFileMachO::GetMinimumOSVersion (uint32_t *versions, uint32_t num_versions)
5184 {
5185     if (m_min_os_versions.empty())
5186     {
5187         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
5188         bool success = false;
5189         for (uint32_t i=0; success == false && i < m_header.ncmds; ++i)
5190         {
5191             const lldb::offset_t load_cmd_offset = offset;
5192 
5193             version_min_command lc;
5194             if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL)
5195                 break;
5196             if (lc.cmd == LC_VERSION_MIN_MACOSX || lc.cmd == LC_VERSION_MIN_IPHONEOS)
5197             {
5198                 if (m_data.GetU32 (&offset, &lc.version, (sizeof(lc) / sizeof(uint32_t)) - 2))
5199                 {
5200                     const uint32_t xxxx = lc.version >> 16;
5201                     const uint32_t yy = (lc.version >> 8) & 0xffu;
5202                     const uint32_t zz = lc.version  & 0xffu;
5203                     if (xxxx)
5204                     {
5205                         m_min_os_versions.push_back(xxxx);
5206                         m_min_os_versions.push_back(yy);
5207                         m_min_os_versions.push_back(zz);
5208                     }
5209                     success = true;
5210                 }
5211             }
5212             offset = load_cmd_offset + lc.cmdsize;
5213         }
5214 
5215         if (success == false)
5216         {
5217             // Push an invalid value so we don't keep trying to
5218             m_min_os_versions.push_back(UINT32_MAX);
5219         }
5220     }
5221 
5222     if (m_min_os_versions.size() > 1 || m_min_os_versions[0] != UINT32_MAX)
5223     {
5224         if (versions != NULL && num_versions > 0)
5225         {
5226             for (size_t i=0; i<num_versions; ++i)
5227             {
5228                 if (i < m_min_os_versions.size())
5229                     versions[i] = m_min_os_versions[i];
5230                 else
5231                     versions[i] = 0;
5232             }
5233         }
5234         return m_min_os_versions.size();
5235     }
5236     // Call the superclasses version that will empty out the data
5237     return ObjectFile::GetMinimumOSVersion (versions, num_versions);
5238 }
5239 
5240 uint32_t
5241 ObjectFileMachO::GetSDKVersion(uint32_t *versions, uint32_t num_versions)
5242 {
5243     if (m_sdk_versions.empty())
5244     {
5245         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
5246         bool success = false;
5247         for (uint32_t i=0; success == false && i < m_header.ncmds; ++i)
5248         {
5249             const lldb::offset_t load_cmd_offset = offset;
5250 
5251             version_min_command lc;
5252             if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL)
5253                 break;
5254             if (lc.cmd == LC_VERSION_MIN_MACOSX || lc.cmd == LC_VERSION_MIN_IPHONEOS)
5255             {
5256                 if (m_data.GetU32 (&offset, &lc.version, (sizeof(lc) / sizeof(uint32_t)) - 2))
5257                 {
5258                     const uint32_t xxxx = lc.sdk >> 16;
5259                     const uint32_t yy = (lc.sdk >> 8) & 0xffu;
5260                     const uint32_t zz = lc.sdk & 0xffu;
5261                     if (xxxx)
5262                     {
5263                         m_sdk_versions.push_back(xxxx);
5264                         m_sdk_versions.push_back(yy);
5265                         m_sdk_versions.push_back(zz);
5266                     }
5267                     success = true;
5268                 }
5269             }
5270             offset = load_cmd_offset + lc.cmdsize;
5271         }
5272 
5273         if (success == false)
5274         {
5275             // Push an invalid value so we don't keep trying to
5276             m_sdk_versions.push_back(UINT32_MAX);
5277         }
5278     }
5279 
5280     if (m_sdk_versions.size() > 1 || m_sdk_versions[0] != UINT32_MAX)
5281     {
5282         if (versions != NULL && num_versions > 0)
5283         {
5284             for (size_t i=0; i<num_versions; ++i)
5285             {
5286                 if (i < m_sdk_versions.size())
5287                     versions[i] = m_sdk_versions[i];
5288                 else
5289                     versions[i] = 0;
5290             }
5291         }
5292         return m_sdk_versions.size();
5293     }
5294     // Call the superclasses version that will empty out the data
5295     return ObjectFile::GetSDKVersion (versions, num_versions);
5296 }
5297 
5298 
5299 bool
5300 ObjectFileMachO::GetIsDynamicLinkEditor()
5301 {
5302     return m_header.filetype == llvm::MachO::MH_DYLINKER;
5303 }
5304 
5305 //------------------------------------------------------------------
5306 // PluginInterface protocol
5307 //------------------------------------------------------------------
5308 lldb_private::ConstString
5309 ObjectFileMachO::GetPluginName()
5310 {
5311     return GetPluginNameStatic();
5312 }
5313 
5314 uint32_t
5315 ObjectFileMachO::GetPluginVersion()
5316 {
5317     return 1;
5318 }
5319 
5320 
5321 bool
5322 ObjectFileMachO::SetLoadAddress (Target &target,
5323                                  lldb::addr_t value,
5324                                  bool value_is_offset)
5325 {
5326     ModuleSP module_sp = GetModule();
5327     if (module_sp)
5328     {
5329         size_t num_loaded_sections = 0;
5330         SectionList *section_list = GetSectionList ();
5331         if (section_list)
5332         {
5333             lldb::addr_t mach_base_file_addr = LLDB_INVALID_ADDRESS;
5334             const size_t num_sections = section_list->GetSize();
5335 
5336             const bool is_memory_image = (bool)m_process_wp.lock();
5337             const Strata strata = GetStrata();
5338             static ConstString g_linkedit_segname ("__LINKEDIT");
5339             if (value_is_offset)
5340             {
5341                 // "value" is an offset to apply to each top level segment
5342                 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
5343                 {
5344                     // Iterate through the object file sections to find all
5345                     // of the sections that size on disk (to avoid __PAGEZERO)
5346                     // and load them
5347                     SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
5348                     if (section_sp &&
5349                         section_sp->GetFileSize() > 0 &&
5350                         section_sp->IsThreadSpecific() == false &&
5351                         module_sp.get() == section_sp->GetModule().get())
5352                     {
5353                         // Ignore __LINKEDIT and __DWARF segments
5354                         if (section_sp->GetName() == g_linkedit_segname)
5355                         {
5356                             // Only map __LINKEDIT if we have an in memory image and this isn't
5357                             // a kernel binary like a kext or mach_kernel.
5358                             if (is_memory_image == false || strata == eStrataKernel)
5359                                 continue;
5360                         }
5361                         if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() + value))
5362                             ++num_loaded_sections;
5363                     }
5364                 }
5365             }
5366             else
5367             {
5368                 // "value" is the new base address of the mach_header, adjust each
5369                 // section accordingly
5370 
5371                 // First find the address of the mach header which is the first non-zero
5372                 // file sized section whose file offset is zero as this will be subtracted
5373                 // from each other valid section's vmaddr and then get "base_addr" added to
5374                 // it when loading the module in the target
5375                 for (size_t sect_idx = 0;
5376                      sect_idx < num_sections && mach_base_file_addr == LLDB_INVALID_ADDRESS;
5377                      ++sect_idx)
5378                 {
5379                     // Iterate through the object file sections to find all
5380                     // of the sections that size on disk (to avoid __PAGEZERO)
5381                     // and load them
5382                     Section *section = section_list->GetSectionAtIndex (sect_idx).get();
5383                     if (section &&
5384                         section->GetFileSize() > 0 &&
5385                         section->GetFileOffset() == 0 &&
5386                         section->IsThreadSpecific() == false &&
5387                         module_sp.get() == section->GetModule().get())
5388                     {
5389                         // Ignore __LINKEDIT and __DWARF segments
5390                         if (section->GetName() == g_linkedit_segname)
5391                         {
5392                             // Only map __LINKEDIT if we have an in memory image and this isn't
5393                             // a kernel binary like a kext or mach_kernel.
5394                             if (is_memory_image == false || strata == eStrataKernel)
5395                                 continue;
5396                         }
5397                         mach_base_file_addr = section->GetFileAddress();
5398                     }
5399                 }
5400 
5401                 if (mach_base_file_addr != LLDB_INVALID_ADDRESS)
5402                 {
5403                     for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
5404                     {
5405                         // Iterate through the object file sections to find all
5406                         // of the sections that size on disk (to avoid __PAGEZERO)
5407                         // and load them
5408                         SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
5409                         if (section_sp &&
5410                             section_sp->GetFileSize() > 0 &&
5411                             section_sp->IsThreadSpecific() == false &&
5412                             module_sp.get() == section_sp->GetModule().get())
5413                         {
5414                             // Ignore __LINKEDIT and __DWARF segments
5415                             if (section_sp->GetName() == g_linkedit_segname)
5416                             {
5417                                 // Only map __LINKEDIT if we have an in memory image and this isn't
5418                                 // a kernel binary like a kext or mach_kernel.
5419                                 if (is_memory_image == false || strata == eStrataKernel)
5420                                     continue;
5421                             }
5422                             if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() - mach_base_file_addr + value))
5423                                 ++num_loaded_sections;
5424                         }
5425                     }
5426                 }
5427             }
5428         }
5429         return num_loaded_sections > 0;
5430     }
5431     return false;
5432 }
5433 
5434 bool
5435 ObjectFileMachO::SaveCore (const lldb::ProcessSP &process_sp,
5436                            const FileSpec &outfile,
5437                            Error &error)
5438 {
5439     if (process_sp)
5440     {
5441         Target &target = process_sp->GetTarget();
5442         const ArchSpec target_arch = target.GetArchitecture();
5443         const llvm::Triple &target_triple = target_arch.GetTriple();
5444         if (target_triple.getVendor() == llvm::Triple::Apple &&
5445             (target_triple.getOS() == llvm::Triple::MacOSX ||
5446              target_triple.getOS() == llvm::Triple::IOS))
5447         {
5448             bool make_core = false;
5449             switch (target_arch.GetMachine())
5450             {
5451                   // arm64 core file writing is having some problem with writing  down the
5452                   // dyld shared images info struct and/or the main executable binary. May
5453                   // turn out to be a debugserver problem, not sure yet.
5454 //                case llvm::Triple::aarch64:
5455 
5456                 case llvm::Triple::arm:
5457                 case llvm::Triple::x86:
5458                 case llvm::Triple::x86_64:
5459                     make_core = true;
5460                     break;
5461                 default:
5462                     error.SetErrorStringWithFormat ("unsupported core architecture: %s", target_triple.str().c_str());
5463                     break;
5464             }
5465 
5466             if (make_core)
5467             {
5468                 std::vector<segment_command_64> segment_load_commands;
5469 //                uint32_t range_info_idx = 0;
5470                 MemoryRegionInfo range_info;
5471                 Error range_error = process_sp->GetMemoryRegionInfo(0, range_info);
5472                 const uint32_t addr_byte_size = target_arch.GetAddressByteSize();
5473                 const ByteOrder byte_order = target_arch.GetByteOrder();
5474                 if (range_error.Success())
5475                 {
5476                     while (range_info.GetRange().GetRangeBase() != LLDB_INVALID_ADDRESS)
5477                     {
5478                         const addr_t addr = range_info.GetRange().GetRangeBase();
5479                         const addr_t size = range_info.GetRange().GetByteSize();
5480 
5481                         if (size == 0)
5482                             break;
5483 
5484                         // Calculate correct protections
5485                         uint32_t prot = 0;
5486                         if (range_info.GetReadable() == MemoryRegionInfo::eYes)
5487                             prot |= VM_PROT_READ;
5488                         if (range_info.GetWritable() == MemoryRegionInfo::eYes)
5489                             prot |= VM_PROT_WRITE;
5490                         if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
5491                             prot |= VM_PROT_EXECUTE;
5492 
5493 //                        printf ("[%3u] [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ") %c%c%c\n",
5494 //                                range_info_idx,
5495 //                                addr,
5496 //                                size,
5497 //                                (prot & VM_PROT_READ   ) ? 'r' : '-',
5498 //                                (prot & VM_PROT_WRITE  ) ? 'w' : '-',
5499 //                                (prot & VM_PROT_EXECUTE) ? 'x' : '-');
5500 
5501                         if (prot != 0)
5502                         {
5503                             uint32_t cmd_type = LC_SEGMENT_64;
5504                             uint32_t segment_size = sizeof (segment_command_64);
5505                             if (addr_byte_size == 4)
5506                             {
5507                                 cmd_type = LC_SEGMENT;
5508                                 segment_size = sizeof (segment_command);
5509                             }
5510                             segment_command_64 segment = {
5511                                 cmd_type,           // uint32_t cmd;
5512                                 segment_size,       // uint32_t cmdsize;
5513                                 {0},                // char segname[16];
5514                                 addr,               // uint64_t vmaddr;    // uint32_t for 32-bit Mach-O
5515                                 size,               // uint64_t vmsize;    // uint32_t for 32-bit Mach-O
5516                                 0,                  // uint64_t fileoff;   // uint32_t for 32-bit Mach-O
5517                                 size,               // uint64_t filesize;  // uint32_t for 32-bit Mach-O
5518                                 prot,               // uint32_t maxprot;
5519                                 prot,               // uint32_t initprot;
5520                                 0,                  // uint32_t nsects;
5521                                 0 };                // uint32_t flags;
5522                             segment_load_commands.push_back(segment);
5523                         }
5524                         else
5525                         {
5526                             // No protections and a size of 1 used to be returned from old
5527                             // debugservers when we asked about a region that was past the
5528                             // last memory region and it indicates the end...
5529                             if (size == 1)
5530                                 break;
5531                         }
5532 
5533                         range_error = process_sp->GetMemoryRegionInfo(range_info.GetRange().GetRangeEnd(), range_info);
5534                         if (range_error.Fail())
5535                             break;
5536                     }
5537 
5538                     StreamString buffer (Stream::eBinary,
5539                                          addr_byte_size,
5540                                          byte_order);
5541 
5542                     mach_header_64 mach_header;
5543                     if (addr_byte_size == 8)
5544                     {
5545                         mach_header.magic = MH_MAGIC_64;
5546                     }
5547                     else
5548                     {
5549                         mach_header.magic = MH_MAGIC;
5550                     }
5551                     mach_header.cputype = target_arch.GetMachOCPUType();
5552                     mach_header.cpusubtype = target_arch.GetMachOCPUSubType();
5553                     mach_header.filetype = MH_CORE;
5554                     mach_header.ncmds = segment_load_commands.size();
5555                     mach_header.flags = 0;
5556                     mach_header.reserved = 0;
5557                     ThreadList &thread_list = process_sp->GetThreadList();
5558                     const uint32_t num_threads = thread_list.GetSize();
5559 
5560                     // Make an array of LC_THREAD data items. Each one contains
5561                     // the contents of the LC_THREAD load command. The data doesn't
5562                     // contain the load command + load command size, we will
5563                     // add the load command and load command size as we emit the data.
5564                     std::vector<StreamString> LC_THREAD_datas(num_threads);
5565                     for (auto &LC_THREAD_data : LC_THREAD_datas)
5566                     {
5567                         LC_THREAD_data.GetFlags().Set(Stream::eBinary);
5568                         LC_THREAD_data.SetAddressByteSize(addr_byte_size);
5569                         LC_THREAD_data.SetByteOrder(byte_order);
5570                     }
5571                     for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx)
5572                     {
5573                         ThreadSP thread_sp (thread_list.GetThreadAtIndex(thread_idx));
5574                         if (thread_sp)
5575                         {
5576                             switch (mach_header.cputype)
5577                             {
5578                                 case llvm::MachO::CPU_TYPE_ARM64:
5579                                     RegisterContextDarwin_arm64_Mach::Create_LC_THREAD (thread_sp.get(), LC_THREAD_datas[thread_idx]);
5580                                     break;
5581 
5582                                 case llvm::MachO::CPU_TYPE_ARM:
5583                                     RegisterContextDarwin_arm_Mach::Create_LC_THREAD (thread_sp.get(), LC_THREAD_datas[thread_idx]);
5584                                     break;
5585 
5586                                 case llvm::MachO::CPU_TYPE_I386:
5587                                     RegisterContextDarwin_i386_Mach::Create_LC_THREAD (thread_sp.get(), LC_THREAD_datas[thread_idx]);
5588                                     break;
5589 
5590                                 case llvm::MachO::CPU_TYPE_X86_64:
5591                                     RegisterContextDarwin_x86_64_Mach::Create_LC_THREAD (thread_sp.get(), LC_THREAD_datas[thread_idx]);
5592                                     break;
5593                             }
5594 
5595                         }
5596                     }
5597 
5598                     // The size of the load command is the size of the segments...
5599                     if (addr_byte_size == 8)
5600                     {
5601                         mach_header.sizeofcmds = segment_load_commands.size() * sizeof (struct segment_command_64);
5602                     }
5603                     else
5604                     {
5605                         mach_header.sizeofcmds = segment_load_commands.size() * sizeof (struct segment_command);
5606                     }
5607 
5608                     // and the size of all LC_THREAD load command
5609                     for (const auto &LC_THREAD_data : LC_THREAD_datas)
5610                     {
5611                         ++mach_header.ncmds;
5612                         mach_header.sizeofcmds += 8 + LC_THREAD_data.GetSize();
5613                     }
5614 
5615                     printf ("mach_header: 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x\n",
5616                             mach_header.magic,
5617                             mach_header.cputype,
5618                             mach_header.cpusubtype,
5619                             mach_header.filetype,
5620                             mach_header.ncmds,
5621                             mach_header.sizeofcmds,
5622                             mach_header.flags,
5623                             mach_header.reserved);
5624 
5625                     // Write the mach header
5626                     buffer.PutHex32(mach_header.magic);
5627                     buffer.PutHex32(mach_header.cputype);
5628                     buffer.PutHex32(mach_header.cpusubtype);
5629                     buffer.PutHex32(mach_header.filetype);
5630                     buffer.PutHex32(mach_header.ncmds);
5631                     buffer.PutHex32(mach_header.sizeofcmds);
5632                     buffer.PutHex32(mach_header.flags);
5633                     if (addr_byte_size == 8)
5634                     {
5635                         buffer.PutHex32(mach_header.reserved);
5636                     }
5637 
5638                     // Skip the mach header and all load commands and align to the next
5639                     // 0x1000 byte boundary
5640                     addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
5641                     if (file_offset & 0x00000fff)
5642                     {
5643                         file_offset += 0x00001000ull;
5644                         file_offset &= (~0x00001000ull + 1);
5645                     }
5646 
5647                     for (auto &segment : segment_load_commands)
5648                     {
5649                         segment.fileoff = file_offset;
5650                         file_offset += segment.filesize;
5651                     }
5652 
5653                     // Write out all of the LC_THREAD load commands
5654                     for (const auto &LC_THREAD_data : LC_THREAD_datas)
5655                     {
5656                         const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
5657                         buffer.PutHex32(LC_THREAD);
5658                         buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
5659                         buffer.Write(LC_THREAD_data.GetData(), LC_THREAD_data_size);
5660                     }
5661 
5662                     // Write out all of the segment load commands
5663                     for (const auto &segment : segment_load_commands)
5664                     {
5665                         printf ("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ") [0x%16.16" PRIx64 " 0x%16.16" PRIx64 ") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n",
5666                                 segment.cmd,
5667                                 segment.cmdsize,
5668                                 segment.vmaddr,
5669                                 segment.vmaddr + segment.vmsize,
5670                                 segment.fileoff,
5671                                 segment.filesize,
5672                                 segment.maxprot,
5673                                 segment.initprot,
5674                                 segment.nsects,
5675                                 segment.flags);
5676 
5677                         buffer.PutHex32(segment.cmd);
5678                         buffer.PutHex32(segment.cmdsize);
5679                         buffer.PutRawBytes(segment.segname, sizeof(segment.segname));
5680                         if (addr_byte_size == 8)
5681                         {
5682                             buffer.PutHex64(segment.vmaddr);
5683                             buffer.PutHex64(segment.vmsize);
5684                             buffer.PutHex64(segment.fileoff);
5685                             buffer.PutHex64(segment.filesize);
5686                         }
5687                         else
5688                         {
5689                             buffer.PutHex32(static_cast<uint32_t>(segment.vmaddr));
5690                             buffer.PutHex32(static_cast<uint32_t>(segment.vmsize));
5691                             buffer.PutHex32(static_cast<uint32_t>(segment.fileoff));
5692                             buffer.PutHex32(static_cast<uint32_t>(segment.filesize));
5693                         }
5694                         buffer.PutHex32(segment.maxprot);
5695                         buffer.PutHex32(segment.initprot);
5696                         buffer.PutHex32(segment.nsects);
5697                         buffer.PutHex32(segment.flags);
5698                     }
5699 
5700                     File core_file;
5701                     std::string core_file_path(outfile.GetPath());
5702                     error = core_file.Open(core_file_path.c_str(),
5703                                            File::eOpenOptionWrite    |
5704                                            File::eOpenOptionTruncate |
5705                                            File::eOpenOptionCanCreate);
5706                     if (error.Success())
5707                     {
5708                         // Read 1 page at a time
5709                         uint8_t bytes[0x1000];
5710                         // Write the mach header and load commands out to the core file
5711                         size_t bytes_written = buffer.GetString().size();
5712                         error = core_file.Write(buffer.GetString().data(), bytes_written);
5713                         if (error.Success())
5714                         {
5715                             // Now write the file data for all memory segments in the process
5716                             for (const auto &segment : segment_load_commands)
5717                             {
5718                                 if (core_file.SeekFromStart(segment.fileoff) == -1)
5719                                 {
5720                                     error.SetErrorStringWithFormat("unable to seek to offset 0x%" PRIx64 " in '%s'", segment.fileoff, core_file_path.c_str());
5721                                     break;
5722                                 }
5723 
5724                                 printf ("Saving %" PRId64 " bytes of data for memory region at 0x%" PRIx64 "\n", segment.vmsize, segment.vmaddr);
5725                                 addr_t bytes_left = segment.vmsize;
5726                                 addr_t addr = segment.vmaddr;
5727                                 Error memory_read_error;
5728                                 while (bytes_left > 0 && error.Success())
5729                                 {
5730                                     const size_t bytes_to_read = bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
5731                                     const size_t bytes_read = process_sp->ReadMemory(addr, bytes, bytes_to_read, memory_read_error);
5732                                     if (bytes_read == bytes_to_read)
5733                                     {
5734                                         size_t bytes_written = bytes_read;
5735                                         error = core_file.Write(bytes, bytes_written);
5736                                         bytes_left -= bytes_read;
5737                                         addr += bytes_read;
5738                                     }
5739                                     else
5740                                     {
5741                                         // Some pages within regions are not readable, those
5742                                         // should be zero filled
5743                                         memset (bytes, 0, bytes_to_read);
5744                                         size_t bytes_written = bytes_to_read;
5745                                         error = core_file.Write(bytes, bytes_written);
5746                                         bytes_left -= bytes_to_read;
5747                                         addr += bytes_to_read;
5748                                     }
5749                                 }
5750                             }
5751                         }
5752                     }
5753                 }
5754                 else
5755                 {
5756                     error.SetErrorString("process doesn't support getting memory region info");
5757                 }
5758             }
5759             return true; // This is the right plug to handle saving core files for this process
5760         }
5761     }
5762     return false;
5763 }
5764 
5765