blob: 7ec1b48b0c329fbe5abc9a6fd0ae046a31a87d47 [file] [log] [blame]
Chris Lattner24943d22010-06-08 16:52:24 +00001//===-- 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
Greg Clayton3f69eac2011-12-03 02:30:59 +000010#include "llvm/ADT/StringRef.h"
Jim Ingham28775942011-03-07 23:44:08 +000011#include "llvm/Support/MachO.h"
12
Chris Lattner24943d22010-06-08 16:52:24 +000013#include "ObjectFileMachO.h"
14
Greg Claytond4330e62012-09-05 01:38:55 +000015#include "lldb/lldb-private-log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000016#include "lldb/Core/ArchSpec.h"
17#include "lldb/Core/DataBuffer.h"
Jason Molendaadf9e3d2013-04-10 05:58:57 +000018#include "lldb/Core/Debugger.h"
Chris Lattner24943d22010-06-08 16:52:24 +000019#include "lldb/Core/FileSpecList.h"
Greg Claytond4330e62012-09-05 01:38:55 +000020#include "lldb/Core/Log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000021#include "lldb/Core/Module.h"
22#include "lldb/Core/PluginManager.h"
Greg Clayton6f7f8da2012-04-24 03:06:13 +000023#include "lldb/Core/RangeMap.h"
Chris Lattner24943d22010-06-08 16:52:24 +000024#include "lldb/Core/Section.h"
25#include "lldb/Core/StreamFile.h"
26#include "lldb/Core/StreamString.h"
27#include "lldb/Core/Timer.h"
28#include "lldb/Core/UUID.h"
Greg Claytondf6dc882012-01-05 03:57:59 +000029#include "lldb/Host/Host.h"
30#include "lldb/Host/FileSpec.h"
Sean Callanan3e80cd92011-10-12 02:08:07 +000031#include "lldb/Symbol/ClangNamespaceDecl.h"
Jason Molendad7938392013-03-21 03:36:01 +000032#include "lldb/Symbol/DWARFCallFrameInfo.h"
Chris Lattner24943d22010-06-08 16:52:24 +000033#include "lldb/Symbol/ObjectFile.h"
Greg Clayton29021d32012-04-18 05:19:20 +000034#include "lldb/Target/Platform.h"
Greg Claytonb5a8f142012-02-05 02:38:54 +000035#include "lldb/Target/Process.h"
Greg Clayton29021d32012-04-18 05:19:20 +000036#include "lldb/Target/Target.h"
Greg Clayton9ce95382012-02-13 23:10:39 +000037#include "Plugins/Process/Utility/RegisterContextDarwin_arm.h"
38#include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
Greg Clayton46c9a352012-02-09 06:16:32 +000039#include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
Chris Lattner24943d22010-06-08 16:52:24 +000040
Jason Molenda45c75502013-04-16 06:24:42 +000041#if defined (__APPLE__) && defined (__arm__)
42// GetLLDBSharedCacheUUID() needs to call dlsym()
43#include <dlfcn.h>
44#endif
45
Chris Lattner24943d22010-06-08 16:52:24 +000046using namespace lldb;
47using namespace lldb_private;
Greg Clayton1674b122010-07-21 22:12:05 +000048using namespace llvm::MachO;
Chris Lattner24943d22010-06-08 16:52:24 +000049
Jason Molenda9badb6c2013-03-06 23:19:17 +000050class RegisterContextDarwin_x86_64_Mach : public RegisterContextDarwin_x86_64
Greg Clayton46c9a352012-02-09 06:16:32 +000051{
52public:
53 RegisterContextDarwin_x86_64_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
54 RegisterContextDarwin_x86_64 (thread, 0)
55 {
56 SetRegisterDataFrom_LC_THREAD (data);
57 }
58
59 virtual void
60 InvalidateAllRegisters ()
61 {
62 // Do nothing... registers are always valid...
63 }
64
65 void
66 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
67 {
Greg Clayton36da2aa2013-01-25 18:06:21 +000068 lldb::offset_t offset = 0;
Greg Clayton46c9a352012-02-09 06:16:32 +000069 SetError (GPRRegSet, Read, -1);
70 SetError (FPURegSet, Read, -1);
71 SetError (EXCRegSet, Read, -1);
Greg Clayton9ce95382012-02-13 23:10:39 +000072 bool done = false;
Jason Molenda9badb6c2013-03-06 23:19:17 +000073
Greg Clayton9ce95382012-02-13 23:10:39 +000074 while (!done)
Greg Clayton46c9a352012-02-09 06:16:32 +000075 {
Greg Clayton9ce95382012-02-13 23:10:39 +000076 int flavor = data.GetU32 (&offset);
77 if (flavor == 0)
78 done = true;
79 else
Greg Clayton46c9a352012-02-09 06:16:32 +000080 {
Greg Clayton9ce95382012-02-13 23:10:39 +000081 uint32_t i;
82 uint32_t count = data.GetU32 (&offset);
83 switch (flavor)
84 {
85 case GPRRegSet:
86 for (i=0; i<count; ++i)
87 (&gpr.rax)[i] = data.GetU64(&offset);
88 SetError (GPRRegSet, Read, 0);
89 done = true;
Jason Molenda9badb6c2013-03-06 23:19:17 +000090
Greg Clayton9ce95382012-02-13 23:10:39 +000091 break;
92 case FPURegSet:
93 // TODO: fill in FPU regs....
94 //SetError (FPURegSet, Read, -1);
95 done = true;
Jason Molenda9badb6c2013-03-06 23:19:17 +000096
Greg Clayton9ce95382012-02-13 23:10:39 +000097 break;
98 case EXCRegSet:
99 exc.trapno = data.GetU32(&offset);
100 exc.err = data.GetU32(&offset);
101 exc.faultvaddr = data.GetU64(&offset);
102 SetError (EXCRegSet, Read, 0);
103 done = true;
104 break;
105 case 7:
106 case 8:
107 case 9:
108 // fancy flavors that encapsulate of the the above
109 // falvors...
110 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +0000111
Greg Clayton9ce95382012-02-13 23:10:39 +0000112 default:
113 done = true;
114 break;
115 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000116 }
Greg Clayton9ce95382012-02-13 23:10:39 +0000117 }
118 }
119protected:
120 virtual int
121 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
122 {
123 return 0;
124 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000125
Greg Clayton9ce95382012-02-13 23:10:39 +0000126 virtual int
127 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
128 {
129 return 0;
130 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000131
Greg Clayton9ce95382012-02-13 23:10:39 +0000132 virtual int
133 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
134 {
135 return 0;
136 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000137
Greg Clayton9ce95382012-02-13 23:10:39 +0000138 virtual int
139 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
140 {
141 return 0;
142 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000143
Greg Clayton9ce95382012-02-13 23:10:39 +0000144 virtual int
145 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
146 {
147 return 0;
148 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000149
Greg Clayton9ce95382012-02-13 23:10:39 +0000150 virtual int
151 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
152 {
153 return 0;
154 }
155};
Greg Clayton46c9a352012-02-09 06:16:32 +0000156
Greg Clayton9ce95382012-02-13 23:10:39 +0000157
Jason Molenda9badb6c2013-03-06 23:19:17 +0000158class RegisterContextDarwin_i386_Mach : public RegisterContextDarwin_i386
Greg Clayton9ce95382012-02-13 23:10:39 +0000159{
160public:
161 RegisterContextDarwin_i386_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
162 RegisterContextDarwin_i386 (thread, 0)
163 {
164 SetRegisterDataFrom_LC_THREAD (data);
165 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000166
Greg Clayton9ce95382012-02-13 23:10:39 +0000167 virtual void
168 InvalidateAllRegisters ()
169 {
170 // Do nothing... registers are always valid...
171 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000172
Greg Clayton9ce95382012-02-13 23:10:39 +0000173 void
174 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
175 {
Greg Clayton36da2aa2013-01-25 18:06:21 +0000176 lldb::offset_t offset = 0;
Greg Clayton9ce95382012-02-13 23:10:39 +0000177 SetError (GPRRegSet, Read, -1);
178 SetError (FPURegSet, Read, -1);
179 SetError (EXCRegSet, Read, -1);
180 bool done = false;
Jason Molenda9badb6c2013-03-06 23:19:17 +0000181
Greg Clayton9ce95382012-02-13 23:10:39 +0000182 while (!done)
183 {
184 int flavor = data.GetU32 (&offset);
185 if (flavor == 0)
186 done = true;
187 else
Greg Clayton46c9a352012-02-09 06:16:32 +0000188 {
Greg Clayton9ce95382012-02-13 23:10:39 +0000189 uint32_t i;
190 uint32_t count = data.GetU32 (&offset);
191 switch (flavor)
192 {
193 case GPRRegSet:
194 for (i=0; i<count; ++i)
195 (&gpr.eax)[i] = data.GetU32(&offset);
196 SetError (GPRRegSet, Read, 0);
197 done = true;
198
199 break;
200 case FPURegSet:
201 // TODO: fill in FPU regs....
202 //SetError (FPURegSet, Read, -1);
203 done = true;
204
205 break;
206 case EXCRegSet:
207 exc.trapno = data.GetU32(&offset);
208 exc.err = data.GetU32(&offset);
209 exc.faultvaddr = data.GetU32(&offset);
210 SetError (EXCRegSet, Read, 0);
211 done = true;
212 break;
213 case 7:
214 case 8:
215 case 9:
216 // fancy flavors that encapsulate of the the above
217 // falvors...
218 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +0000219
Greg Clayton9ce95382012-02-13 23:10:39 +0000220 default:
221 done = true;
222 break;
223 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000224 }
225 }
226 }
227protected:
228 virtual int
229 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
230 {
231 return 0;
232 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000233
Greg Clayton46c9a352012-02-09 06:16:32 +0000234 virtual int
235 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
236 {
237 return 0;
238 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000239
Greg Clayton46c9a352012-02-09 06:16:32 +0000240 virtual int
241 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
242 {
243 return 0;
244 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000245
Greg Clayton46c9a352012-02-09 06:16:32 +0000246 virtual int
247 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
248 {
249 return 0;
250 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000251
Greg Clayton46c9a352012-02-09 06:16:32 +0000252 virtual int
253 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
254 {
255 return 0;
256 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000257
Greg Clayton46c9a352012-02-09 06:16:32 +0000258 virtual int
259 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
260 {
261 return 0;
262 }
263};
264
Jason Molenda9badb6c2013-03-06 23:19:17 +0000265class RegisterContextDarwin_arm_Mach : public RegisterContextDarwin_arm
Greg Clayton9ce95382012-02-13 23:10:39 +0000266{
267public:
268 RegisterContextDarwin_arm_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
Greg Claytonb5431d02012-10-30 23:57:32 +0000269 RegisterContextDarwin_arm (thread, 0)
Greg Clayton9ce95382012-02-13 23:10:39 +0000270 {
271 SetRegisterDataFrom_LC_THREAD (data);
272 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000273
Greg Clayton9ce95382012-02-13 23:10:39 +0000274 virtual void
275 InvalidateAllRegisters ()
276 {
277 // Do nothing... registers are always valid...
278 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000279
Greg Clayton9ce95382012-02-13 23:10:39 +0000280 void
281 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
282 {
Greg Clayton36da2aa2013-01-25 18:06:21 +0000283 lldb::offset_t offset = 0;
Greg Clayton9ce95382012-02-13 23:10:39 +0000284 SetError (GPRRegSet, Read, -1);
285 SetError (FPURegSet, Read, -1);
286 SetError (EXCRegSet, Read, -1);
287 int flavor = data.GetU32 (&offset);
288 uint32_t count = data.GetU32 (&offset);
289 switch (flavor)
290 {
291 case GPRRegSet:
292 for (uint32_t i=0; i<count; ++i)
293 gpr.r[i] = data.GetU32(&offset);
294 SetError (GPRRegSet, Read, 0);
295 break;
296 case FPURegSet:
297 // TODO: fill in FPU regs....
298 //SetError (FPURegSet, Read, -1);
299 break;
300 case EXCRegSet:
301 exc.exception = data.GetU32(&offset);
302 exc.fsr = data.GetU32(&offset);
303 exc.far = data.GetU32(&offset);
304 SetError (EXCRegSet, Read, 0);
305 break;
306 }
307 }
308protected:
309 virtual int
310 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
311 {
312 return 0;
313 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000314
Greg Clayton9ce95382012-02-13 23:10:39 +0000315 virtual int
316 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
317 {
318 return 0;
319 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000320
Greg Clayton9ce95382012-02-13 23:10:39 +0000321 virtual int
322 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
323 {
324 return 0;
325 }
Greg Claytonb5431d02012-10-30 23:57:32 +0000326
327 virtual int
328 DoReadDBG (lldb::tid_t tid, int flavor, DBG &dbg)
329 {
330 return -1;
331 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000332
Greg Clayton9ce95382012-02-13 23:10:39 +0000333 virtual int
334 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
335 {
336 return 0;
337 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000338
Greg Clayton9ce95382012-02-13 23:10:39 +0000339 virtual int
340 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
341 {
342 return 0;
343 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000344
Greg Clayton9ce95382012-02-13 23:10:39 +0000345 virtual int
346 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
347 {
348 return 0;
349 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000350
Greg Claytonb5431d02012-10-30 23:57:32 +0000351 virtual int
352 DoWriteDBG (lldb::tid_t tid, int flavor, const DBG &dbg)
353 {
354 return -1;
355 }
Greg Clayton9ce95382012-02-13 23:10:39 +0000356};
357
Greg Claytonb1888f22011-03-19 01:12:21 +0000358#define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008
Chris Lattner24943d22010-06-08 16:52:24 +0000359
360void
361ObjectFileMachO::Initialize()
362{
363 PluginManager::RegisterPlugin (GetPluginNameStatic(),
364 GetPluginDescriptionStatic(),
Greg Claytonb5a8f142012-02-05 02:38:54 +0000365 CreateInstance,
366 CreateMemoryInstance);
Chris Lattner24943d22010-06-08 16:52:24 +0000367}
368
369void
370ObjectFileMachO::Terminate()
371{
372 PluginManager::UnregisterPlugin (CreateInstance);
373}
374
375
376const char *
377ObjectFileMachO::GetPluginNameStatic()
378{
379 return "object-file.mach-o";
380}
381
382const char *
383ObjectFileMachO::GetPluginDescriptionStatic()
384{
385 return "Mach-o object file reader (32 and 64 bit)";
386}
387
Chris Lattner24943d22010-06-08 16:52:24 +0000388ObjectFile *
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000389ObjectFileMachO::CreateInstance (const lldb::ModuleSP &module_sp,
390 DataBufferSP& data_sp,
391 lldb::offset_t data_offset,
392 const FileSpec* file,
393 lldb::offset_t file_offset,
394 lldb::offset_t length)
Chris Lattner24943d22010-06-08 16:52:24 +0000395{
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000396 if (!data_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000397 {
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000398 data_sp = file->MemoryMapFileContents(file_offset, length);
399 data_offset = 0;
400 }
401
402 if (ObjectFileMachO::MagicBytesMatch(data_sp, data_offset, length))
403 {
404 // Update the data to contain the entire file if it doesn't already
405 if (data_sp->GetByteSize() < length)
406 {
407 data_sp = file->MemoryMapFileContents(file_offset, length);
408 data_offset = 0;
409 }
410 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, data_offset, file, file_offset, length));
Chris Lattner24943d22010-06-08 16:52:24 +0000411 if (objfile_ap.get() && objfile_ap->ParseHeader())
412 return objfile_ap.release();
413 }
414 return NULL;
415}
416
Greg Claytonb5a8f142012-02-05 02:38:54 +0000417ObjectFile *
Jason Molenda9badb6c2013-03-06 23:19:17 +0000418ObjectFileMachO::CreateMemoryInstance (const lldb::ModuleSP &module_sp,
419 DataBufferSP& data_sp,
420 const ProcessSP &process_sp,
Greg Claytonb5a8f142012-02-05 02:38:54 +0000421 lldb::addr_t header_addr)
422{
423 if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
424 {
Greg Clayton3508c382012-02-24 01:59:29 +0000425 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, process_sp, header_addr));
Greg Claytonb5a8f142012-02-05 02:38:54 +0000426 if (objfile_ap.get() && objfile_ap->ParseHeader())
427 return objfile_ap.release();
428 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000429 return NULL;
Greg Claytonb5a8f142012-02-05 02:38:54 +0000430}
431
432
433const ConstString &
434ObjectFileMachO::GetSegmentNameTEXT()
435{
436 static ConstString g_segment_name_TEXT ("__TEXT");
437 return g_segment_name_TEXT;
438}
439
440const ConstString &
441ObjectFileMachO::GetSegmentNameDATA()
442{
443 static ConstString g_segment_name_DATA ("__DATA");
444 return g_segment_name_DATA;
445}
446
447const ConstString &
448ObjectFileMachO::GetSegmentNameOBJC()
449{
450 static ConstString g_segment_name_OBJC ("__OBJC");
451 return g_segment_name_OBJC;
452}
453
454const ConstString &
455ObjectFileMachO::GetSegmentNameLINKEDIT()
456{
457 static ConstString g_section_name_LINKEDIT ("__LINKEDIT");
458 return g_section_name_LINKEDIT;
459}
460
461const ConstString &
462ObjectFileMachO::GetSectionNameEHFrame()
463{
464 static ConstString g_section_name_eh_frame ("__eh_frame");
465 return g_section_name_eh_frame;
466}
467
468
Chris Lattner24943d22010-06-08 16:52:24 +0000469
470static uint32_t
471MachHeaderSizeFromMagic(uint32_t magic)
472{
473 switch (magic)
474 {
Greg Clayton1674b122010-07-21 22:12:05 +0000475 case HeaderMagic32:
476 case HeaderMagic32Swapped:
Chris Lattner24943d22010-06-08 16:52:24 +0000477 return sizeof(struct mach_header);
478
Greg Clayton1674b122010-07-21 22:12:05 +0000479 case HeaderMagic64:
480 case HeaderMagic64Swapped:
Chris Lattner24943d22010-06-08 16:52:24 +0000481 return sizeof(struct mach_header_64);
482 break;
483
484 default:
485 break;
486 }
487 return 0;
488}
489
490
491bool
Jason Molenda9badb6c2013-03-06 23:19:17 +0000492ObjectFileMachO::MagicBytesMatch (DataBufferSP& data_sp,
493 lldb::addr_t data_offset,
Greg Claytondb2dc2b2012-01-12 05:25:17 +0000494 lldb::addr_t data_length)
Chris Lattner24943d22010-06-08 16:52:24 +0000495{
Greg Claytondb2dc2b2012-01-12 05:25:17 +0000496 DataExtractor data;
497 data.SetData (data_sp, data_offset, data_length);
Greg Clayton36da2aa2013-01-25 18:06:21 +0000498 lldb::offset_t offset = 0;
Chris Lattner24943d22010-06-08 16:52:24 +0000499 uint32_t magic = data.GetU32(&offset);
500 return MachHeaderSizeFromMagic(magic) != 0;
501}
502
503
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000504ObjectFileMachO::ObjectFileMachO(const lldb::ModuleSP &module_sp,
505 DataBufferSP& data_sp,
506 lldb::offset_t data_offset,
507 const FileSpec* file,
508 lldb::offset_t file_offset,
509 lldb::offset_t length) :
510 ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
Greg Clayton46c9a352012-02-09 06:16:32 +0000511 m_mach_segments(),
512 m_mach_sections(),
513 m_entry_point_address(),
514 m_thread_context_offsets(),
515 m_thread_context_offsets_valid(false)
Chris Lattner24943d22010-06-08 16:52:24 +0000516{
Greg Claytonddff7cc2011-02-04 21:13:05 +0000517 ::memset (&m_header, 0, sizeof(m_header));
518 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
Chris Lattner24943d22010-06-08 16:52:24 +0000519}
520
Greg Clayton3508c382012-02-24 01:59:29 +0000521ObjectFileMachO::ObjectFileMachO (const lldb::ModuleSP &module_sp,
Greg Claytonb5a8f142012-02-05 02:38:54 +0000522 lldb::DataBufferSP& header_data_sp,
523 const lldb::ProcessSP &process_sp,
524 lldb::addr_t header_addr) :
Greg Clayton3508c382012-02-24 01:59:29 +0000525 ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
Greg Clayton46c9a352012-02-09 06:16:32 +0000526 m_mach_segments(),
527 m_mach_sections(),
528 m_entry_point_address(),
529 m_thread_context_offsets(),
530 m_thread_context_offsets_valid(false)
Greg Claytonb5a8f142012-02-05 02:38:54 +0000531{
532 ::memset (&m_header, 0, sizeof(m_header));
533 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
534}
Chris Lattner24943d22010-06-08 16:52:24 +0000535
536ObjectFileMachO::~ObjectFileMachO()
537{
538}
539
540
541bool
542ObjectFileMachO::ParseHeader ()
543{
Greg Clayton9482f052012-03-13 23:14:29 +0000544 ModuleSP module_sp(GetModule());
545 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000546 {
Greg Clayton9482f052012-03-13 23:14:29 +0000547 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
548 bool can_parse = false;
Greg Clayton36da2aa2013-01-25 18:06:21 +0000549 lldb::offset_t offset = 0;
Greg Claytoncd548032011-02-01 01:31:41 +0000550 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
Greg Clayton9482f052012-03-13 23:14:29 +0000551 // Leave magic in the original byte order
552 m_header.magic = m_data.GetU32(&offset);
553 switch (m_header.magic)
Greg Claytonb5a8f142012-02-05 02:38:54 +0000554 {
Greg Clayton9482f052012-03-13 23:14:29 +0000555 case HeaderMagic32:
556 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
557 m_data.SetAddressByteSize(4);
558 can_parse = true;
559 break;
560
561 case HeaderMagic64:
562 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
563 m_data.SetAddressByteSize(8);
564 can_parse = true;
565 break;
566
567 case HeaderMagic32Swapped:
568 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
569 m_data.SetAddressByteSize(4);
570 can_parse = true;
571 break;
572
573 case HeaderMagic64Swapped:
574 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
575 m_data.SetAddressByteSize(8);
576 can_parse = true;
577 break;
578
579 default:
580 break;
Greg Claytonb5a8f142012-02-05 02:38:54 +0000581 }
Greg Clayton9482f052012-03-13 23:14:29 +0000582
583 if (can_parse)
584 {
585 m_data.GetU32(&offset, &m_header.cputype, 6);
586
587 ArchSpec mach_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
Jason Molenda9badb6c2013-03-06 23:19:17 +0000588
Greg Clayton21a25432012-11-16 21:36:10 +0000589 // Check if the module has a required architecture
590 const ArchSpec &module_arch = module_sp->GetArchitecture();
Sean Callanan40e278c2012-12-13 22:07:14 +0000591 if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
Greg Clayton21a25432012-11-16 21:36:10 +0000592 return false;
593
Greg Clayton9482f052012-03-13 23:14:29 +0000594 if (SetModulesArchitecture (mach_arch))
595 {
596 const size_t header_and_lc_size = m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
597 if (m_data.GetByteSize() < header_and_lc_size)
598 {
599 DataBufferSP data_sp;
600 ProcessSP process_sp (m_process_wp.lock());
601 if (process_sp)
602 {
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000603 data_sp = ReadMemory (process_sp, m_memory_addr, header_and_lc_size);
Greg Clayton9482f052012-03-13 23:14:29 +0000604 }
605 else
606 {
607 // Read in all only the load command data from the file on disk
Greg Claytoncbe61bd2013-02-06 17:22:03 +0000608 data_sp = m_file.ReadFileContents(m_file_offset, header_and_lc_size);
Greg Clayton9482f052012-03-13 23:14:29 +0000609 if (data_sp->GetByteSize() != header_and_lc_size)
610 return false;
611 }
612 if (data_sp)
613 m_data.SetData (data_sp);
614 }
615 }
616 return true;
617 }
618 else
619 {
620 memset(&m_header, 0, sizeof(struct mach_header));
621 }
Chris Lattner24943d22010-06-08 16:52:24 +0000622 }
623 return false;
624}
625
626
627ByteOrder
628ObjectFileMachO::GetByteOrder () const
629{
Chris Lattner24943d22010-06-08 16:52:24 +0000630 return m_data.GetByteOrder ();
631}
632
Jim Ingham7508e732010-08-09 23:31:02 +0000633bool
634ObjectFileMachO::IsExecutable() const
635{
636 return m_header.filetype == HeaderFileTypeExecutable;
637}
Chris Lattner24943d22010-06-08 16:52:24 +0000638
Greg Clayton36da2aa2013-01-25 18:06:21 +0000639uint32_t
Chris Lattner24943d22010-06-08 16:52:24 +0000640ObjectFileMachO::GetAddressByteSize () const
641{
Chris Lattner24943d22010-06-08 16:52:24 +0000642 return m_data.GetAddressByteSize ();
643}
644
Greg Claytonb3448432011-03-24 21:19:54 +0000645AddressClass
Greg Claytonb1888f22011-03-19 01:12:21 +0000646ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr)
647{
648 Symtab *symtab = GetSymtab();
649 if (symtab)
650 {
651 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
652 if (symbol)
653 {
Greg Clayton0c31d3d2012-03-07 21:03:09 +0000654 if (symbol->ValueIsAddress())
Greg Claytonb1888f22011-03-19 01:12:21 +0000655 {
Greg Clayton0c31d3d2012-03-07 21:03:09 +0000656 SectionSP section_sp (symbol->GetAddress().GetSection());
Greg Clayton3508c382012-02-24 01:59:29 +0000657 if (section_sp)
Greg Claytonb1888f22011-03-19 01:12:21 +0000658 {
Greg Clayton3508c382012-02-24 01:59:29 +0000659 const SectionType section_type = section_sp->GetType();
Greg Claytonb1888f22011-03-19 01:12:21 +0000660 switch (section_type)
661 {
662 case eSectionTypeInvalid: return eAddressClassUnknown;
663 case eSectionTypeCode:
664 if (m_header.cputype == llvm::MachO::CPUTypeARM)
665 {
666 // For ARM we have a bit in the n_desc field of the symbol
667 // that tells us ARM/Thumb which is bit 0x0008.
668 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
669 return eAddressClassCodeAlternateISA;
670 }
671 return eAddressClassCode;
672
673 case eSectionTypeContainer: return eAddressClassUnknown;
Greg Clayton24a6bd92011-10-27 17:55:14 +0000674 case eSectionTypeData:
675 case eSectionTypeDataCString:
676 case eSectionTypeDataCStringPointers:
677 case eSectionTypeDataSymbolAddress:
678 case eSectionTypeData4:
679 case eSectionTypeData8:
680 case eSectionTypeData16:
681 case eSectionTypeDataPointers:
682 case eSectionTypeZeroFill:
683 case eSectionTypeDataObjCMessageRefs:
684 case eSectionTypeDataObjCCFStrings:
685 return eAddressClassData;
686 case eSectionTypeDebug:
687 case eSectionTypeDWARFDebugAbbrev:
688 case eSectionTypeDWARFDebugAranges:
689 case eSectionTypeDWARFDebugFrame:
690 case eSectionTypeDWARFDebugInfo:
691 case eSectionTypeDWARFDebugLine:
692 case eSectionTypeDWARFDebugLoc:
693 case eSectionTypeDWARFDebugMacInfo:
694 case eSectionTypeDWARFDebugPubNames:
695 case eSectionTypeDWARFDebugPubTypes:
696 case eSectionTypeDWARFDebugRanges:
697 case eSectionTypeDWARFDebugStr:
698 case eSectionTypeDWARFAppleNames:
699 case eSectionTypeDWARFAppleTypes:
700 case eSectionTypeDWARFAppleNamespaces:
701 case eSectionTypeDWARFAppleObjC:
702 return eAddressClassDebug;
Greg Claytonb1888f22011-03-19 01:12:21 +0000703 case eSectionTypeEHFrame: return eAddressClassRuntime;
704 case eSectionTypeOther: return eAddressClassUnknown;
705 }
706 }
707 }
Jason Molenda9badb6c2013-03-06 23:19:17 +0000708
Greg Claytonb3448432011-03-24 21:19:54 +0000709 const SymbolType symbol_type = symbol->GetType();
Greg Claytonb1888f22011-03-19 01:12:21 +0000710 switch (symbol_type)
711 {
712 case eSymbolTypeAny: return eAddressClassUnknown;
713 case eSymbolTypeAbsolute: return eAddressClassUnknown;
Jason Molenda9badb6c2013-03-06 23:19:17 +0000714
Greg Claytonb1888f22011-03-19 01:12:21 +0000715 case eSymbolTypeCode:
716 case eSymbolTypeTrampoline:
Greg Clayton06884352013-02-27 21:16:04 +0000717 case eSymbolTypeResolver:
Greg Claytonb1888f22011-03-19 01:12:21 +0000718 if (m_header.cputype == llvm::MachO::CPUTypeARM)
719 {
720 // For ARM we have a bit in the n_desc field of the symbol
721 // that tells us ARM/Thumb which is bit 0x0008.
722 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
723 return eAddressClassCodeAlternateISA;
724 }
725 return eAddressClassCode;
726
727 case eSymbolTypeData: return eAddressClassData;
728 case eSymbolTypeRuntime: return eAddressClassRuntime;
729 case eSymbolTypeException: return eAddressClassRuntime;
730 case eSymbolTypeSourceFile: return eAddressClassDebug;
731 case eSymbolTypeHeaderFile: return eAddressClassDebug;
732 case eSymbolTypeObjectFile: return eAddressClassDebug;
733 case eSymbolTypeCommonBlock: return eAddressClassDebug;
734 case eSymbolTypeBlock: return eAddressClassDebug;
735 case eSymbolTypeLocal: return eAddressClassData;
736 case eSymbolTypeParam: return eAddressClassData;
737 case eSymbolTypeVariable: return eAddressClassData;
738 case eSymbolTypeVariableType: return eAddressClassDebug;
739 case eSymbolTypeLineEntry: return eAddressClassDebug;
740 case eSymbolTypeLineHeader: return eAddressClassDebug;
741 case eSymbolTypeScopeBegin: return eAddressClassDebug;
742 case eSymbolTypeScopeEnd: return eAddressClassDebug;
743 case eSymbolTypeAdditional: return eAddressClassUnknown;
744 case eSymbolTypeCompiler: return eAddressClassDebug;
745 case eSymbolTypeInstrumentation:return eAddressClassDebug;
746 case eSymbolTypeUndefined: return eAddressClassUnknown;
Greg Clayton3f69eac2011-12-03 02:30:59 +0000747 case eSymbolTypeObjCClass: return eAddressClassRuntime;
748 case eSymbolTypeObjCMetaClass: return eAddressClassRuntime;
749 case eSymbolTypeObjCIVar: return eAddressClassRuntime;
Greg Claytonb1888f22011-03-19 01:12:21 +0000750 }
751 }
752 }
753 return eAddressClassUnknown;
754}
Chris Lattner24943d22010-06-08 16:52:24 +0000755
756Symtab *
757ObjectFileMachO::GetSymtab()
758{
Greg Clayton9482f052012-03-13 23:14:29 +0000759 ModuleSP module_sp(GetModule());
760 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000761 {
Greg Clayton9482f052012-03-13 23:14:29 +0000762 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
763 if (m_symtab_ap.get() == NULL)
764 {
765 m_symtab_ap.reset(new Symtab(this));
766 Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
767 ParseSymtab (true);
768 m_symtab_ap->Finalize ();
769 }
Chris Lattner24943d22010-06-08 16:52:24 +0000770 }
771 return m_symtab_ap.get();
772}
773
774
775SectionList *
776ObjectFileMachO::GetSectionList()
777{
Greg Clayton9482f052012-03-13 23:14:29 +0000778 ModuleSP module_sp(GetModule());
779 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000780 {
Greg Clayton9482f052012-03-13 23:14:29 +0000781 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
782 if (m_sections_ap.get() == NULL)
783 {
784 m_sections_ap.reset(new SectionList());
785 ParseSections();
786 }
Chris Lattner24943d22010-06-08 16:52:24 +0000787 }
788 return m_sections_ap.get();
789}
790
791
792size_t
793ObjectFileMachO::ParseSections ()
794{
795 lldb::user_id_t segID = 0;
796 lldb::user_id_t sectID = 0;
Greg Clayton36da2aa2013-01-25 18:06:21 +0000797 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Chris Lattner24943d22010-06-08 16:52:24 +0000798 uint32_t i;
Greg Clayton46c9a352012-02-09 06:16:32 +0000799 const bool is_core = GetType() == eTypeCoreFile;
Chris Lattner24943d22010-06-08 16:52:24 +0000800 //bool dump_sections = false;
Greg Clayton3508c382012-02-24 01:59:29 +0000801 ModuleSP module_sp (GetModule());
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000802 // First look up any LC_ENCRYPTION_INFO load commands
803 typedef RangeArray<uint32_t, uint32_t, 8> EncryptedFileRanges;
804 EncryptedFileRanges encrypted_file_ranges;
Greg Clayton54e33712012-05-25 18:09:55 +0000805 encryption_info_command encryption_cmd;
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000806 for (i=0; i<m_header.ncmds; ++i)
807 {
Greg Clayton36da2aa2013-01-25 18:06:21 +0000808 const lldb::offset_t load_cmd_offset = offset;
Greg Clayton54e33712012-05-25 18:09:55 +0000809 if (m_data.GetU32(&offset, &encryption_cmd, 2) == NULL)
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000810 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +0000811
Greg Clayton54e33712012-05-25 18:09:55 +0000812 if (encryption_cmd.cmd == LoadCommandEncryptionInfo)
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000813 {
Greg Clayton54e33712012-05-25 18:09:55 +0000814 if (m_data.GetU32(&offset, &encryption_cmd.cryptoff, 3))
815 {
816 if (encryption_cmd.cryptid != 0)
817 {
818 EncryptedFileRanges::Entry entry;
819 entry.SetRangeBase(encryption_cmd.cryptoff);
820 entry.SetByteSize(encryption_cmd.cryptsize);
821 encrypted_file_ranges.Append(entry);
822 }
823 }
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000824 }
Greg Clayton54e33712012-05-25 18:09:55 +0000825 offset = load_cmd_offset + encryption_cmd.cmdsize;
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000826 }
827
828 offset = MachHeaderSizeFromMagic(m_header.magic);
829
Greg Clayton54e33712012-05-25 18:09:55 +0000830 struct segment_command_64 load_cmd;
Chris Lattner24943d22010-06-08 16:52:24 +0000831 for (i=0; i<m_header.ncmds; ++i)
832 {
Greg Clayton36da2aa2013-01-25 18:06:21 +0000833 const lldb::offset_t load_cmd_offset = offset;
Chris Lattner24943d22010-06-08 16:52:24 +0000834 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
835 break;
836
Greg Clayton1674b122010-07-21 22:12:05 +0000837 if (load_cmd.cmd == LoadCommandSegment32 || load_cmd.cmd == LoadCommandSegment64)
Chris Lattner24943d22010-06-08 16:52:24 +0000838 {
839 if (m_data.GetU8(&offset, (uint8_t*)load_cmd.segname, 16))
840 {
841 load_cmd.vmaddr = m_data.GetAddress(&offset);
842 load_cmd.vmsize = m_data.GetAddress(&offset);
843 load_cmd.fileoff = m_data.GetAddress(&offset);
844 load_cmd.filesize = m_data.GetAddress(&offset);
Jason Molendaadf9e3d2013-04-10 05:58:57 +0000845 if (m_length != 0 && load_cmd.filesize != 0)
846 {
Greg Claytonbb759862013-04-16 16:51:19 +0000847 if (load_cmd.fileoff > m_length)
848 {
849 // We have a load command that says it extends past the end of hte file. This is likely
850 // a corrupt file. We don't have any way to return an error condition here (this method
851 // was likely invokved from something like ObjectFile::GetSectionList()) -- all we can do
852 // is null out the SectionList vector and if a process has been set up, dump a message
853 // to stdout. The most common case here is core file debugging with a truncated file.
854 const char *lc_segment_name = load_cmd.cmd == LoadCommandSegment64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
855 GetModule()->ReportError("is a corrupt mach-o file: load command %u %s has a fileoff (0x%" PRIx64 ") that extends beyond the end of the file (0x%" PRIx64 ")",
856 i,
857 lc_segment_name,
858 load_cmd.fileoff,
859 m_length);
860 m_sections_ap->Clear();
861 return 0;
862 }
863
Jason Molendaadf9e3d2013-04-10 05:58:57 +0000864 if (load_cmd.fileoff + load_cmd.filesize > m_length)
865 {
866 // We have a load command that says it extends past the end of hte file. This is likely
867 // a corrupt file. We don't have any way to return an error condition here (this method
868 // was likely invokved from something like ObjectFile::GetSectionList()) -- all we can do
869 // is null out the SectionList vector and if a process has been set up, dump a message
Greg Claytonbb759862013-04-16 16:51:19 +0000870 // to stdout. The most common case here is core file debugging with a truncated file.
871 const char *lc_segment_name = load_cmd.cmd == LoadCommandSegment64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
872 GetModule()->ReportError("is a corrupt mach-o file: load command %u %s has a fileoff + filesize (0x%" PRIx64 ") that extends beyond the end of the file (0x%" PRIx64 ")",
873 i,
874 lc_segment_name,
875 load_cmd.fileoff + load_cmd.filesize,
876 m_length);
Jason Molendaadf9e3d2013-04-10 05:58:57 +0000877 m_sections_ap->Clear();
878 return 0;
879 }
880 }
Chris Lattner24943d22010-06-08 16:52:24 +0000881 if (m_data.GetU32(&offset, &load_cmd.maxprot, 4))
882 {
Jason Molenda9badb6c2013-03-06 23:19:17 +0000883
Greg Clayton68ca8232011-01-25 02:58:48 +0000884 const bool segment_is_encrypted = (load_cmd.flags & SegmentCommandFlagBitProtectedVersion1) != 0;
885
Chris Lattner24943d22010-06-08 16:52:24 +0000886 // Keep a list of mach segments around in case we need to
887 // get at data that isn't stored in the abstracted Sections.
888 m_mach_segments.push_back (load_cmd);
889
Greg Clayton36da2aa2013-01-25 18:06:21 +0000890 ConstString segment_name (load_cmd.segname, std::min<size_t>(strlen(load_cmd.segname), sizeof(load_cmd.segname)));
Chris Lattner24943d22010-06-08 16:52:24 +0000891 // Use a segment ID of the segment index shifted left by 8 so they
892 // never conflict with any of the sections.
893 SectionSP segment_sp;
Greg Clayton46c9a352012-02-09 06:16:32 +0000894 if (segment_name || is_core)
Chris Lattner24943d22010-06-08 16:52:24 +0000895 {
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000896 segment_sp.reset(new Section (module_sp, // Module to which this section belongs
Chris Lattner24943d22010-06-08 16:52:24 +0000897 ++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
898 segment_name, // Name of this section
899 eSectionTypeContainer, // This section is a container of other sections.
900 load_cmd.vmaddr, // File VM address == addresses as they are found in the object file
901 load_cmd.vmsize, // VM size in bytes of this section
902 load_cmd.fileoff, // Offset to the data for this section in the file
903 load_cmd.filesize, // Size in bytes of this section as found in the the file
904 load_cmd.flags)); // Flags for this section
905
Greg Clayton68ca8232011-01-25 02:58:48 +0000906 segment_sp->SetIsEncrypted (segment_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +0000907 m_sections_ap->AddSection(segment_sp);
908 }
909
910 struct section_64 sect64;
Greg Claytonddff7cc2011-02-04 21:13:05 +0000911 ::memset (&sect64, 0, sizeof(sect64));
Chris Lattner24943d22010-06-08 16:52:24 +0000912 // Push a section into our mach sections for the section at
Jason Molenda9badb6c2013-03-06 23:19:17 +0000913 // index zero (NListSectionNoSection) if we don't have any
Greg Clayton6af4fad2010-10-06 01:26:32 +0000914 // mach sections yet...
915 if (m_mach_sections.empty())
916 m_mach_sections.push_back(sect64);
Chris Lattner24943d22010-06-08 16:52:24 +0000917 uint32_t segment_sect_idx;
918 const lldb::user_id_t first_segment_sectID = sectID + 1;
919
920
Greg Clayton1674b122010-07-21 22:12:05 +0000921 const uint32_t num_u32s = load_cmd.cmd == LoadCommandSegment32 ? 7 : 8;
Chris Lattner24943d22010-06-08 16:52:24 +0000922 for (segment_sect_idx=0; segment_sect_idx<load_cmd.nsects; ++segment_sect_idx)
923 {
924 if (m_data.GetU8(&offset, (uint8_t*)sect64.sectname, sizeof(sect64.sectname)) == NULL)
925 break;
926 if (m_data.GetU8(&offset, (uint8_t*)sect64.segname, sizeof(sect64.segname)) == NULL)
927 break;
928 sect64.addr = m_data.GetAddress(&offset);
929 sect64.size = m_data.GetAddress(&offset);
930
931 if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == NULL)
932 break;
933
934 // Keep a list of mach sections around in case we need to
935 // get at data that isn't stored in the abstracted Sections.
936 m_mach_sections.push_back (sect64);
937
938 ConstString section_name (sect64.sectname, std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname)));
939 if (!segment_name)
940 {
941 // We have a segment with no name so we need to conjure up
942 // segments that correspond to the section's segname if there
943 // isn't already such a section. If there is such a section,
944 // we resize the section so that it spans all sections.
945 // We also mark these sections as fake so address matches don't
946 // hit if they land in the gaps between the child sections.
947 segment_name.SetTrimmedCStringWithLength(sect64.segname, sizeof(sect64.segname));
948 segment_sp = m_sections_ap->FindSectionByName (segment_name);
949 if (segment_sp.get())
950 {
951 Section *segment = segment_sp.get();
952 // Grow the section size as needed.
953 const lldb::addr_t sect64_min_addr = sect64.addr;
954 const lldb::addr_t sect64_max_addr = sect64_min_addr + sect64.size;
955 const lldb::addr_t curr_seg_byte_size = segment->GetByteSize();
956 const lldb::addr_t curr_seg_min_addr = segment->GetFileAddress();
957 const lldb::addr_t curr_seg_max_addr = curr_seg_min_addr + curr_seg_byte_size;
958 if (sect64_min_addr >= curr_seg_min_addr)
959 {
960 const lldb::addr_t new_seg_byte_size = sect64_max_addr - curr_seg_min_addr;
961 // Only grow the section size if needed
962 if (new_seg_byte_size > curr_seg_byte_size)
963 segment->SetByteSize (new_seg_byte_size);
964 }
965 else
966 {
967 // We need to change the base address of the segment and
968 // adjust the child section offsets for all existing children.
969 const lldb::addr_t slide_amount = sect64_min_addr - curr_seg_min_addr;
970 segment->Slide(slide_amount, false);
Sean Callanan716a6642012-06-08 02:16:08 +0000971 segment->GetChildren().Slide(-slide_amount, false);
Chris Lattner24943d22010-06-08 16:52:24 +0000972 segment->SetByteSize (curr_seg_max_addr - sect64_min_addr);
973 }
Greg Clayton661825b2010-06-28 23:51:11 +0000974
975 // Grow the section size as needed.
976 if (sect64.offset)
977 {
978 const lldb::addr_t segment_min_file_offset = segment->GetFileOffset();
979 const lldb::addr_t segment_max_file_offset = segment_min_file_offset + segment->GetFileSize();
980
981 const lldb::addr_t section_min_file_offset = sect64.offset;
982 const lldb::addr_t section_max_file_offset = section_min_file_offset + sect64.size;
983 const lldb::addr_t new_file_offset = std::min (section_min_file_offset, segment_min_file_offset);
984 const lldb::addr_t new_file_size = std::max (section_max_file_offset, segment_max_file_offset) - new_file_offset;
985 segment->SetFileOffset (new_file_offset);
986 segment->SetFileSize (new_file_size);
987 }
Chris Lattner24943d22010-06-08 16:52:24 +0000988 }
989 else
990 {
991 // Create a fake section for the section's named segment
Greg Clayton3508c382012-02-24 01:59:29 +0000992 segment_sp.reset(new Section (segment_sp, // Parent section
993 module_sp, // Module to which this section belongs
994 ++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
995 segment_name, // Name of this section
996 eSectionTypeContainer, // This section is a container of other sections.
997 sect64.addr, // File VM address == addresses as they are found in the object file
998 sect64.size, // VM size in bytes of this section
999 sect64.offset, // Offset to the data for this section in the file
1000 sect64.offset ? sect64.size : 0, // Size in bytes of this section as found in the the file
1001 load_cmd.flags)); // Flags for this section
Chris Lattner24943d22010-06-08 16:52:24 +00001002 segment_sp->SetIsFake(true);
1003 m_sections_ap->AddSection(segment_sp);
Greg Clayton68ca8232011-01-25 02:58:48 +00001004 segment_sp->SetIsEncrypted (segment_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +00001005 }
1006 }
1007 assert (segment_sp.get());
1008
Greg Clayton1674b122010-07-21 22:12:05 +00001009 uint32_t mach_sect_type = sect64.flags & SectionFlagMaskSectionType;
Chris Lattner24943d22010-06-08 16:52:24 +00001010 static ConstString g_sect_name_objc_data ("__objc_data");
1011 static ConstString g_sect_name_objc_msgrefs ("__objc_msgrefs");
1012 static ConstString g_sect_name_objc_selrefs ("__objc_selrefs");
1013 static ConstString g_sect_name_objc_classrefs ("__objc_classrefs");
1014 static ConstString g_sect_name_objc_superrefs ("__objc_superrefs");
1015 static ConstString g_sect_name_objc_const ("__objc_const");
1016 static ConstString g_sect_name_objc_classlist ("__objc_classlist");
1017 static ConstString g_sect_name_cfstring ("__cfstring");
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001018
1019 static ConstString g_sect_name_dwarf_debug_abbrev ("__debug_abbrev");
1020 static ConstString g_sect_name_dwarf_debug_aranges ("__debug_aranges");
1021 static ConstString g_sect_name_dwarf_debug_frame ("__debug_frame");
1022 static ConstString g_sect_name_dwarf_debug_info ("__debug_info");
1023 static ConstString g_sect_name_dwarf_debug_line ("__debug_line");
1024 static ConstString g_sect_name_dwarf_debug_loc ("__debug_loc");
1025 static ConstString g_sect_name_dwarf_debug_macinfo ("__debug_macinfo");
1026 static ConstString g_sect_name_dwarf_debug_pubnames ("__debug_pubnames");
1027 static ConstString g_sect_name_dwarf_debug_pubtypes ("__debug_pubtypes");
1028 static ConstString g_sect_name_dwarf_debug_ranges ("__debug_ranges");
1029 static ConstString g_sect_name_dwarf_debug_str ("__debug_str");
Greg Claytonf6e3de22011-09-28 17:06:40 +00001030 static ConstString g_sect_name_dwarf_apple_names ("__apple_names");
1031 static ConstString g_sect_name_dwarf_apple_types ("__apple_types");
Greg Clayton00db2152011-10-04 22:41:51 +00001032 static ConstString g_sect_name_dwarf_apple_namespaces ("__apple_namespac");
Greg Clayton24a6bd92011-10-27 17:55:14 +00001033 static ConstString g_sect_name_dwarf_apple_objc ("__apple_objc");
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001034 static ConstString g_sect_name_eh_frame ("__eh_frame");
Greg Clayton3fed8b92010-10-08 00:21:05 +00001035 static ConstString g_sect_name_DATA ("__DATA");
1036 static ConstString g_sect_name_TEXT ("__TEXT");
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001037
Chris Lattner24943d22010-06-08 16:52:24 +00001038 SectionType sect_type = eSectionTypeOther;
1039
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001040 if (section_name == g_sect_name_dwarf_debug_abbrev)
1041 sect_type = eSectionTypeDWARFDebugAbbrev;
1042 else if (section_name == g_sect_name_dwarf_debug_aranges)
1043 sect_type = eSectionTypeDWARFDebugAranges;
1044 else if (section_name == g_sect_name_dwarf_debug_frame)
1045 sect_type = eSectionTypeDWARFDebugFrame;
1046 else if (section_name == g_sect_name_dwarf_debug_info)
1047 sect_type = eSectionTypeDWARFDebugInfo;
1048 else if (section_name == g_sect_name_dwarf_debug_line)
1049 sect_type = eSectionTypeDWARFDebugLine;
1050 else if (section_name == g_sect_name_dwarf_debug_loc)
1051 sect_type = eSectionTypeDWARFDebugLoc;
1052 else if (section_name == g_sect_name_dwarf_debug_macinfo)
1053 sect_type = eSectionTypeDWARFDebugMacInfo;
1054 else if (section_name == g_sect_name_dwarf_debug_pubnames)
1055 sect_type = eSectionTypeDWARFDebugPubNames;
1056 else if (section_name == g_sect_name_dwarf_debug_pubtypes)
1057 sect_type = eSectionTypeDWARFDebugPubTypes;
1058 else if (section_name == g_sect_name_dwarf_debug_ranges)
1059 sect_type = eSectionTypeDWARFDebugRanges;
1060 else if (section_name == g_sect_name_dwarf_debug_str)
1061 sect_type = eSectionTypeDWARFDebugStr;
Greg Claytonf6e3de22011-09-28 17:06:40 +00001062 else if (section_name == g_sect_name_dwarf_apple_names)
1063 sect_type = eSectionTypeDWARFAppleNames;
1064 else if (section_name == g_sect_name_dwarf_apple_types)
1065 sect_type = eSectionTypeDWARFAppleTypes;
Greg Clayton00db2152011-10-04 22:41:51 +00001066 else if (section_name == g_sect_name_dwarf_apple_namespaces)
1067 sect_type = eSectionTypeDWARFAppleNamespaces;
Greg Clayton24a6bd92011-10-27 17:55:14 +00001068 else if (section_name == g_sect_name_dwarf_apple_objc)
1069 sect_type = eSectionTypeDWARFAppleObjC;
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001070 else if (section_name == g_sect_name_objc_selrefs)
Chris Lattner24943d22010-06-08 16:52:24 +00001071 sect_type = eSectionTypeDataCStringPointers;
Chris Lattner24943d22010-06-08 16:52:24 +00001072 else if (section_name == g_sect_name_objc_msgrefs)
Chris Lattner24943d22010-06-08 16:52:24 +00001073 sect_type = eSectionTypeDataObjCMessageRefs;
Greg Clayton32a8c7e2010-07-21 22:54:26 +00001074 else if (section_name == g_sect_name_eh_frame)
1075 sect_type = eSectionTypeEHFrame;
1076 else if (section_name == g_sect_name_cfstring)
1077 sect_type = eSectionTypeDataObjCCFStrings;
Chris Lattner24943d22010-06-08 16:52:24 +00001078 else if (section_name == g_sect_name_objc_data ||
1079 section_name == g_sect_name_objc_classrefs ||
1080 section_name == g_sect_name_objc_superrefs ||
1081 section_name == g_sect_name_objc_const ||
1082 section_name == g_sect_name_objc_classlist)
1083 {
1084 sect_type = eSectionTypeDataPointers;
1085 }
Chris Lattner24943d22010-06-08 16:52:24 +00001086
1087 if (sect_type == eSectionTypeOther)
1088 {
1089 switch (mach_sect_type)
1090 {
1091 // TODO: categorize sections by other flags for regular sections
Greg Clayton3fed8b92010-10-08 00:21:05 +00001092 case SectionTypeRegular:
1093 if (segment_sp->GetName() == g_sect_name_TEXT)
Jason Molenda9badb6c2013-03-06 23:19:17 +00001094 sect_type = eSectionTypeCode;
Greg Clayton3fed8b92010-10-08 00:21:05 +00001095 else if (segment_sp->GetName() == g_sect_name_DATA)
Jason Molenda9badb6c2013-03-06 23:19:17 +00001096 sect_type = eSectionTypeData;
Greg Clayton3fed8b92010-10-08 00:21:05 +00001097 else
Jason Molenda9badb6c2013-03-06 23:19:17 +00001098 sect_type = eSectionTypeOther;
Greg Clayton3fed8b92010-10-08 00:21:05 +00001099 break;
Greg Clayton1674b122010-07-21 22:12:05 +00001100 case SectionTypeZeroFill: sect_type = eSectionTypeZeroFill; break;
1101 case SectionTypeCStringLiterals: sect_type = eSectionTypeDataCString; break; // section with only literal C strings
1102 case SectionType4ByteLiterals: sect_type = eSectionTypeData4; break; // section with only 4 byte literals
1103 case SectionType8ByteLiterals: sect_type = eSectionTypeData8; break; // section with only 8 byte literals
1104 case SectionTypeLiteralPointers: sect_type = eSectionTypeDataPointers; break; // section with only pointers to literals
1105 case SectionTypeNonLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only non-lazy symbol pointers
1106 case SectionTypeLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only lazy symbol pointers
1107 case SectionTypeSymbolStubs: sect_type = eSectionTypeCode; break; // section with only symbol stubs, byte size of stub in the reserved2 field
1108 case SectionTypeModuleInitFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for initialization
1109 case SectionTypeModuleTermFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination
1110 case SectionTypeCoalesced: sect_type = eSectionTypeOther; break;
1111 case SectionTypeZeroFillLarge: sect_type = eSectionTypeZeroFill; break;
1112 case SectionTypeInterposing: sect_type = eSectionTypeCode; break; // section with only pairs of function pointers for interposing
1113 case SectionType16ByteLiterals: sect_type = eSectionTypeData16; break; // section with only 16 byte literals
1114 case SectionTypeDTraceObjectFormat: sect_type = eSectionTypeDebug; break;
1115 case SectionTypeLazyDylibSymbolPointers: sect_type = eSectionTypeDataPointers; break;
Chris Lattner24943d22010-06-08 16:52:24 +00001116 default: break;
1117 }
1118 }
1119
Greg Clayton3508c382012-02-24 01:59:29 +00001120 SectionSP section_sp(new Section (segment_sp,
1121 module_sp,
1122 ++sectID,
1123 section_name,
1124 sect_type,
1125 sect64.addr - segment_sp->GetFileAddress(),
1126 sect64.size,
1127 sect64.offset,
1128 sect64.offset == 0 ? 0 : sect64.size,
1129 sect64.flags));
Greg Clayton68ca8232011-01-25 02:58:48 +00001130 // Set the section to be encrypted to match the segment
Jason Molenda9badb6c2013-03-06 23:19:17 +00001131
Greg Clayton6f7f8da2012-04-24 03:06:13 +00001132 bool section_is_encrypted = false;
1133 if (!segment_is_encrypted && load_cmd.filesize != 0)
1134 section_is_encrypted = encrypted_file_ranges.FindEntryThatContains(sect64.offset) != NULL;
Greg Clayton68ca8232011-01-25 02:58:48 +00001135
Greg Clayton6f7f8da2012-04-24 03:06:13 +00001136 section_sp->SetIsEncrypted (segment_is_encrypted || section_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +00001137 segment_sp->GetChildren().AddSection(section_sp);
1138
1139 if (segment_sp->IsFake())
1140 {
1141 segment_sp.reset();
1142 segment_name.Clear();
1143 }
1144 }
Greg Clayton0fa51242011-07-19 03:57:15 +00001145 if (segment_sp && m_header.filetype == HeaderFileTypeDSYM)
Chris Lattner24943d22010-06-08 16:52:24 +00001146 {
1147 if (first_segment_sectID <= sectID)
1148 {
1149 lldb::user_id_t sect_uid;
1150 for (sect_uid = first_segment_sectID; sect_uid <= sectID; ++sect_uid)
1151 {
1152 SectionSP curr_section_sp(segment_sp->GetChildren().FindSectionByID (sect_uid));
1153 SectionSP next_section_sp;
1154 if (sect_uid + 1 <= sectID)
1155 next_section_sp = segment_sp->GetChildren().FindSectionByID (sect_uid+1);
1156
1157 if (curr_section_sp.get())
1158 {
1159 if (curr_section_sp->GetByteSize() == 0)
1160 {
1161 if (next_section_sp.get() != NULL)
1162 curr_section_sp->SetByteSize ( next_section_sp->GetFileAddress() - curr_section_sp->GetFileAddress() );
1163 else
1164 curr_section_sp->SetByteSize ( load_cmd.vmsize );
1165 }
1166 }
1167 }
1168 }
1169 }
1170 }
1171 }
1172 }
Greg Clayton1674b122010-07-21 22:12:05 +00001173 else if (load_cmd.cmd == LoadCommandDynamicSymtabInfo)
Chris Lattner24943d22010-06-08 16:52:24 +00001174 {
1175 m_dysymtab.cmd = load_cmd.cmd;
1176 m_dysymtab.cmdsize = load_cmd.cmdsize;
1177 m_data.GetU32 (&offset, &m_dysymtab.ilocalsym, (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2);
1178 }
1179
1180 offset = load_cmd_offset + load_cmd.cmdsize;
1181 }
1182// if (dump_sections)
1183// {
1184// StreamFile s(stdout);
1185// m_sections_ap->Dump(&s, true);
1186// }
1187 return sectID; // Return the number of sections we registered with the module
1188}
1189
1190class MachSymtabSectionInfo
1191{
1192public:
1193
1194 MachSymtabSectionInfo (SectionList *section_list) :
1195 m_section_list (section_list),
1196 m_section_infos()
1197 {
1198 // Get the number of sections down to a depth of 1 to include
1199 // all segments and their sections, but no other sections that
1200 // may be added for debug map or
1201 m_section_infos.resize(section_list->GetNumSections(1));
1202 }
1203
1204
Greg Clayton3508c382012-02-24 01:59:29 +00001205 SectionSP
Chris Lattner24943d22010-06-08 16:52:24 +00001206 GetSection (uint8_t n_sect, addr_t file_addr)
1207 {
1208 if (n_sect == 0)
Greg Clayton3508c382012-02-24 01:59:29 +00001209 return SectionSP();
Chris Lattner24943d22010-06-08 16:52:24 +00001210 if (n_sect < m_section_infos.size())
1211 {
Greg Clayton3508c382012-02-24 01:59:29 +00001212 if (!m_section_infos[n_sect].section_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00001213 {
Greg Clayton3508c382012-02-24 01:59:29 +00001214 SectionSP section_sp (m_section_list->FindSectionByID (n_sect));
1215 m_section_infos[n_sect].section_sp = section_sp;
Sean Callananb386d822012-08-09 00:50:26 +00001216 if (section_sp)
Greg Clayton5638d2c2011-07-10 17:32:33 +00001217 {
Greg Clayton3508c382012-02-24 01:59:29 +00001218 m_section_infos[n_sect].vm_range.SetBaseAddress (section_sp->GetFileAddress());
1219 m_section_infos[n_sect].vm_range.SetByteSize (section_sp->GetByteSize());
Greg Clayton5638d2c2011-07-10 17:32:33 +00001220 }
1221 else
1222 {
Greg Claytondf6dc882012-01-05 03:57:59 +00001223 Host::SystemLog (Host::eSystemLogError, "error: unable to find section for section %u\n", n_sect);
Greg Clayton5638d2c2011-07-10 17:32:33 +00001224 }
Chris Lattner24943d22010-06-08 16:52:24 +00001225 }
1226 if (m_section_infos[n_sect].vm_range.Contains(file_addr))
Greg Clayton811b9c52011-08-26 20:01:35 +00001227 {
1228 // Symbol is in section.
Greg Clayton3508c382012-02-24 01:59:29 +00001229 return m_section_infos[n_sect].section_sp;
Greg Clayton811b9c52011-08-26 20:01:35 +00001230 }
1231 else if (m_section_infos[n_sect].vm_range.GetByteSize () == 0 &&
1232 m_section_infos[n_sect].vm_range.GetBaseAddress() == file_addr)
1233 {
1234 // Symbol is in section with zero size, but has the same start
1235 // address as the section. This can happen with linker symbols
1236 // (symbols that start with the letter 'l' or 'L'.
Greg Clayton3508c382012-02-24 01:59:29 +00001237 return m_section_infos[n_sect].section_sp;
Greg Clayton811b9c52011-08-26 20:01:35 +00001238 }
Chris Lattner24943d22010-06-08 16:52:24 +00001239 }
Greg Clayton3508c382012-02-24 01:59:29 +00001240 return m_section_list->FindSectionContainingFileAddress(file_addr);
Chris Lattner24943d22010-06-08 16:52:24 +00001241 }
1242
1243protected:
1244 struct SectionInfo
1245 {
1246 SectionInfo () :
1247 vm_range(),
Greg Clayton3508c382012-02-24 01:59:29 +00001248 section_sp ()
Chris Lattner24943d22010-06-08 16:52:24 +00001249 {
1250 }
1251
1252 VMRange vm_range;
Greg Clayton3508c382012-02-24 01:59:29 +00001253 SectionSP section_sp;
Chris Lattner24943d22010-06-08 16:52:24 +00001254 };
1255 SectionList *m_section_list;
1256 std::vector<SectionInfo> m_section_infos;
1257};
1258
Chris Lattner24943d22010-06-08 16:52:24 +00001259size_t
1260ObjectFileMachO::ParseSymtab (bool minimize)
1261{
1262 Timer scoped_timer(__PRETTY_FUNCTION__,
1263 "ObjectFileMachO::ParseSymtab () module = %s",
1264 m_file.GetFilename().AsCString(""));
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001265 ModuleSP module_sp (GetModule());
1266 if (!module_sp)
1267 return 0;
1268
1269 struct symtab_command symtab_load_command = { 0, 0, 0, 0, 0, 0 };
1270 struct linkedit_data_command function_starts_load_command = { 0, 0, 0, 0 };
1271 typedef AddressDataArray<lldb::addr_t, bool, 100> FunctionStarts;
1272 FunctionStarts function_starts;
Greg Clayton36da2aa2013-01-25 18:06:21 +00001273 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Chris Lattner24943d22010-06-08 16:52:24 +00001274 uint32_t i;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001275
Greg Clayton952e9dc2013-03-27 23:08:40 +00001276 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
Greg Clayton0fea0512011-12-30 00:32:24 +00001277
Chris Lattner24943d22010-06-08 16:52:24 +00001278 for (i=0; i<m_header.ncmds; ++i)
1279 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00001280 const lldb::offset_t cmd_offset = offset;
Chris Lattner24943d22010-06-08 16:52:24 +00001281 // Read in the load command and load command size
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001282 struct load_command lc;
1283 if (m_data.GetU32(&offset, &lc, 2) == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +00001284 break;
1285 // Watch for the symbol table load command
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001286 switch (lc.cmd)
Chris Lattner24943d22010-06-08 16:52:24 +00001287 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001288 case LoadCommandSymtab:
1289 symtab_load_command.cmd = lc.cmd;
1290 symtab_load_command.cmdsize = lc.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +00001291 // Read in the rest of the symtab load command
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001292 if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4) == 0) // fill in symoff, nsyms, stroff, strsize fields
1293 return 0;
1294 if (symtab_load_command.symoff == 0)
Chris Lattner24943d22010-06-08 16:52:24 +00001295 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001296 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001297 module_sp->LogMessage(log, "LC_SYMTAB.symoff == 0");
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001298 return 0;
1299 }
1300
1301 if (symtab_load_command.stroff == 0)
1302 {
1303 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001304 module_sp->LogMessage(log, "LC_SYMTAB.stroff == 0");
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001305 return 0;
1306 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00001307
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001308 if (symtab_load_command.nsyms == 0)
1309 {
1310 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001311 module_sp->LogMessage(log, "LC_SYMTAB.nsyms == 0");
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001312 return 0;
1313 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00001314
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001315 if (symtab_load_command.strsize == 0)
1316 {
1317 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001318 module_sp->LogMessage(log, "LC_SYMTAB.strsize == 0");
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001319 return 0;
1320 }
1321 break;
1322
1323 case LoadCommandFunctionStarts:
1324 function_starts_load_command.cmd = lc.cmd;
1325 function_starts_load_command.cmdsize = lc.cmdsize;
1326 if (m_data.GetU32(&offset, &function_starts_load_command.dataoff, 2) == NULL) // fill in symoff, nsyms, stroff, strsize fields
1327 bzero (&function_starts_load_command, sizeof(function_starts_load_command));
1328 break;
1329
1330 default:
1331 break;
1332 }
1333 offset = cmd_offset + lc.cmdsize;
1334 }
1335
1336 if (symtab_load_command.cmd)
1337 {
1338 Symtab *symtab = m_symtab_ap.get();
1339 SectionList *section_list = GetSectionList();
1340 if (section_list == NULL)
1341 return 0;
1342
1343 ProcessSP process_sp (m_process_wp.lock());
Greg Claytondd29b972012-05-18 23:20:01 +00001344 Process *process = process_sp.get();
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001345
Greg Clayton36da2aa2013-01-25 18:06:21 +00001346 const uint32_t addr_byte_size = m_data.GetAddressByteSize();
1347 const ByteOrder byte_order = m_data.GetByteOrder();
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001348 bool bit_width_32 = addr_byte_size == 4;
1349 const size_t nlist_byte_size = bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
1350
Greg Clayton36da2aa2013-01-25 18:06:21 +00001351 DataExtractor nlist_data (NULL, 0, byte_order, addr_byte_size);
1352 DataExtractor strtab_data (NULL, 0, byte_order, addr_byte_size);
1353 DataExtractor function_starts_data (NULL, 0, byte_order, addr_byte_size);
Jason Molenda0bf22382013-02-05 22:31:24 +00001354 DataExtractor indirect_symbol_index_data (NULL, 0, byte_order, addr_byte_size);
Jason Molenda9badb6c2013-03-06 23:19:17 +00001355
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001356 const addr_t nlist_data_byte_size = symtab_load_command.nsyms * nlist_byte_size;
1357 const addr_t strtab_data_byte_size = symtab_load_command.strsize;
Greg Claytondd29b972012-05-18 23:20:01 +00001358 addr_t strtab_addr = LLDB_INVALID_ADDRESS;
1359 if (process)
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001360 {
Greg Claytondd29b972012-05-18 23:20:01 +00001361 Target &target = process->GetTarget();
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001362 SectionSP linkedit_section_sp(section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
1363 // Reading mach file from memory in a process or core file...
1364
1365 if (linkedit_section_sp)
1366 {
1367 const addr_t linkedit_load_addr = linkedit_section_sp->GetLoadBaseAddress(&target);
1368 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
1369 const addr_t symoff_addr = linkedit_load_addr + symtab_load_command.symoff - linkedit_file_offset;
Greg Claytondd29b972012-05-18 23:20:01 +00001370 strtab_addr = linkedit_load_addr + symtab_load_command.stroff - linkedit_file_offset;
Greg Clayton29021d32012-04-18 05:19:20 +00001371
1372 bool data_was_read = false;
1373
1374#if defined (__APPLE__) && defined (__arm__)
1375 if (m_header.flags & 0x80000000u)
Greg Clayton0fea0512011-12-30 00:32:24 +00001376 {
Greg Clayton29021d32012-04-18 05:19:20 +00001377 // This mach-o memory file is in the dyld shared cache. If this
1378 // program is not remote and this is iOS, then this process will
1379 // share the same shared cache as the process we are debugging and
1380 // we can read the entire __LINKEDIT from the address space in this
1381 // process. This is a needed optimization that is used for local iOS
1382 // debugging only since all shared libraries in the shared cache do
1383 // not have corresponding files that exist in the file system of the
1384 // device. They have been combined into a single file. This means we
1385 // always have to load these files from memory. All of the symbol and
1386 // string tables from all of the __LINKEDIT sections from the shared
1387 // libraries in the shared cache have been merged into a single large
1388 // symbol and string table. Reading all of this symbol and string table
1389 // data across can slow down debug launch times, so we optimize this by
1390 // reading the memory for the __LINKEDIT section from this process.
Jason Molenda45c75502013-04-16 06:24:42 +00001391
1392 UUID lldb_shared_cache(GetLLDBSharedCacheUUID());
1393 UUID process_shared_cache(GetProcessSharedCacheUUID(process));
1394 bool use_lldb_cache = true;
1395 if (lldb_shared_cache.IsValid() && process_shared_cache.IsValid() && lldb_shared_cache != process_shared_cache)
1396 {
1397 use_lldb_cache = false;
1398 }
1399
Greg Clayton29021d32012-04-18 05:19:20 +00001400 PlatformSP platform_sp (target.GetPlatform());
Jason Molenda45c75502013-04-16 06:24:42 +00001401 if (platform_sp && platform_sp->IsHost() && use_lldb_cache)
Greg Clayton29021d32012-04-18 05:19:20 +00001402 {
1403 data_was_read = true;
1404 nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size, eByteOrderLittle);
Greg Claytondd29b972012-05-18 23:20:01 +00001405 strtab_data.SetData((void *)strtab_addr, strtab_data_byte_size, eByteOrderLittle);
Greg Clayton29021d32012-04-18 05:19:20 +00001406 if (function_starts_load_command.cmd)
1407 {
1408 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
1409 function_starts_data.SetData ((void *)func_start_addr, function_starts_load_command.datasize, eByteOrderLittle);
1410 }
1411 }
1412 }
1413#endif
1414
1415 if (!data_was_read)
1416 {
1417 DataBufferSP nlist_data_sp (ReadMemory (process_sp, symoff_addr, nlist_data_byte_size));
1418 if (nlist_data_sp)
1419 nlist_data.SetData (nlist_data_sp, 0, nlist_data_sp->GetByteSize());
Greg Claytondd29b972012-05-18 23:20:01 +00001420 //DataBufferSP strtab_data_sp (ReadMemory (process_sp, strtab_addr, strtab_data_byte_size));
1421 //if (strtab_data_sp)
1422 // strtab_data.SetData (strtab_data_sp, 0, strtab_data_sp->GetByteSize());
Jason Molenda0bf22382013-02-05 22:31:24 +00001423 if (m_dysymtab.nindirectsyms != 0)
1424 {
1425 const addr_t indirect_syms_addr = linkedit_load_addr + m_dysymtab.indirectsymoff - linkedit_file_offset;
1426 DataBufferSP indirect_syms_data_sp (ReadMemory (process_sp, indirect_syms_addr, m_dysymtab.nindirectsyms * 4));
1427 if (indirect_syms_data_sp)
1428 indirect_symbol_index_data.SetData (indirect_syms_data_sp, 0, indirect_syms_data_sp->GetByteSize());
1429 }
Greg Clayton29021d32012-04-18 05:19:20 +00001430 if (function_starts_load_command.cmd)
1431 {
1432 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
1433 DataBufferSP func_start_data_sp (ReadMemory (process_sp, func_start_addr, function_starts_load_command.datasize));
1434 if (func_start_data_sp)
1435 function_starts_data.SetData (func_start_data_sp, 0, func_start_data_sp->GetByteSize());
1436 }
Greg Clayton0fea0512011-12-30 00:32:24 +00001437 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001438 }
1439 }
1440 else
1441 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00001442 nlist_data.SetData (m_data,
1443 symtab_load_command.symoff,
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001444 nlist_data_byte_size);
1445 strtab_data.SetData (m_data,
Jason Molenda9badb6c2013-03-06 23:19:17 +00001446 symtab_load_command.stroff,
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001447 strtab_data_byte_size);
Jason Molenda0bf22382013-02-05 22:31:24 +00001448 if (m_dysymtab.nindirectsyms != 0)
1449 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00001450 indirect_symbol_index_data.SetData (m_data,
1451 m_dysymtab.indirectsymoff,
Jason Molenda0bf22382013-02-05 22:31:24 +00001452 m_dysymtab.nindirectsyms * 4);
1453 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001454 if (function_starts_load_command.cmd)
1455 {
1456 function_starts_data.SetData (m_data,
1457 function_starts_load_command.dataoff,
1458 function_starts_load_command.datasize);
1459 }
1460 }
Greg Clayton0fea0512011-12-30 00:32:24 +00001461
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001462 if (nlist_data.GetByteSize() == 0)
1463 {
1464 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001465 module_sp->LogMessage(log, "failed to read nlist data");
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001466 return 0;
1467 }
1468
1469
Greg Clayton3a5dc012012-05-25 17:04:00 +00001470 const bool have_strtab_data = strtab_data.GetByteSize() > 0;
1471 if (!have_strtab_data)
Greg Claytondd29b972012-05-18 23:20:01 +00001472 {
Greg Clayton3a5dc012012-05-25 17:04:00 +00001473 if (process)
1474 {
1475 if (strtab_addr == LLDB_INVALID_ADDRESS)
1476 {
1477 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001478 module_sp->LogMessage(log, "failed to locate the strtab in memory");
Greg Clayton3a5dc012012-05-25 17:04:00 +00001479 return 0;
1480 }
1481 }
1482 else
Greg Claytondd29b972012-05-18 23:20:01 +00001483 {
1484 if (log)
Greg Clayton952e9dc2013-03-27 23:08:40 +00001485 module_sp->LogMessage(log, "failed to read strtab data");
Greg Claytondd29b972012-05-18 23:20:01 +00001486 return 0;
1487 }
1488 }
Greg Claytondd29b972012-05-18 23:20:01 +00001489
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001490 const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT();
1491 const ConstString &g_segment_name_DATA = GetSegmentNameDATA();
1492 const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC();
1493 const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame();
1494 SectionSP text_section_sp(section_list->FindSectionByName(g_segment_name_TEXT));
1495 SectionSP data_section_sp(section_list->FindSectionByName(g_segment_name_DATA));
1496 SectionSP objc_section_sp(section_list->FindSectionByName(g_segment_name_OBJC));
1497 SectionSP eh_frame_section_sp;
1498 if (text_section_sp.get())
1499 eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName (g_section_name_eh_frame);
1500 else
1501 eh_frame_section_sp = section_list->FindSectionByName (g_section_name_eh_frame);
1502
Greg Claytond2653c22012-03-14 01:53:24 +00001503 const bool is_arm = (m_header.cputype == llvm::MachO::CPUTypeARM);
Jason Molendad7938392013-03-21 03:36:01 +00001504
1505 // lldb works best if it knows the start addresss of all functions in a module.
1506 // Linker symbols or debug info are normally the best source of information for start addr / size but
1507 // they may be stripped in a released binary.
Jason Molenda2120aef2013-04-16 00:18:44 +00001508 // Two additional sources of information exist in Mach-O binaries:
Jason Molendad7938392013-03-21 03:36:01 +00001509 // LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each function's start address in the
1510 // binary, relative to the text section.
1511 // eh_frame - the eh_frame FDEs have the start addr & size of each function
1512 // LC_FUNCTION_STARTS is the fastest source to read in, and is present on all modern binaries.
1513 // Binaries built to run on older releases may need to use eh_frame information.
1514
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001515 if (text_section_sp && function_starts_data.GetByteSize())
1516 {
1517 FunctionStarts::Entry function_start_entry;
1518 function_start_entry.data = false;
Greg Clayton36da2aa2013-01-25 18:06:21 +00001519 lldb::offset_t function_start_offset = 0;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001520 function_start_entry.addr = text_section_sp->GetFileAddress();
1521 uint64_t delta;
1522 while ((delta = function_starts_data.GetULEB128(&function_start_offset)) > 0)
1523 {
1524 // Now append the current entry
1525 function_start_entry.addr += delta;
1526 function_starts.Append(function_start_entry);
1527 }
Jason Molenda2120aef2013-04-16 00:18:44 +00001528 }
Jason Molendad7938392013-03-21 03:36:01 +00001529 else
1530 {
Jason Molenda825a96a2013-03-22 00:38:45 +00001531 // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the load command claiming an eh_frame
1532 // but it doesn't actually have the eh_frame content. And if we have a dSYM, we don't need to do any
1533 // of this fill-in-the-missing-symbols works anyway - the debug info should give us all the functions in
1534 // the module.
1535 if (text_section_sp.get() && eh_frame_section_sp.get() && m_type != eTypeDebugInfo)
Jason Molendad7938392013-03-21 03:36:01 +00001536 {
1537 DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp, eRegisterKindGCC, true);
1538 DWARFCallFrameInfo::FunctionAddressAndSizeVector functions;
1539 eh_frame.GetFunctionAddressAndSizeVector (functions);
1540 addr_t text_base_addr = text_section_sp->GetFileAddress();
1541 size_t count = functions.GetSize();
1542 for (size_t i = 0; i < count; ++i)
1543 {
1544 const DWARFCallFrameInfo::FunctionAddressAndSizeVector::Entry *func = functions.GetEntryAtIndex (i);
1545 if (func)
1546 {
1547 FunctionStarts::Entry function_start_entry;
1548 function_start_entry.addr = func->base - text_base_addr;
1549 function_starts.Append(function_start_entry);
1550 }
1551 }
1552 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001553 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00001554
Greg Clayton36da2aa2013-01-25 18:06:21 +00001555 const size_t function_starts_count = function_starts.GetSize();
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001556
Greg Clayton36da2aa2013-01-25 18:06:21 +00001557 const user_id_t TEXT_eh_frame_sectID = eh_frame_section_sp.get() ? eh_frame_section_sp->GetID() : NListSectionNoSection;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001558
Greg Clayton36da2aa2013-01-25 18:06:21 +00001559 lldb::offset_t nlist_data_offset = 0;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001560
1561 uint32_t N_SO_index = UINT32_MAX;
1562
1563 MachSymtabSectionInfo section_info (section_list);
1564 std::vector<uint32_t> N_FUN_indexes;
1565 std::vector<uint32_t> N_NSYM_indexes;
1566 std::vector<uint32_t> N_INCL_indexes;
1567 std::vector<uint32_t> N_BRAC_indexes;
1568 std::vector<uint32_t> N_COMM_indexes;
1569 typedef std::map <uint64_t, uint32_t> ValueToSymbolIndexMap;
1570 typedef std::map <uint32_t, uint32_t> NListIndexToSymbolIndexMap;
1571 ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
1572 ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
1573 // Any symbols that get merged into another will get an entry
1574 // in this map so we know
1575 NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
1576 uint32_t nlist_idx = 0;
1577 Symbol *symbol_ptr = NULL;
1578
1579 uint32_t sym_idx = 0;
Jason Molendab62abd52012-06-21 01:51:02 +00001580 Symbol *sym = NULL;
Greg Clayton36da2aa2013-01-25 18:06:21 +00001581 size_t num_syms = 0;
Greg Claytondd29b972012-05-18 23:20:01 +00001582 std::string memory_symbol_name;
Jason Molendab62abd52012-06-21 01:51:02 +00001583 uint32_t unmapped_local_symbols_found = 0;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00001584
Jason Molendab62abd52012-06-21 01:51:02 +00001585#if defined (__APPLE__) && defined (__arm__)
1586
1587 // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been optimized by moving LOCAL
1588 // symbols out of the memory mapped portion of the DSC. The symbol information has all been retained,
1589 // but it isn't available in the normal nlist data. However, there *are* duplicate entries of *some*
1590 // LOCAL symbols in the normal nlist data. To handle this situation correctly, we must first attempt
1591 // to parse any DSC unmapped symbol information. If we find any, we set a flag that tells the normal
1592 // nlist parser to ignore all LOCAL symbols.
1593
1594 if (m_header.flags & 0x80000000u)
1595 {
1596 // Before we can start mapping the DSC, we need to make certain the target process is actually
1597 // using the cache we can find.
1598
Jason Molendab62abd52012-06-21 01:51:02 +00001599 // Next we need to determine the correct path for the dyld shared cache.
1600
1601 ArchSpec header_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
1602 char dsc_path[PATH_MAX];
1603
1604 snprintf(dsc_path, sizeof(dsc_path), "%s%s%s",
Jason Molenda9badb6c2013-03-06 23:19:17 +00001605 "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR */
1606 "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
Jason Molendab62abd52012-06-21 01:51:02 +00001607 header_arch.GetArchitectureName());
1608
1609 FileSpec dsc_filespec(dsc_path, false);
1610
1611 // We need definitions of two structures in the on-disk DSC, copy them here manually
Jason Molenda2120aef2013-04-16 00:18:44 +00001612 struct lldb_copy_dyld_cache_header_v0
Greg Claytonab77dcb2012-09-05 22:30:51 +00001613 {
Jason Molenda2120aef2013-04-16 00:18:44 +00001614 char magic[16]; // e.g. "dyld_v0 i386", "dyld_v1 armv7", etc.
1615 uint32_t mappingOffset; // file offset to first dyld_cache_mapping_info
1616 uint32_t mappingCount; // number of dyld_cache_mapping_info entries
Jason Molenda9badb6c2013-03-06 23:19:17 +00001617 uint32_t imagesOffset;
1618 uint32_t imagesCount;
1619 uint64_t dyldBaseAddress;
1620 uint64_t codeSignatureOffset;
1621 uint64_t codeSignatureSize;
1622 uint64_t slideInfoOffset;
1623 uint64_t slideInfoSize;
Jason Molenda2120aef2013-04-16 00:18:44 +00001624 uint64_t localSymbolsOffset; // file offset of where local symbols are stored
1625 uint64_t localSymbolsSize; // size of local symbols information
1626 };
1627 struct lldb_copy_dyld_cache_header_v1
1628 {
1629 char magic[16]; // e.g. "dyld_v0 i386", "dyld_v1 armv7", etc.
1630 uint32_t mappingOffset; // file offset to first dyld_cache_mapping_info
1631 uint32_t mappingCount; // number of dyld_cache_mapping_info entries
1632 uint32_t imagesOffset;
1633 uint32_t imagesCount;
1634 uint64_t dyldBaseAddress;
1635 uint64_t codeSignatureOffset;
1636 uint64_t codeSignatureSize;
1637 uint64_t slideInfoOffset;
1638 uint64_t slideInfoSize;
Jason Molenda9badb6c2013-03-06 23:19:17 +00001639 uint64_t localSymbolsOffset;
1640 uint64_t localSymbolsSize;
Jason Molenda2120aef2013-04-16 00:18:44 +00001641 uint8_t uuid[16]; // v1 and above, also recorded in dyld_all_image_infos v13 and later
Greg Claytonab77dcb2012-09-05 22:30:51 +00001642 };
Jason Molenda6bcabae2013-03-06 23:17:36 +00001643
Jason Molenda2120aef2013-04-16 00:18:44 +00001644 struct lldb_copy_dyld_cache_mapping_info
1645 {
1646 uint64_t address;
1647 uint64_t size;
1648 uint64_t fileOffset;
1649 uint32_t maxProt;
1650 uint32_t initProt;
1651 };
Jason Molenda6bcabae2013-03-06 23:17:36 +00001652
Greg Claytonab77dcb2012-09-05 22:30:51 +00001653 struct lldb_copy_dyld_cache_local_symbols_info
1654 {
Jason Molenda2120aef2013-04-16 00:18:44 +00001655 uint32_t nlistOffset;
1656 uint32_t nlistCount;
1657 uint32_t stringsOffset;
1658 uint32_t stringsSize;
1659 uint32_t entriesOffset;
1660 uint32_t entriesCount;
Greg Claytonab77dcb2012-09-05 22:30:51 +00001661 };
1662 struct lldb_copy_dyld_cache_local_symbols_entry
1663 {
Jason Molenda2120aef2013-04-16 00:18:44 +00001664 uint32_t dylibOffset;
1665 uint32_t nlistStartIndex;
1666 uint32_t nlistCount;
Greg Claytonab77dcb2012-09-05 22:30:51 +00001667 };
Jason Molendab62abd52012-06-21 01:51:02 +00001668
Jason Molendafd3b35d2012-06-22 03:28:35 +00001669 /* The dyld_cache_header has a pointer to the dyld_cache_local_symbols_info structure (localSymbolsOffset).
1670 The dyld_cache_local_symbols_info structure gives us three things:
1671 1. The start and count of the nlist records in the dyld_shared_cache file
1672 2. The start and size of the strings for these nlist records
1673 3. The start and count of dyld_cache_local_symbols_entry entries
1674
1675 There is one dyld_cache_local_symbols_entry per dylib/framework in the dyld shared cache.
1676 The "dylibOffset" field is the Mach-O header of this dylib/framework in the dyld shared cache.
Jason Molenda9badb6c2013-03-06 23:19:17 +00001677 The dyld_cache_local_symbols_entry also lists the start of this dylib/framework's nlist records
Jason Molendafd3b35d2012-06-22 03:28:35 +00001678 and the count of how many nlist records there are for this dylib/framework.
1679 */
1680
Jason Molendab62abd52012-06-21 01:51:02 +00001681 // Process the dsc header to find the unmapped symbols
1682 //
1683 // Save some VM space, do not map the entire cache in one shot.
1684
Jason Molenda6bcabae2013-03-06 23:17:36 +00001685 DataBufferSP dsc_data_sp;
1686 dsc_data_sp = dsc_filespec.MemoryMapFileContents(0, sizeof(struct lldb_copy_dyld_cache_header_v1));
1687
1688 if (dsc_data_sp)
Jason Molendab62abd52012-06-21 01:51:02 +00001689 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00001690 DataExtractor dsc_header_data(dsc_data_sp, byte_order, addr_byte_size);
Jason Molendab62abd52012-06-21 01:51:02 +00001691
Jason Molenda6bcabae2013-03-06 23:17:36 +00001692 char version_str[17];
1693 int version = -1;
1694 lldb::offset_t offset = 0;
1695 memcpy (version_str, dsc_header_data.GetData (&offset, 16), 16);
1696 version_str[16] = '\0';
1697 if (strncmp (version_str, "dyld_v", 6) == 0 && isdigit (version_str[6]))
1698 {
1699 int v;
1700 if (::sscanf (version_str + 6, "%d", &v) == 1)
1701 {
1702 version = v;
1703 }
1704 }
1705
Jason Molenda45c75502013-04-16 06:24:42 +00001706 UUID dsc_uuid;
1707 if (version >= 1)
1708 {
1709 offset = offsetof (struct lldb_copy_dyld_cache_header_v1, uuid);
1710 uint8_t uuid_bytes[sizeof (uuid_t)];
1711 memcpy (uuid_bytes, dsc_header_data.GetData (&offset, sizeof (uuid_t)), sizeof (uuid_t));
1712 dsc_uuid.SetBytes (uuid_bytes);
1713 }
1714
1715 bool uuid_match = true;
1716 if (dsc_uuid.IsValid() && process)
1717 {
1718 UUID shared_cache_uuid(GetProcessSharedCacheUUID(process));
1719
1720 if (shared_cache_uuid.IsValid() && dsc_uuid != shared_cache_uuid)
1721 {
1722 // The on-disk dyld_shared_cache file is not the same as the one in this
1723 // process' memory, don't use it.
1724 uuid_match = false;
1725 }
1726 }
1727
Jason Molenda9badb6c2013-03-06 23:19:17 +00001728 offset = offsetof (struct lldb_copy_dyld_cache_header_v1, mappingOffset);
Jason Molenda6bcabae2013-03-06 23:17:36 +00001729
Jason Molendab62abd52012-06-21 01:51:02 +00001730 uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
1731
1732 // If the mappingOffset points to a location inside the header, we've
1733 // opened an old dyld shared cache, and should not proceed further.
Jason Molenda45c75502013-04-16 06:24:42 +00001734 if (uuid_match && mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header_v0))
Jason Molendab62abd52012-06-21 01:51:02 +00001735 {
1736
Jason Molenda6bcabae2013-03-06 23:17:36 +00001737 DataBufferSP dsc_mapping_info_data_sp = dsc_filespec.MemoryMapFileContents(mappingOffset, sizeof (struct lldb_copy_dyld_cache_mapping_info));
1738 DataExtractor dsc_mapping_info_data(dsc_mapping_info_data_sp, byte_order, addr_byte_size);
1739 offset = 0;
1740
1741 // The File addresses (from the in-memory Mach-O load commands) for the shared libraries
1742 // in the shared library cache need to be adjusted by an offset to match up with the
1743 // dylibOffset identifying field in the dyld_cache_local_symbol_entry's. This offset is
1744 // recorded in mapping_offset_value.
1745 const uint64_t mapping_offset_value = dsc_mapping_info_data.GetU64(&offset);
1746
1747 offset = offsetof (struct lldb_copy_dyld_cache_header_v1, localSymbolsOffset);
Jason Molendab62abd52012-06-21 01:51:02 +00001748 uint64_t localSymbolsOffset = dsc_header_data.GetU64(&offset);
1749 uint64_t localSymbolsSize = dsc_header_data.GetU64(&offset);
1750
Jason Molenda9badb6c2013-03-06 23:19:17 +00001751 if (localSymbolsOffset && localSymbolsSize)
Jason Molendab62abd52012-06-21 01:51:02 +00001752 {
1753 // Map the local symbols
Jason Molenda9badb6c2013-03-06 23:19:17 +00001754 if (DataBufferSP dsc_local_symbols_data_sp = dsc_filespec.MemoryMapFileContents(localSymbolsOffset, localSymbolsSize))
Jason Molendab62abd52012-06-21 01:51:02 +00001755 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00001756 DataExtractor dsc_local_symbols_data(dsc_local_symbols_data_sp, byte_order, addr_byte_size);
Jason Molendab62abd52012-06-21 01:51:02 +00001757
1758 offset = 0;
1759
1760 // Read the local_symbols_infos struct in one shot
1761 struct lldb_copy_dyld_cache_local_symbols_info local_symbols_info;
1762 dsc_local_symbols_data.GetU32(&offset, &local_symbols_info.nlistOffset, 6);
1763
Jason Molendab62abd52012-06-21 01:51:02 +00001764 SectionSP text_section_sp(section_list->FindSectionByName(GetSegmentNameTEXT()));
1765
Jason Molenda6bcabae2013-03-06 23:17:36 +00001766 uint32_t header_file_offset = (text_section_sp->GetFileAddress() - mapping_offset_value);
Jason Molendab62abd52012-06-21 01:51:02 +00001767
1768 offset = local_symbols_info.entriesOffset;
1769 for (uint32_t entry_index = 0; entry_index < local_symbols_info.entriesCount; entry_index++)
1770 {
1771 struct lldb_copy_dyld_cache_local_symbols_entry local_symbols_entry;
1772 local_symbols_entry.dylibOffset = dsc_local_symbols_data.GetU32(&offset);
1773 local_symbols_entry.nlistStartIndex = dsc_local_symbols_data.GetU32(&offset);
1774 local_symbols_entry.nlistCount = dsc_local_symbols_data.GetU32(&offset);
1775
Jason Molenda9badb6c2013-03-06 23:19:17 +00001776 if (header_file_offset == local_symbols_entry.dylibOffset)
Jason Molendab62abd52012-06-21 01:51:02 +00001777 {
1778 unmapped_local_symbols_found = local_symbols_entry.nlistCount;
1779
1780 // The normal nlist code cannot correctly size the Symbols array, we need to allocate it here.
1781 sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms + unmapped_local_symbols_found - m_dysymtab.nlocalsym);
1782 num_syms = symtab->GetNumSymbols();
1783
1784 nlist_data_offset = local_symbols_info.nlistOffset + (nlist_byte_size * local_symbols_entry.nlistStartIndex);
1785 uint32_t string_table_offset = local_symbols_info.stringsOffset;
1786
Jason Molenda9badb6c2013-03-06 23:19:17 +00001787 for (uint32_t nlist_index = 0; nlist_index < local_symbols_entry.nlistCount; nlist_index++)
Jason Molendab62abd52012-06-21 01:51:02 +00001788 {
1789 /////////////////////////////
1790 {
1791 struct nlist_64 nlist;
1792 if (!dsc_local_symbols_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
1793 break;
1794
1795 nlist.n_strx = dsc_local_symbols_data.GetU32_unchecked(&nlist_data_offset);
1796 nlist.n_type = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
1797 nlist.n_sect = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
1798 nlist.n_desc = dsc_local_symbols_data.GetU16_unchecked (&nlist_data_offset);
1799 nlist.n_value = dsc_local_symbols_data.GetAddress_unchecked (&nlist_data_offset);
1800
1801 SymbolType type = eSymbolTypeInvalid;
1802 const char *symbol_name = dsc_local_symbols_data.PeekCStr(string_table_offset + nlist.n_strx);
1803
1804 if (symbol_name == NULL)
1805 {
1806 // No symbol should be NULL, even the symbols with no
1807 // string values should have an offset zero which points
1808 // to an empty C-string
1809 Host::SystemLog (Host::eSystemLogError,
1810 "error: DSC unmapped local symbol[%u] has invalid string table offset 0x%x in %s/%s, ignoring symbol\n",
1811 entry_index,
1812 nlist.n_strx,
1813 module_sp->GetFileSpec().GetDirectory().GetCString(),
1814 module_sp->GetFileSpec().GetFilename().GetCString());
1815 continue;
1816 }
1817 if (symbol_name[0] == '\0')
1818 symbol_name = NULL;
1819
1820 const char *symbol_name_non_abi_mangled = NULL;
1821
1822 SectionSP symbol_section;
1823 uint32_t symbol_byte_size = 0;
1824 bool add_nlist = true;
1825 bool is_debug = ((nlist.n_type & NlistMaskStab) != 0);
Greg Clayton01e6a582012-11-27 01:52:16 +00001826 bool demangled_is_synthesized = false;
Jason Molendab62abd52012-06-21 01:51:02 +00001827
1828 assert (sym_idx < num_syms);
1829
1830 sym[sym_idx].SetDebug (is_debug);
1831
1832 if (is_debug)
1833 {
1834 switch (nlist.n_type)
1835 {
1836 case StabGlobalSymbol:
1837 // N_GSYM -- global symbol: name,,NO_SECT,type,0
1838 // Sometimes the N_GSYM value contains the address.
1839
1840 // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data. They
1841 // have the same address, but we want to ensure that we always find only the real symbol,
1842 // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
1843 // symbol type. This is a temporary hack to make sure the ObjectiveC symbols get treated
1844 // correctly. To do this right, we should coalesce all the GSYM & global symbols that have the
1845 // same address.
1846
1847 if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O'
1848 && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
1849 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
1850 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
1851 add_nlist = false;
1852 else
1853 {
1854 sym[sym_idx].SetExternal(true);
1855 if (nlist.n_value != 0)
1856 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1857 type = eSymbolTypeData;
1858 }
1859 break;
1860
1861 case StabFunctionName:
1862 // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0
1863 type = eSymbolTypeCompiler;
1864 break;
1865
1866 case StabFunction:
1867 // N_FUN -- procedure: name,,n_sect,linenumber,address
1868 if (symbol_name)
1869 {
1870 type = eSymbolTypeCode;
1871 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1872
1873 N_FUN_addr_to_sym_idx[nlist.n_value] = sym_idx;
1874 // We use the current number of symbols in the symbol table in lieu of
1875 // using nlist_idx in case we ever start trimming entries out
1876 N_FUN_indexes.push_back(sym_idx);
1877 }
1878 else
1879 {
1880 type = eSymbolTypeCompiler;
1881
1882 if ( !N_FUN_indexes.empty() )
1883 {
1884 // Copy the size of the function into the original STAB entry so we don't have
1885 // to hunt for it later
1886 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
1887 N_FUN_indexes.pop_back();
1888 // We don't really need the end function STAB as it contains the size which
1889 // we already placed with the original symbol, so don't add it if we want a
1890 // minimal symbol table
1891 if (minimize)
1892 add_nlist = false;
1893 }
1894 }
1895 break;
1896
1897 case StabStaticSymbol:
1898 // N_STSYM -- static symbol: name,,n_sect,type,address
1899 N_STSYM_addr_to_sym_idx[nlist.n_value] = sym_idx;
1900 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1901 type = eSymbolTypeData;
1902 break;
1903
1904 case StabLocalCommon:
1905 // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address
1906 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1907 type = eSymbolTypeCommonBlock;
1908 break;
1909
1910 case StabBeginSymbol:
1911 // N_BNSYM
1912 // We use the current number of symbols in the symbol table in lieu of
1913 // using nlist_idx in case we ever start trimming entries out
1914 if (minimize)
1915 {
1916 // Skip these if we want minimal symbol tables
1917 add_nlist = false;
1918 }
1919 else
1920 {
1921 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1922 N_NSYM_indexes.push_back(sym_idx);
1923 type = eSymbolTypeScopeBegin;
1924 }
1925 break;
1926
1927 case StabEndSymbol:
1928 // N_ENSYM
1929 // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
1930 // so that we can always skip the entire symbol if we need to navigate
1931 // more quickly at the source level when parsing STABS
1932 if (minimize)
1933 {
1934 // Skip these if we want minimal symbol tables
1935 add_nlist = false;
1936 }
1937 else
1938 {
1939 if ( !N_NSYM_indexes.empty() )
1940 {
1941 symbol_ptr = symtab->SymbolAtIndex(N_NSYM_indexes.back());
1942 symbol_ptr->SetByteSize(sym_idx + 1);
1943 symbol_ptr->SetSizeIsSibling(true);
1944 N_NSYM_indexes.pop_back();
1945 }
1946 type = eSymbolTypeScopeEnd;
1947 }
1948 break;
1949
1950
1951 case StabSourceFileOptions:
1952 // N_OPT - emitted with gcc2_compiled and in gcc source
1953 type = eSymbolTypeCompiler;
1954 break;
1955
1956 case StabRegisterSymbol:
1957 // N_RSYM - register sym: name,,NO_SECT,type,register
1958 type = eSymbolTypeVariable;
1959 break;
1960
1961 case StabSourceLine:
1962 // N_SLINE - src line: 0,,n_sect,linenumber,address
1963 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1964 type = eSymbolTypeLineEntry;
1965 break;
1966
1967 case StabStructureType:
1968 // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset
1969 type = eSymbolTypeVariableType;
1970 break;
1971
1972 case StabSourceFileName:
1973 // N_SO - source file name
1974 type = eSymbolTypeSourceFile;
1975 if (symbol_name == NULL)
1976 {
1977 if (minimize)
1978 add_nlist = false;
1979 if (N_SO_index != UINT32_MAX)
1980 {
1981 // Set the size of the N_SO to the terminating index of this N_SO
1982 // so that we can always skip the entire N_SO if we need to navigate
1983 // more quickly at the source level when parsing STABS
1984 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
1985 symbol_ptr->SetByteSize(sym_idx + (minimize ? 0 : 1));
1986 symbol_ptr->SetSizeIsSibling(true);
1987 }
1988 N_NSYM_indexes.clear();
1989 N_INCL_indexes.clear();
1990 N_BRAC_indexes.clear();
1991 N_COMM_indexes.clear();
1992 N_FUN_indexes.clear();
1993 N_SO_index = UINT32_MAX;
1994 }
1995 else
1996 {
1997 // We use the current number of symbols in the symbol table in lieu of
1998 // using nlist_idx in case we ever start trimming entries out
1999 const bool N_SO_has_full_path = symbol_name[0] == '/';
2000 if (N_SO_has_full_path)
2001 {
2002 if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2003 {
2004 // We have two consecutive N_SO entries where the first contains a directory
2005 // and the second contains a full path.
Jason Molenda292cca82012-07-20 03:35:44 +00002006 sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
Jason Molendab62abd52012-06-21 01:51:02 +00002007 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2008 add_nlist = false;
2009 }
2010 else
2011 {
2012 // This is the first entry in a N_SO that contains a directory or
2013 // a full path to the source file
2014 N_SO_index = sym_idx;
2015 }
2016 }
2017 else if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2018 {
2019 // This is usually the second N_SO entry that contains just the filename,
2020 // so here we combine it with the first one if we are minimizing the symbol table
2021 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
2022 if (so_path && so_path[0])
2023 {
2024 std::string full_so_path (so_path);
Greg Clayton4df2b7f2012-09-07 20:29:13 +00002025 const size_t double_slash_pos = full_so_path.find("//");
2026 if (double_slash_pos != std::string::npos)
2027 {
2028 // The linker has been generating bad N_SO entries with doubled up paths
2029 // in the format "%s%s" where the first stirng in the DW_AT_comp_dir,
2030 // and the second is the directory for the source file so you end up with
2031 // a path that looks like "/tmp/src//tmp/src/"
2032 FileSpec so_dir(so_path, false);
2033 if (!so_dir.Exists())
2034 {
2035 so_dir.SetFile(&full_so_path[double_slash_pos + 1], false);
2036 if (so_dir.Exists())
2037 {
2038 // Trim off the incorrect path
2039 full_so_path.erase(0, double_slash_pos + 1);
2040 }
2041 }
2042 }
Jason Molendab62abd52012-06-21 01:51:02 +00002043 if (*full_so_path.rbegin() != '/')
2044 full_so_path += '/';
2045 full_so_path += symbol_name;
Jason Molenda292cca82012-07-20 03:35:44 +00002046 sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
Jason Molendab62abd52012-06-21 01:51:02 +00002047 add_nlist = false;
2048 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2049 }
2050 }
Greg Claytonab77dcb2012-09-05 22:30:51 +00002051 else
2052 {
2053 // This could be a relative path to a N_SO
2054 N_SO_index = sym_idx;
2055 }
Jason Molendab62abd52012-06-21 01:51:02 +00002056 }
Jason Molendab62abd52012-06-21 01:51:02 +00002057 break;
2058
2059 case StabObjectFileName:
2060 // N_OSO - object file name: name,,0,0,st_mtime
2061 type = eSymbolTypeObjectFile;
2062 break;
2063
2064 case StabLocalSymbol:
2065 // N_LSYM - local sym: name,,NO_SECT,type,offset
2066 type = eSymbolTypeLocal;
2067 break;
2068
2069 //----------------------------------------------------------------------
2070 // INCL scopes
2071 //----------------------------------------------------------------------
2072 case StabBeginIncludeFileName:
2073 // N_BINCL - include file beginning: name,,NO_SECT,0,sum
2074 // We use the current number of symbols in the symbol table in lieu of
2075 // using nlist_idx in case we ever start trimming entries out
2076 N_INCL_indexes.push_back(sym_idx);
2077 type = eSymbolTypeScopeBegin;
2078 break;
2079
2080 case StabEndIncludeFile:
2081 // N_EINCL - include file end: name,,NO_SECT,0,0
2082 // Set the size of the N_BINCL to the terminating index of this N_EINCL
2083 // so that we can always skip the entire symbol if we need to navigate
2084 // more quickly at the source level when parsing STABS
2085 if ( !N_INCL_indexes.empty() )
2086 {
2087 symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
2088 symbol_ptr->SetByteSize(sym_idx + 1);
2089 symbol_ptr->SetSizeIsSibling(true);
2090 N_INCL_indexes.pop_back();
2091 }
2092 type = eSymbolTypeScopeEnd;
2093 break;
2094
2095 case StabIncludeFileName:
2096 // N_SOL - #included file name: name,,n_sect,0,address
2097 type = eSymbolTypeHeaderFile;
2098
2099 // We currently don't use the header files on darwin
2100 if (minimize)
2101 add_nlist = false;
2102 break;
2103
2104 case StabCompilerParameters:
2105 // N_PARAMS - compiler parameters: name,,NO_SECT,0,0
2106 type = eSymbolTypeCompiler;
2107 break;
2108
2109 case StabCompilerVersion:
2110 // N_VERSION - compiler version: name,,NO_SECT,0,0
2111 type = eSymbolTypeCompiler;
2112 break;
2113
2114 case StabCompilerOptLevel:
2115 // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0
2116 type = eSymbolTypeCompiler;
2117 break;
2118
2119 case StabParameter:
2120 // N_PSYM - parameter: name,,NO_SECT,type,offset
2121 type = eSymbolTypeVariable;
2122 break;
2123
2124 case StabAlternateEntry:
2125 // N_ENTRY - alternate entry: name,,n_sect,linenumber,address
2126 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2127 type = eSymbolTypeLineEntry;
2128 break;
2129
2130 //----------------------------------------------------------------------
2131 // Left and Right Braces
2132 //----------------------------------------------------------------------
2133 case StabLeftBracket:
2134 // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address
2135 // We use the current number of symbols in the symbol table in lieu of
2136 // using nlist_idx in case we ever start trimming entries out
2137 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2138 N_BRAC_indexes.push_back(sym_idx);
2139 type = eSymbolTypeScopeBegin;
2140 break;
2141
2142 case StabRightBracket:
2143 // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address
2144 // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
2145 // so that we can always skip the entire symbol if we need to navigate
2146 // more quickly at the source level when parsing STABS
2147 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2148 if ( !N_BRAC_indexes.empty() )
2149 {
2150 symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
2151 symbol_ptr->SetByteSize(sym_idx + 1);
2152 symbol_ptr->SetSizeIsSibling(true);
2153 N_BRAC_indexes.pop_back();
2154 }
2155 type = eSymbolTypeScopeEnd;
2156 break;
2157
2158 case StabDeletedIncludeFile:
2159 // N_EXCL - deleted include file: name,,NO_SECT,0,sum
2160 type = eSymbolTypeHeaderFile;
2161 break;
2162
2163 //----------------------------------------------------------------------
2164 // COMM scopes
2165 //----------------------------------------------------------------------
2166 case StabBeginCommon:
2167 // N_BCOMM - begin common: name,,NO_SECT,0,0
2168 // We use the current number of symbols in the symbol table in lieu of
2169 // using nlist_idx in case we ever start trimming entries out
2170 type = eSymbolTypeScopeBegin;
2171 N_COMM_indexes.push_back(sym_idx);
2172 break;
2173
2174 case StabEndCommonLocal:
2175 // N_ECOML - end common (local name): 0,,n_sect,0,address
2176 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2177 // Fall through
2178
2179 case StabEndCommon:
2180 // N_ECOMM - end common: name,,n_sect,0,0
2181 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
2182 // so that we can always skip the entire symbol if we need to navigate
2183 // more quickly at the source level when parsing STABS
2184 if ( !N_COMM_indexes.empty() )
2185 {
2186 symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
2187 symbol_ptr->SetByteSize(sym_idx + 1);
2188 symbol_ptr->SetSizeIsSibling(true);
2189 N_COMM_indexes.pop_back();
2190 }
2191 type = eSymbolTypeScopeEnd;
2192 break;
2193
2194 case StabLength:
2195 // N_LENG - second stab entry with length information
2196 type = eSymbolTypeAdditional;
2197 break;
2198
2199 default: break;
2200 }
2201 }
2202 else
2203 {
2204 //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type;
2205 uint8_t n_type = NlistMaskType & nlist.n_type;
2206 sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0);
2207
2208 switch (n_type)
2209 {
2210 case NListTypeIndirect: // N_INDR - Fall through
2211 case NListTypePreboundUndefined:// N_PBUD - Fall through
2212 case NListTypeUndefined: // N_UNDF
2213 type = eSymbolTypeUndefined;
2214 break;
2215
2216 case NListTypeAbsolute: // N_ABS
2217 type = eSymbolTypeAbsolute;
2218 break;
2219
2220 case NListTypeSection: // N_SECT
Greg Clayton01e6a582012-11-27 01:52:16 +00002221 {
2222 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
Jason Molendab62abd52012-06-21 01:51:02 +00002223
Greg Clayton01e6a582012-11-27 01:52:16 +00002224 if (symbol_section == NULL)
Jason Molendab62abd52012-06-21 01:51:02 +00002225 {
Greg Clayton01e6a582012-11-27 01:52:16 +00002226 // TODO: warn about this?
2227 add_nlist = false;
2228 break;
Jason Molendab62abd52012-06-21 01:51:02 +00002229 }
Greg Clayton01e6a582012-11-27 01:52:16 +00002230
2231 if (TEXT_eh_frame_sectID == nlist.n_sect)
Jason Molendab62abd52012-06-21 01:51:02 +00002232 {
Greg Clayton01e6a582012-11-27 01:52:16 +00002233 type = eSymbolTypeException;
2234 }
2235 else
2236 {
2237 uint32_t section_type = symbol_section->Get() & SectionFlagMaskSectionType;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002238
Greg Clayton01e6a582012-11-27 01:52:16 +00002239 switch (section_type)
Jason Molendab62abd52012-06-21 01:51:02 +00002240 {
Greg Clayton01e6a582012-11-27 01:52:16 +00002241 case SectionTypeRegular: break; // regular section
2242 //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section
2243 case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings
2244 case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals
2245 case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals
2246 case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals
2247 case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
2248 case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
2249 case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
2250 case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization
2251 case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination
2252 //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced
2253 //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes)
2254 case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing
2255 case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals
2256 case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break;
2257 case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break;
2258 default: break;
Jason Molendab62abd52012-06-21 01:51:02 +00002259 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002260
Greg Clayton01e6a582012-11-27 01:52:16 +00002261 if (type == eSymbolTypeInvalid)
2262 {
2263 const char *symbol_sect_name = symbol_section->GetName().AsCString();
2264 if (symbol_section->IsDescendant (text_section_sp.get()))
2265 {
2266 if (symbol_section->IsClear(SectionAttrUserPureInstructions |
2267 SectionAttrUserSelfModifyingCode |
2268 SectionAttrSytemSomeInstructions))
2269 type = eSymbolTypeData;
2270 else
2271 type = eSymbolTypeCode;
2272 }
2273 else if (symbol_section->IsDescendant(data_section_sp.get()))
Jason Molendab62abd52012-06-21 01:51:02 +00002274 {
2275 if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
2276 {
2277 type = eSymbolTypeRuntime;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002278
Greg Clayton01e6a582012-11-27 01:52:16 +00002279 if (symbol_name &&
2280 symbol_name[0] == '_' &&
2281 symbol_name[1] == 'O' &&
Jason Molendab62abd52012-06-21 01:51:02 +00002282 symbol_name[2] == 'B')
2283 {
2284 llvm::StringRef symbol_name_ref(symbol_name);
2285 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
2286 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
2287 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
2288 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
2289 {
2290 symbol_name_non_abi_mangled = symbol_name + 1;
2291 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
2292 type = eSymbolTypeObjCClass;
Greg Clayton01e6a582012-11-27 01:52:16 +00002293 demangled_is_synthesized = true;
Jason Molendab62abd52012-06-21 01:51:02 +00002294 }
2295 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
2296 {
2297 symbol_name_non_abi_mangled = symbol_name + 1;
2298 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
2299 type = eSymbolTypeObjCMetaClass;
Greg Clayton01e6a582012-11-27 01:52:16 +00002300 demangled_is_synthesized = true;
Jason Molendab62abd52012-06-21 01:51:02 +00002301 }
2302 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
2303 {
2304 symbol_name_non_abi_mangled = symbol_name + 1;
2305 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
2306 type = eSymbolTypeObjCIVar;
Greg Clayton01e6a582012-11-27 01:52:16 +00002307 demangled_is_synthesized = true;
Jason Molendab62abd52012-06-21 01:51:02 +00002308 }
2309 }
2310 }
Greg Clayton01e6a582012-11-27 01:52:16 +00002311 else if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
Jason Molendab62abd52012-06-21 01:51:02 +00002312 {
Greg Clayton01e6a582012-11-27 01:52:16 +00002313 type = eSymbolTypeException;
Jason Molendab62abd52012-06-21 01:51:02 +00002314 }
2315 else
Greg Clayton01e6a582012-11-27 01:52:16 +00002316 {
2317 type = eSymbolTypeData;
2318 }
2319 }
2320 else if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
2321 {
2322 type = eSymbolTypeTrampoline;
2323 }
2324 else if (symbol_section->IsDescendant(objc_section_sp.get()))
2325 {
2326 type = eSymbolTypeRuntime;
2327 if (symbol_name && symbol_name[0] == '.')
2328 {
2329 llvm::StringRef symbol_name_ref(symbol_name);
2330 static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
2331 if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
Jason Molendab62abd52012-06-21 01:51:02 +00002332 {
Greg Clayton01e6a582012-11-27 01:52:16 +00002333 symbol_name_non_abi_mangled = symbol_name;
2334 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
2335 type = eSymbolTypeObjCClass;
2336 demangled_is_synthesized = true;
Jason Molendab62abd52012-06-21 01:51:02 +00002337 }
Greg Clayton01e6a582012-11-27 01:52:16 +00002338 }
2339 }
2340 }
Jason Molendab62abd52012-06-21 01:51:02 +00002341 }
2342 }
Jason Molendab62abd52012-06-21 01:51:02 +00002343 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002344 }
Jason Molendab62abd52012-06-21 01:51:02 +00002345 }
2346
2347 if (add_nlist)
2348 {
2349 uint64_t symbol_value = nlist.n_value;
2350 bool symbol_name_is_mangled = false;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002351
Jason Molendab62abd52012-06-21 01:51:02 +00002352 if (symbol_name_non_abi_mangled)
2353 {
Jason Molenda292cca82012-07-20 03:35:44 +00002354 sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
2355 sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
Jason Molendab62abd52012-06-21 01:51:02 +00002356 }
2357 else
2358 {
2359 if (symbol_name && symbol_name[0] == '_')
2360 {
2361 symbol_name_is_mangled = symbol_name[1] == '_';
2362 symbol_name++; // Skip the leading underscore
2363 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002364
Jason Molendab62abd52012-06-21 01:51:02 +00002365 if (symbol_name)
2366 {
Jason Molenda292cca82012-07-20 03:35:44 +00002367 sym[sym_idx].GetMangled().SetValue(ConstString(symbol_name), symbol_name_is_mangled);
Jason Molendab62abd52012-06-21 01:51:02 +00002368 }
2369 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002370
Jason Molendab62abd52012-06-21 01:51:02 +00002371 if (is_debug == false)
2372 {
2373 if (type == eSymbolTypeCode)
2374 {
2375 // See if we can find a N_FUN entry for any code symbols.
2376 // If we do find a match, and the name matches, then we
2377 // can merge the two into just the function symbol to avoid
2378 // duplicate entries in the symbol table
2379 ValueToSymbolIndexMap::const_iterator pos = N_FUN_addr_to_sym_idx.find (nlist.n_value);
2380 if (pos != N_FUN_addr_to_sym_idx.end())
2381 {
2382 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2383 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2384 {
2385 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2386 // We just need the flags from the linker symbol, so put these flags
2387 // into the N_FUN flags to avoid duplicate symbols in the symbol table
2388 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2389 sym[sym_idx].Clear();
2390 continue;
2391 }
2392 }
2393 }
2394 else if (type == eSymbolTypeData)
2395 {
2396 // See if we can find a N_STSYM entry for any data symbols.
2397 // If we do find a match, and the name matches, then we
2398 // can merge the two into just the Static symbol to avoid
2399 // duplicate entries in the symbol table
2400 ValueToSymbolIndexMap::const_iterator pos = N_STSYM_addr_to_sym_idx.find (nlist.n_value);
2401 if (pos != N_STSYM_addr_to_sym_idx.end())
2402 {
2403 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2404 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2405 {
2406 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2407 // We just need the flags from the linker symbol, so put these flags
2408 // into the N_STSYM flags to avoid duplicate symbols in the symbol table
2409 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2410 sym[sym_idx].Clear();
2411 continue;
2412 }
2413 }
2414 }
2415 }
2416 if (symbol_section)
2417 {
2418 const addr_t section_file_addr = symbol_section->GetFileAddress();
2419 if (symbol_byte_size == 0 && function_starts_count > 0)
2420 {
2421 addr_t symbol_lookup_file_addr = nlist.n_value;
2422 // Do an exact address match for non-ARM addresses, else get the closest since
2423 // the symbol might be a thumb symbol which has an address with bit zero set
2424 FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
2425 if (is_arm && func_start_entry)
2426 {
2427 // Verify that the function start address is the symbol address (ARM)
2428 // or the symbol address + 1 (thumb)
2429 if (func_start_entry->addr != symbol_lookup_file_addr &&
2430 func_start_entry->addr != (symbol_lookup_file_addr + 1))
2431 {
2432 // Not the right entry, NULL it out...
2433 func_start_entry = NULL;
2434 }
2435 }
2436 if (func_start_entry)
2437 {
2438 func_start_entry->data = true;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002439
Jason Molendab62abd52012-06-21 01:51:02 +00002440 addr_t symbol_file_addr = func_start_entry->addr;
2441 uint32_t symbol_flags = 0;
2442 if (is_arm)
2443 {
2444 if (symbol_file_addr & 1)
2445 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
2446 symbol_file_addr &= 0xfffffffffffffffeull;
2447 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002448
Jason Molendab62abd52012-06-21 01:51:02 +00002449 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
2450 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
2451 if (next_func_start_entry)
2452 {
2453 addr_t next_symbol_file_addr = next_func_start_entry->addr;
2454 // Be sure the clear the Thumb address bit when we calculate the size
2455 // from the current and next address
2456 if (is_arm)
2457 next_symbol_file_addr &= 0xfffffffffffffffeull;
2458 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
2459 }
2460 else
2461 {
2462 symbol_byte_size = section_end_file_addr - symbol_file_addr;
2463 }
2464 }
2465 }
2466 symbol_value -= section_file_addr;
2467 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002468
Jason Molendab62abd52012-06-21 01:51:02 +00002469 sym[sym_idx].SetID (nlist_idx);
2470 sym[sym_idx].SetType (type);
2471 sym[sym_idx].GetAddress().SetSection (symbol_section);
2472 sym[sym_idx].GetAddress().SetOffset (symbol_value);
2473 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
Jason Molenda9badb6c2013-03-06 23:19:17 +00002474
Jason Molendab62abd52012-06-21 01:51:02 +00002475 if (symbol_byte_size > 0)
2476 sym[sym_idx].SetByteSize(symbol_byte_size);
2477
Greg Clayton01e6a582012-11-27 01:52:16 +00002478 if (demangled_is_synthesized)
2479 sym[sym_idx].SetDemangledNameIsSynthesized(true);
Jason Molendab62abd52012-06-21 01:51:02 +00002480 ++sym_idx;
2481 }
2482 else
2483 {
2484 sym[sym_idx].Clear();
2485 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002486
Jason Molendab62abd52012-06-21 01:51:02 +00002487 }
2488 /////////////////////////////
2489 }
2490 break; // No more entries to consider
2491 }
2492 }
2493 }
2494 }
2495 }
2496 }
2497 }
2498
2499 // Must reset this in case it was mutated above!
2500 nlist_data_offset = 0;
2501#endif
2502
2503 // If the sym array was not created while parsing the DSC unmapped
2504 // symbols, create it now.
2505 if (sym == NULL)
2506 {
2507 sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
2508 num_syms = symtab->GetNumSymbols();
2509 }
2510
2511 if (unmapped_local_symbols_found)
2512 {
2513 assert(m_dysymtab.ilocalsym == 0);
2514 nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
2515 nlist_idx = m_dysymtab.nlocalsym;
2516 }
2517 else
2518 {
2519 nlist_idx = 0;
2520 }
2521
2522 for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx)
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002523 {
2524 struct nlist_64 nlist;
2525 if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
2526 break;
2527
2528 nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset);
2529 nlist.n_type = nlist_data.GetU8_unchecked (&nlist_data_offset);
2530 nlist.n_sect = nlist_data.GetU8_unchecked (&nlist_data_offset);
2531 nlist.n_desc = nlist_data.GetU16_unchecked (&nlist_data_offset);
2532 nlist.n_value = nlist_data.GetAddress_unchecked (&nlist_data_offset);
2533
2534 SymbolType type = eSymbolTypeInvalid;
Greg Claytondd29b972012-05-18 23:20:01 +00002535 const char *symbol_name = NULL;
Jason Molenda9badb6c2013-03-06 23:19:17 +00002536
Greg Clayton3a5dc012012-05-25 17:04:00 +00002537 if (have_strtab_data)
Greg Claytondd29b972012-05-18 23:20:01 +00002538 {
2539 symbol_name = strtab_data.PeekCStr(nlist.n_strx);
Jason Molenda9badb6c2013-03-06 23:19:17 +00002540
Greg Claytondd29b972012-05-18 23:20:01 +00002541 if (symbol_name == NULL)
2542 {
2543 // No symbol should be NULL, even the symbols with no
2544 // string values should have an offset zero which points
2545 // to an empty C-string
2546 Host::SystemLog (Host::eSystemLogError,
Jason Molenda9badb6c2013-03-06 23:19:17 +00002547 "error: symbol[%u] has invalid string table offset 0x%x in %s/%s, ignoring symbol\n",
Greg Claytondd29b972012-05-18 23:20:01 +00002548 nlist_idx,
2549 nlist.n_strx,
2550 module_sp->GetFileSpec().GetDirectory().GetCString(),
2551 module_sp->GetFileSpec().GetFilename().GetCString());
2552 continue;
2553 }
2554 if (symbol_name[0] == '\0')
2555 symbol_name = NULL;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002556 }
Greg Clayton3a5dc012012-05-25 17:04:00 +00002557 else
2558 {
2559 const addr_t str_addr = strtab_addr + nlist.n_strx;
2560 Error str_error;
2561 if (process->ReadCStringFromMemory(str_addr, memory_symbol_name, str_error))
2562 symbol_name = memory_symbol_name.c_str();
2563 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002564 const char *symbol_name_non_abi_mangled = NULL;
2565
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002566 SectionSP symbol_section;
Greg Clayton36da2aa2013-01-25 18:06:21 +00002567 lldb::addr_t symbol_byte_size = 0;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002568 bool add_nlist = true;
2569 bool is_debug = ((nlist.n_type & NlistMaskStab) != 0);
Greg Clayton01e6a582012-11-27 01:52:16 +00002570 bool demangled_is_synthesized = false;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002571
2572 assert (sym_idx < num_syms);
2573
2574 sym[sym_idx].SetDebug (is_debug);
2575
2576 if (is_debug)
2577 {
2578 switch (nlist.n_type)
Greg Clayton0fea0512011-12-30 00:32:24 +00002579 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00002580 case StabGlobalSymbol:
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002581 // N_GSYM -- global symbol: name,,NO_SECT,type,0
2582 // Sometimes the N_GSYM value contains the address.
Jason Molenda9badb6c2013-03-06 23:19:17 +00002583
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002584 // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data. They
2585 // have the same address, but we want to ensure that we always find only the real symbol,
2586 // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
2587 // symbol type. This is a temporary hack to make sure the ObjectiveC symbols get treated
2588 // correctly. To do this right, we should coalesce all the GSYM & global symbols that have the
2589 // same address.
Jason Molenda9badb6c2013-03-06 23:19:17 +00002590
2591 if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O'
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002592 && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
2593 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
2594 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
2595 add_nlist = false;
2596 else
Greg Claytonb5a8f142012-02-05 02:38:54 +00002597 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002598 sym[sym_idx].SetExternal(true);
2599 if (nlist.n_value != 0)
2600 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2601 type = eSymbolTypeData;
Greg Claytonb5a8f142012-02-05 02:38:54 +00002602 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002603 break;
Greg Claytonb5a8f142012-02-05 02:38:54 +00002604
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002605 case StabFunctionName:
2606 // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0
2607 type = eSymbolTypeCompiler;
2608 break;
Greg Clayton0fea0512011-12-30 00:32:24 +00002609
Jason Molenda9badb6c2013-03-06 23:19:17 +00002610 case StabFunction:
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002611 // N_FUN -- procedure: name,,n_sect,linenumber,address
2612 if (symbol_name)
Greg Claytona9c4f312011-10-31 20:50:40 +00002613 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002614 type = eSymbolTypeCode;
2615 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
Jason Molenda9badb6c2013-03-06 23:19:17 +00002616
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002617 N_FUN_addr_to_sym_idx[nlist.n_value] = sym_idx;
2618 // We use the current number of symbols in the symbol table in lieu of
2619 // using nlist_idx in case we ever start trimming entries out
2620 N_FUN_indexes.push_back(sym_idx);
Chris Lattner24943d22010-06-08 16:52:24 +00002621 }
2622 else
2623 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002624 type = eSymbolTypeCompiler;
Chris Lattner24943d22010-06-08 16:52:24 +00002625
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002626 if ( !N_FUN_indexes.empty() )
Chris Lattner24943d22010-06-08 16:52:24 +00002627 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002628 // Copy the size of the function into the original STAB entry so we don't have
2629 // to hunt for it later
2630 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
2631 N_FUN_indexes.pop_back();
2632 // We don't really need the end function STAB as it contains the size which
2633 // we already placed with the original symbol, so don't add it if we want a
2634 // minimal symbol table
2635 if (minimize)
Greg Clayton3f69eac2011-12-03 02:30:59 +00002636 add_nlist = false;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002637 }
Greg Clayton3f69eac2011-12-03 02:30:59 +00002638 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002639 break;
Greg Clayton3f69eac2011-12-03 02:30:59 +00002640
Jason Molenda9badb6c2013-03-06 23:19:17 +00002641 case StabStaticSymbol:
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002642 // N_STSYM -- static symbol: name,,n_sect,type,address
2643 N_STSYM_addr_to_sym_idx[nlist.n_value] = sym_idx;
2644 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2645 type = eSymbolTypeData;
2646 break;
2647
2648 case StabLocalCommon:
2649 // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address
2650 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2651 type = eSymbolTypeCommonBlock;
2652 break;
2653
2654 case StabBeginSymbol:
2655 // N_BNSYM
2656 // We use the current number of symbols in the symbol table in lieu of
2657 // using nlist_idx in case we ever start trimming entries out
2658 if (minimize)
Greg Clayton3f69eac2011-12-03 02:30:59 +00002659 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002660 // Skip these if we want minimal symbol tables
2661 add_nlist = false;
2662 }
2663 else
2664 {
2665 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2666 N_NSYM_indexes.push_back(sym_idx);
2667 type = eSymbolTypeScopeBegin;
2668 }
2669 break;
Greg Clayton3f69eac2011-12-03 02:30:59 +00002670
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002671 case StabEndSymbol:
2672 // N_ENSYM
2673 // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
2674 // so that we can always skip the entire symbol if we need to navigate
2675 // more quickly at the source level when parsing STABS
2676 if (minimize)
2677 {
2678 // Skip these if we want minimal symbol tables
2679 add_nlist = false;
2680 }
2681 else
2682 {
2683 if ( !N_NSYM_indexes.empty() )
Greg Clayton3f69eac2011-12-03 02:30:59 +00002684 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002685 symbol_ptr = symtab->SymbolAtIndex(N_NSYM_indexes.back());
2686 symbol_ptr->SetByteSize(sym_idx + 1);
2687 symbol_ptr->SetSizeIsSibling(true);
2688 N_NSYM_indexes.pop_back();
2689 }
2690 type = eSymbolTypeScopeEnd;
2691 }
2692 break;
2693
2694
2695 case StabSourceFileOptions:
2696 // N_OPT - emitted with gcc2_compiled and in gcc source
2697 type = eSymbolTypeCompiler;
2698 break;
2699
2700 case StabRegisterSymbol:
2701 // N_RSYM - register sym: name,,NO_SECT,type,register
2702 type = eSymbolTypeVariable;
2703 break;
2704
2705 case StabSourceLine:
2706 // N_SLINE - src line: 0,,n_sect,linenumber,address
2707 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2708 type = eSymbolTypeLineEntry;
2709 break;
2710
2711 case StabStructureType:
2712 // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset
2713 type = eSymbolTypeVariableType;
2714 break;
2715
2716 case StabSourceFileName:
2717 // N_SO - source file name
2718 type = eSymbolTypeSourceFile;
2719 if (symbol_name == NULL)
2720 {
2721 if (minimize)
2722 add_nlist = false;
2723 if (N_SO_index != UINT32_MAX)
2724 {
2725 // Set the size of the N_SO to the terminating index of this N_SO
2726 // so that we can always skip the entire N_SO if we need to navigate
2727 // more quickly at the source level when parsing STABS
2728 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
2729 symbol_ptr->SetByteSize(sym_idx + (minimize ? 0 : 1));
2730 symbol_ptr->SetSizeIsSibling(true);
2731 }
2732 N_NSYM_indexes.clear();
2733 N_INCL_indexes.clear();
2734 N_BRAC_indexes.clear();
2735 N_COMM_indexes.clear();
2736 N_FUN_indexes.clear();
2737 N_SO_index = UINT32_MAX;
2738 }
2739 else
2740 {
2741 // We use the current number of symbols in the symbol table in lieu of
2742 // using nlist_idx in case we ever start trimming entries out
Greg Clayton5fa6cd32012-05-30 20:20:34 +00002743 const bool N_SO_has_full_path = symbol_name[0] == '/';
2744 if (N_SO_has_full_path)
2745 {
2746 if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2747 {
2748 // We have two consecutive N_SO entries where the first contains a directory
2749 // and the second contains a full path.
Greg Claytonc0240042012-07-18 23:18:10 +00002750 sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
Greg Clayton5fa6cd32012-05-30 20:20:34 +00002751 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2752 add_nlist = false;
2753 }
2754 else
2755 {
2756 // This is the first entry in a N_SO that contains a directory or
2757 // a full path to the source file
2758 N_SO_index = sym_idx;
2759 }
2760 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002761 else if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2762 {
Greg Clayton5fa6cd32012-05-30 20:20:34 +00002763 // This is usually the second N_SO entry that contains just the filename,
2764 // so here we combine it with the first one if we are minimizing the symbol table
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002765 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
2766 if (so_path && so_path[0])
2767 {
2768 std::string full_so_path (so_path);
Greg Clayton4df2b7f2012-09-07 20:29:13 +00002769 const size_t double_slash_pos = full_so_path.find("//");
2770 if (double_slash_pos != std::string::npos)
2771 {
2772 // The linker has been generating bad N_SO entries with doubled up paths
2773 // in the format "%s%s" where the first stirng in the DW_AT_comp_dir,
2774 // and the second is the directory for the source file so you end up with
2775 // a path that looks like "/tmp/src//tmp/src/"
2776 FileSpec so_dir(so_path, false);
2777 if (!so_dir.Exists())
2778 {
2779 so_dir.SetFile(&full_so_path[double_slash_pos + 1], false);
2780 if (so_dir.Exists())
2781 {
2782 // Trim off the incorrect path
2783 full_so_path.erase(0, double_slash_pos + 1);
2784 }
2785 }
2786 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002787 if (*full_so_path.rbegin() != '/')
2788 full_so_path += '/';
2789 full_so_path += symbol_name;
Greg Claytonc0240042012-07-18 23:18:10 +00002790 sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002791 add_nlist = false;
2792 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2793 }
2794 }
Greg Claytonab77dcb2012-09-05 22:30:51 +00002795 else
2796 {
2797 // This could be a relative path to a N_SO
2798 N_SO_index = sym_idx;
2799 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002800 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00002801
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002802 break;
2803
2804 case StabObjectFileName:
2805 // N_OSO - object file name: name,,0,0,st_mtime
2806 type = eSymbolTypeObjectFile;
2807 break;
2808
2809 case StabLocalSymbol:
2810 // N_LSYM - local sym: name,,NO_SECT,type,offset
2811 type = eSymbolTypeLocal;
2812 break;
2813
2814 //----------------------------------------------------------------------
2815 // INCL scopes
2816 //----------------------------------------------------------------------
2817 case StabBeginIncludeFileName:
2818 // N_BINCL - include file beginning: name,,NO_SECT,0,sum
2819 // We use the current number of symbols in the symbol table in lieu of
2820 // using nlist_idx in case we ever start trimming entries out
2821 N_INCL_indexes.push_back(sym_idx);
2822 type = eSymbolTypeScopeBegin;
2823 break;
2824
2825 case StabEndIncludeFile:
2826 // N_EINCL - include file end: name,,NO_SECT,0,0
2827 // Set the size of the N_BINCL to the terminating index of this N_EINCL
2828 // so that we can always skip the entire symbol if we need to navigate
2829 // more quickly at the source level when parsing STABS
2830 if ( !N_INCL_indexes.empty() )
2831 {
2832 symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
2833 symbol_ptr->SetByteSize(sym_idx + 1);
2834 symbol_ptr->SetSizeIsSibling(true);
2835 N_INCL_indexes.pop_back();
2836 }
2837 type = eSymbolTypeScopeEnd;
2838 break;
2839
2840 case StabIncludeFileName:
2841 // N_SOL - #included file name: name,,n_sect,0,address
2842 type = eSymbolTypeHeaderFile;
2843
2844 // We currently don't use the header files on darwin
2845 if (minimize)
2846 add_nlist = false;
2847 break;
2848
Jason Molenda9badb6c2013-03-06 23:19:17 +00002849 case StabCompilerParameters:
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002850 // N_PARAMS - compiler parameters: name,,NO_SECT,0,0
2851 type = eSymbolTypeCompiler;
2852 break;
2853
2854 case StabCompilerVersion:
2855 // N_VERSION - compiler version: name,,NO_SECT,0,0
2856 type = eSymbolTypeCompiler;
2857 break;
2858
2859 case StabCompilerOptLevel:
2860 // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0
2861 type = eSymbolTypeCompiler;
2862 break;
2863
2864 case StabParameter:
2865 // N_PSYM - parameter: name,,NO_SECT,type,offset
2866 type = eSymbolTypeVariable;
2867 break;
2868
2869 case StabAlternateEntry:
2870 // N_ENTRY - alternate entry: name,,n_sect,linenumber,address
2871 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2872 type = eSymbolTypeLineEntry;
2873 break;
2874
2875 //----------------------------------------------------------------------
2876 // Left and Right Braces
2877 //----------------------------------------------------------------------
2878 case StabLeftBracket:
2879 // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address
2880 // We use the current number of symbols in the symbol table in lieu of
2881 // using nlist_idx in case we ever start trimming entries out
2882 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2883 N_BRAC_indexes.push_back(sym_idx);
2884 type = eSymbolTypeScopeBegin;
2885 break;
2886
2887 case StabRightBracket:
2888 // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address
2889 // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
2890 // so that we can always skip the entire symbol if we need to navigate
2891 // more quickly at the source level when parsing STABS
2892 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2893 if ( !N_BRAC_indexes.empty() )
2894 {
2895 symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
2896 symbol_ptr->SetByteSize(sym_idx + 1);
2897 symbol_ptr->SetSizeIsSibling(true);
2898 N_BRAC_indexes.pop_back();
2899 }
2900 type = eSymbolTypeScopeEnd;
2901 break;
2902
2903 case StabDeletedIncludeFile:
2904 // N_EXCL - deleted include file: name,,NO_SECT,0,sum
2905 type = eSymbolTypeHeaderFile;
2906 break;
2907
2908 //----------------------------------------------------------------------
2909 // COMM scopes
2910 //----------------------------------------------------------------------
2911 case StabBeginCommon:
2912 // N_BCOMM - begin common: name,,NO_SECT,0,0
2913 // We use the current number of symbols in the symbol table in lieu of
2914 // using nlist_idx in case we ever start trimming entries out
2915 type = eSymbolTypeScopeBegin;
2916 N_COMM_indexes.push_back(sym_idx);
2917 break;
2918
2919 case StabEndCommonLocal:
2920 // N_ECOML - end common (local name): 0,,n_sect,0,address
2921 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2922 // Fall through
2923
2924 case StabEndCommon:
2925 // N_ECOMM - end common: name,,n_sect,0,0
2926 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
2927 // so that we can always skip the entire symbol if we need to navigate
2928 // more quickly at the source level when parsing STABS
2929 if ( !N_COMM_indexes.empty() )
2930 {
2931 symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
2932 symbol_ptr->SetByteSize(sym_idx + 1);
2933 symbol_ptr->SetSizeIsSibling(true);
2934 N_COMM_indexes.pop_back();
2935 }
2936 type = eSymbolTypeScopeEnd;
2937 break;
2938
2939 case StabLength:
2940 // N_LENG - second stab entry with length information
2941 type = eSymbolTypeAdditional;
2942 break;
2943
2944 default: break;
2945 }
2946 }
2947 else
2948 {
2949 //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type;
2950 uint8_t n_type = NlistMaskType & nlist.n_type;
2951 sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0);
2952
2953 switch (n_type)
2954 {
2955 case NListTypeIndirect: // N_INDR - Fall through
2956 case NListTypePreboundUndefined:// N_PBUD - Fall through
2957 case NListTypeUndefined: // N_UNDF
2958 type = eSymbolTypeUndefined;
2959 break;
2960
2961 case NListTypeAbsolute: // N_ABS
2962 type = eSymbolTypeAbsolute;
2963 break;
2964
2965 case NListTypeSection: // N_SECT
2966 {
2967 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2968
Sean Callananb386d822012-08-09 00:50:26 +00002969 if (!symbol_section)
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002970 {
2971 // TODO: warn about this?
2972 add_nlist = false;
2973 break;
2974 }
2975
2976 if (TEXT_eh_frame_sectID == nlist.n_sect)
2977 {
2978 type = eSymbolTypeException;
Chris Lattner24943d22010-06-08 16:52:24 +00002979 }
2980 else
2981 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002982 uint32_t section_type = symbol_section->Get() & SectionFlagMaskSectionType;
2983
2984 switch (section_type)
Chris Lattner24943d22010-06-08 16:52:24 +00002985 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00002986 case SectionTypeRegular: break; // regular section
2987 //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section
2988 case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings
2989 case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals
2990 case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals
2991 case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals
2992 case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
2993 case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
2994 case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
2995 case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization
2996 case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination
2997 //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced
2998 //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes)
2999 case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing
3000 case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals
3001 case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break;
3002 case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break;
3003 default: break;
Greg Clayton3f69eac2011-12-03 02:30:59 +00003004 }
Chris Lattner24943d22010-06-08 16:52:24 +00003005
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003006 if (type == eSymbolTypeInvalid)
Greg Clayton3f69eac2011-12-03 02:30:59 +00003007 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003008 const char *symbol_sect_name = symbol_section->GetName().AsCString();
3009 if (symbol_section->IsDescendant (text_section_sp.get()))
Greg Clayton576a68b2010-09-08 16:38:06 +00003010 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00003011 if (symbol_section->IsClear(SectionAttrUserPureInstructions |
3012 SectionAttrUserSelfModifyingCode |
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003013 SectionAttrSytemSomeInstructions))
3014 type = eSymbolTypeData;
3015 else
3016 type = eSymbolTypeCode;
Greg Clayton576a68b2010-09-08 16:38:06 +00003017 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003018 else
3019 if (symbol_section->IsDescendant(data_section_sp.get()))
Greg Clayton576a68b2010-09-08 16:38:06 +00003020 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003021 if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
Greg Clayton7c36fa02010-09-11 03:13:28 +00003022 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003023 type = eSymbolTypeRuntime;
Chris Lattner24943d22010-06-08 16:52:24 +00003024
Jason Molenda9badb6c2013-03-06 23:19:17 +00003025 if (symbol_name &&
3026 symbol_name[0] == '_' &&
3027 symbol_name[1] == 'O' &&
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003028 symbol_name[2] == 'B')
Greg Clayton637029b2010-09-12 05:25:16 +00003029 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003030 llvm::StringRef symbol_name_ref(symbol_name);
3031 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
3032 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
3033 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
3034 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
Chris Lattner24943d22010-06-08 16:52:24 +00003035 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003036 symbol_name_non_abi_mangled = symbol_name + 1;
3037 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
3038 type = eSymbolTypeObjCClass;
Greg Clayton01e6a582012-11-27 01:52:16 +00003039 demangled_is_synthesized = true;
Chris Lattner24943d22010-06-08 16:52:24 +00003040 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003041 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
Chris Lattner24943d22010-06-08 16:52:24 +00003042 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003043 symbol_name_non_abi_mangled = symbol_name + 1;
3044 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
3045 type = eSymbolTypeObjCMetaClass;
Greg Clayton01e6a582012-11-27 01:52:16 +00003046 demangled_is_synthesized = true;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003047 }
3048 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
3049 {
3050 symbol_name_non_abi_mangled = symbol_name + 1;
3051 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
3052 type = eSymbolTypeObjCIVar;
Greg Clayton01e6a582012-11-27 01:52:16 +00003053 demangled_is_synthesized = true;
Chris Lattner24943d22010-06-08 16:52:24 +00003054 }
3055 }
3056 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003057 else
3058 if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
3059 {
3060 type = eSymbolTypeException;
3061 }
3062 else
3063 {
3064 type = eSymbolTypeData;
3065 }
3066 }
3067 else
3068 if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
3069 {
3070 type = eSymbolTypeTrampoline;
3071 }
3072 else
3073 if (symbol_section->IsDescendant(objc_section_sp.get()))
3074 {
3075 type = eSymbolTypeRuntime;
3076 if (symbol_name && symbol_name[0] == '.')
3077 {
3078 llvm::StringRef symbol_name_ref(symbol_name);
3079 static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
3080 if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
3081 {
3082 symbol_name_non_abi_mangled = symbol_name;
3083 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
3084 type = eSymbolTypeObjCClass;
Greg Clayton01e6a582012-11-27 01:52:16 +00003085 demangled_is_synthesized = true;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003086 }
3087 }
Chris Lattner24943d22010-06-08 16:52:24 +00003088 }
3089 }
3090 }
3091 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003092 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003093 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003094 }
3095
3096 if (add_nlist)
3097 {
3098 uint64_t symbol_value = nlist.n_value;
3099 bool symbol_name_is_mangled = false;
3100
3101 if (symbol_name_non_abi_mangled)
3102 {
Greg Claytonc0240042012-07-18 23:18:10 +00003103 sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
3104 sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
Chris Lattner24943d22010-06-08 16:52:24 +00003105 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003106 else
3107 {
3108 if (symbol_name && symbol_name[0] == '_')
3109 {
3110 symbol_name_is_mangled = symbol_name[1] == '_';
3111 symbol_name++; // Skip the leading underscore
3112 }
3113
3114 if (symbol_name)
3115 {
Greg Claytonc0240042012-07-18 23:18:10 +00003116 sym[sym_idx].GetMangled().SetValue(ConstString(symbol_name), symbol_name_is_mangled);
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003117 }
3118 }
3119
3120 if (is_debug == false)
3121 {
3122 if (type == eSymbolTypeCode)
3123 {
3124 // See if we can find a N_FUN entry for any code symbols.
3125 // If we do find a match, and the name matches, then we
3126 // can merge the two into just the function symbol to avoid
3127 // duplicate entries in the symbol table
3128 ValueToSymbolIndexMap::const_iterator pos = N_FUN_addr_to_sym_idx.find (nlist.n_value);
3129 if (pos != N_FUN_addr_to_sym_idx.end())
3130 {
3131 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
3132 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
3133 {
3134 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3135 // We just need the flags from the linker symbol, so put these flags
3136 // into the N_FUN flags to avoid duplicate symbols in the symbol table
3137 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3138 sym[sym_idx].Clear();
3139 continue;
3140 }
3141 }
3142 }
3143 else if (type == eSymbolTypeData)
3144 {
3145 // See if we can find a N_STSYM entry for any data symbols.
3146 // If we do find a match, and the name matches, then we
3147 // can merge the two into just the Static symbol to avoid
3148 // duplicate entries in the symbol table
3149 ValueToSymbolIndexMap::const_iterator pos = N_STSYM_addr_to_sym_idx.find (nlist.n_value);
3150 if (pos != N_STSYM_addr_to_sym_idx.end())
3151 {
3152 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
3153 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
3154 {
3155 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3156 // We just need the flags from the linker symbol, so put these flags
3157 // into the N_STSYM flags to avoid duplicate symbols in the symbol table
3158 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3159 sym[sym_idx].Clear();
3160 continue;
3161 }
3162 }
3163 }
3164 }
3165 if (symbol_section)
3166 {
3167 const addr_t section_file_addr = symbol_section->GetFileAddress();
3168 if (symbol_byte_size == 0 && function_starts_count > 0)
3169 {
Greg Claytond2653c22012-03-14 01:53:24 +00003170 addr_t symbol_lookup_file_addr = nlist.n_value;
3171 // Do an exact address match for non-ARM addresses, else get the closest since
3172 // the symbol might be a thumb symbol which has an address with bit zero set
3173 FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
3174 if (is_arm && func_start_entry)
3175 {
3176 // Verify that the function start address is the symbol address (ARM)
3177 // or the symbol address + 1 (thumb)
3178 if (func_start_entry->addr != symbol_lookup_file_addr &&
3179 func_start_entry->addr != (symbol_lookup_file_addr + 1))
3180 {
3181 // Not the right entry, NULL it out...
3182 func_start_entry = NULL;
3183 }
3184 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003185 if (func_start_entry)
3186 {
3187 func_start_entry->data = true;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003188
Greg Claytond2653c22012-03-14 01:53:24 +00003189 addr_t symbol_file_addr = func_start_entry->addr;
Greg Claytond2653c22012-03-14 01:53:24 +00003190 if (is_arm)
Greg Claytond2653c22012-03-14 01:53:24 +00003191 symbol_file_addr &= 0xfffffffffffffffeull;
Greg Claytond2653c22012-03-14 01:53:24 +00003192
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003193 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
3194 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
3195 if (next_func_start_entry)
3196 {
Greg Claytond2653c22012-03-14 01:53:24 +00003197 addr_t next_symbol_file_addr = next_func_start_entry->addr;
3198 // Be sure the clear the Thumb address bit when we calculate the size
3199 // from the current and next address
3200 if (is_arm)
3201 next_symbol_file_addr &= 0xfffffffffffffffeull;
3202 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003203 }
3204 else
3205 {
Greg Claytond2653c22012-03-14 01:53:24 +00003206 symbol_byte_size = section_end_file_addr - symbol_file_addr;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003207 }
3208 }
3209 }
3210 symbol_value -= section_file_addr;
3211 }
3212
3213 sym[sym_idx].SetID (nlist_idx);
3214 sym[sym_idx].SetType (type);
3215 sym[sym_idx].GetAddress().SetSection (symbol_section);
3216 sym[sym_idx].GetAddress().SetOffset (symbol_value);
3217 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
3218
3219 if (symbol_byte_size > 0)
3220 sym[sym_idx].SetByteSize(symbol_byte_size);
3221
Greg Clayton01e6a582012-11-27 01:52:16 +00003222 if (demangled_is_synthesized)
3223 sym[sym_idx].SetDemangledNameIsSynthesized(true);
3224
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003225 ++sym_idx;
3226 }
3227 else
3228 {
3229 sym[sym_idx].Clear();
3230 }
3231
3232 }
3233
3234 // STAB N_GSYM entries end up having a symbol type eSymbolTypeGlobal and when the symbol value
3235 // is zero, the address of the global ends up being in a non-STAB entry. Try and fix up all
3236 // such entries by figuring out what the address for the global is by looking up this non-STAB
3237 // entry and copying the value into the debug symbol's value to save us the hassle in the
3238 // debug symbol parser.
3239
3240 Symbol *global_symbol = NULL;
3241 for (nlist_idx = 0;
3242 nlist_idx < symtab_load_command.nsyms && (global_symbol = symtab->FindSymbolWithType (eSymbolTypeData, Symtab::eDebugYes, Symtab::eVisibilityAny, nlist_idx)) != NULL;
3243 nlist_idx++)
3244 {
3245 if (global_symbol->GetAddress().GetFileAddress() == 0)
3246 {
3247 std::vector<uint32_t> indexes;
3248 if (symtab->AppendSymbolIndexesWithName (global_symbol->GetMangled().GetName(), indexes) > 0)
3249 {
3250 std::vector<uint32_t>::const_iterator pos;
3251 std::vector<uint32_t>::const_iterator end = indexes.end();
3252 for (pos = indexes.begin(); pos != end; ++pos)
3253 {
3254 symbol_ptr = symtab->SymbolAtIndex(*pos);
3255 if (symbol_ptr != global_symbol && symbol_ptr->IsDebug() == false)
3256 {
3257 global_symbol->GetAddress() = symbol_ptr->GetAddress();
3258 break;
3259 }
3260 }
3261 }
Chris Lattner24943d22010-06-08 16:52:24 +00003262 }
3263 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003264
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003265 uint32_t synthetic_sym_id = symtab_load_command.nsyms;
3266
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003267 if (function_starts_count > 0)
3268 {
3269 char synthetic_function_symbol[PATH_MAX];
3270 uint32_t num_synthetic_function_symbols = 0;
3271 for (i=0; i<function_starts_count; ++i)
3272 {
3273 if (function_starts.GetEntryRef (i).data == false)
3274 ++num_synthetic_function_symbols;
3275 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003276
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003277 if (num_synthetic_function_symbols > 0)
3278 {
3279 if (num_syms < sym_idx + num_synthetic_function_symbols)
3280 {
3281 num_syms = sym_idx + num_synthetic_function_symbols;
3282 sym = symtab->Resize (num_syms);
3283 }
3284 uint32_t synthetic_function_symbol_idx = 0;
3285 for (i=0; i<function_starts_count; ++i)
3286 {
3287 const FunctionStarts::Entry *func_start_entry = function_starts.GetEntryAtIndex (i);
3288 if (func_start_entry->data == false)
3289 {
Greg Claytond2653c22012-03-14 01:53:24 +00003290 addr_t symbol_file_addr = func_start_entry->addr;
3291 uint32_t symbol_flags = 0;
3292 if (is_arm)
3293 {
3294 if (symbol_file_addr & 1)
3295 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
3296 symbol_file_addr &= 0xfffffffffffffffeull;
3297 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003298 Address symbol_addr;
Greg Claytond2653c22012-03-14 01:53:24 +00003299 if (module_sp->ResolveFileAddress (symbol_file_addr, symbol_addr))
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003300 {
3301 SectionSP symbol_section (symbol_addr.GetSection());
3302 uint32_t symbol_byte_size = 0;
3303 if (symbol_section)
3304 {
3305 const addr_t section_file_addr = symbol_section->GetFileAddress();
3306 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
3307 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
3308 if (next_func_start_entry)
3309 {
Greg Claytond2653c22012-03-14 01:53:24 +00003310 addr_t next_symbol_file_addr = next_func_start_entry->addr;
3311 if (is_arm)
3312 next_symbol_file_addr &= 0xfffffffffffffffeull;
3313 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003314 }
3315 else
3316 {
Greg Claytond2653c22012-03-14 01:53:24 +00003317 symbol_byte_size = section_end_file_addr - symbol_file_addr;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003318 }
3319 snprintf (synthetic_function_symbol,
3320 sizeof(synthetic_function_symbol),
3321 "___lldb_unnamed_function%u$$%s",
3322 ++synthetic_function_symbol_idx,
3323 module_sp->GetFileSpec().GetFilename().GetCString());
3324 sym[sym_idx].SetID (synthetic_sym_id++);
Greg Claytonc0240042012-07-18 23:18:10 +00003325 sym[sym_idx].GetMangled().SetDemangledName(ConstString(synthetic_function_symbol));
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003326 sym[sym_idx].SetType (eSymbolTypeCode);
3327 sym[sym_idx].SetIsSynthetic (true);
3328 sym[sym_idx].GetAddress() = symbol_addr;
Greg Claytond2653c22012-03-14 01:53:24 +00003329 if (symbol_flags)
3330 sym[sym_idx].SetFlags (symbol_flags);
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003331 if (symbol_byte_size)
3332 sym[sym_idx].SetByteSize (symbol_byte_size);
3333 ++sym_idx;
3334 }
3335 }
3336 }
3337 }
3338 }
3339 }
3340
3341 // Trim our symbols down to just what we ended up with after
3342 // removing any symbols.
3343 if (sym_idx < num_syms)
3344 {
3345 num_syms = sym_idx;
3346 sym = symtab->Resize (num_syms);
3347 }
3348
3349 // Now synthesize indirect symbols
3350 if (m_dysymtab.nindirectsyms != 0)
3351 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003352 if (indirect_symbol_index_data.GetByteSize())
3353 {
3354 NListIndexToSymbolIndexMap::const_iterator end_index_pos = m_nlist_idx_to_sym_idx.end();
3355
3356 for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size(); ++sect_idx)
3357 {
3358 if ((m_mach_sections[sect_idx].flags & SectionFlagMaskSectionType) == SectionTypeSymbolStubs)
3359 {
3360 uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2;
3361 if (symbol_stub_byte_size == 0)
3362 continue;
3363
3364 const uint32_t num_symbol_stubs = m_mach_sections[sect_idx].size / symbol_stub_byte_size;
3365
3366 if (num_symbol_stubs == 0)
3367 continue;
3368
3369 const uint32_t symbol_stub_index_offset = m_mach_sections[sect_idx].reserved1;
3370 for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx)
3371 {
3372 const uint32_t symbol_stub_index = symbol_stub_index_offset + stub_idx;
3373 const lldb::addr_t symbol_stub_addr = m_mach_sections[sect_idx].addr + (stub_idx * symbol_stub_byte_size);
Greg Clayton36da2aa2013-01-25 18:06:21 +00003374 lldb::offset_t symbol_stub_offset = symbol_stub_index * 4;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003375 if (indirect_symbol_index_data.ValidOffsetForDataOfSize(symbol_stub_offset, 4))
3376 {
3377 const uint32_t stub_sym_id = indirect_symbol_index_data.GetU32 (&symbol_stub_offset);
3378 if (stub_sym_id & (IndirectSymbolAbsolute | IndirectSymbolLocal))
3379 continue;
3380
3381 NListIndexToSymbolIndexMap::const_iterator index_pos = m_nlist_idx_to_sym_idx.find (stub_sym_id);
3382 Symbol *stub_symbol = NULL;
3383 if (index_pos != end_index_pos)
3384 {
3385 // We have a remapping from the original nlist index to
3386 // a current symbol index, so just look this up by index
3387 stub_symbol = symtab->SymbolAtIndex (index_pos->second);
3388 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003389 else
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003390 {
3391 // We need to lookup a symbol using the original nlist
Jason Molenda9badb6c2013-03-06 23:19:17 +00003392 // symbol index since this index is coming from the
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003393 // S_SYMBOL_STUBS
3394 stub_symbol = symtab->FindSymbolByID (stub_sym_id);
3395 }
3396
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003397 if (stub_symbol)
3398 {
3399 Address so_addr(symbol_stub_addr, section_list);
3400
3401 if (stub_symbol->GetType() == eSymbolTypeUndefined)
3402 {
3403 // Change the external symbol into a trampoline that makes sense
3404 // These symbols were N_UNDF N_EXT, and are useless to us, so we
3405 // can re-use them so we don't have to make up a synthetic symbol
3406 // for no good reason.
3407 stub_symbol->SetType (eSymbolTypeTrampoline);
3408 stub_symbol->SetExternal (false);
3409 stub_symbol->GetAddress() = so_addr;
3410 stub_symbol->SetByteSize (symbol_stub_byte_size);
3411 }
3412 else
3413 {
3414 // Make a synthetic symbol to describe the trampoline stub
Jason Molenda2a76fbf2012-04-24 02:09:58 +00003415 Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003416 if (sym_idx >= num_syms)
Jason Molenda2a76fbf2012-04-24 02:09:58 +00003417 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003418 sym = symtab->Resize (++num_syms);
Jason Molenda2a76fbf2012-04-24 02:09:58 +00003419 stub_symbol = NULL; // this pointer no longer valid
3420 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003421 sym[sym_idx].SetID (synthetic_sym_id++);
Jason Molenda2a76fbf2012-04-24 02:09:58 +00003422 sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003423 sym[sym_idx].SetType (eSymbolTypeTrampoline);
3424 sym[sym_idx].SetIsSynthetic (true);
3425 sym[sym_idx].GetAddress() = so_addr;
3426 sym[sym_idx].SetByteSize (symbol_stub_byte_size);
3427 ++sym_idx;
3428 }
3429 }
Greg Claytond4330e62012-09-05 01:38:55 +00003430 else
3431 {
3432 if (log)
3433 log->Warning ("symbol stub referencing symbol table symbol %u that isn't in our minimal symbol table, fix this!!!", stub_sym_id);
3434 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +00003435 }
3436 }
3437 }
3438 }
3439 }
3440 }
3441 return symtab->GetNumSymbols();
Chris Lattner24943d22010-06-08 16:52:24 +00003442 }
3443 return 0;
3444}
3445
3446
3447void
3448ObjectFileMachO::Dump (Stream *s)
3449{
Greg Clayton9482f052012-03-13 23:14:29 +00003450 ModuleSP module_sp(GetModule());
3451 if (module_sp)
3452 {
3453 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3454 s->Printf("%p: ", this);
3455 s->Indent();
3456 if (m_header.magic == HeaderMagic64 || m_header.magic == HeaderMagic64Swapped)
3457 s->PutCString("ObjectFileMachO64");
3458 else
3459 s->PutCString("ObjectFileMachO32");
Chris Lattner24943d22010-06-08 16:52:24 +00003460
Greg Clayton9482f052012-03-13 23:14:29 +00003461 ArchSpec header_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
Chris Lattner24943d22010-06-08 16:52:24 +00003462
Greg Clayton9482f052012-03-13 23:14:29 +00003463 *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n";
Chris Lattner24943d22010-06-08 16:52:24 +00003464
Greg Clayton9482f052012-03-13 23:14:29 +00003465 if (m_sections_ap.get())
3466 m_sections_ap->Dump(s, NULL, true, UINT32_MAX);
Chris Lattner24943d22010-06-08 16:52:24 +00003467
Greg Clayton9482f052012-03-13 23:14:29 +00003468 if (m_symtab_ap.get())
3469 m_symtab_ap->Dump(s, NULL, eSortOrderNone);
3470 }
Chris Lattner24943d22010-06-08 16:52:24 +00003471}
3472
3473
3474bool
Greg Clayton0467c782011-02-04 18:53:10 +00003475ObjectFileMachO::GetUUID (lldb_private::UUID* uuid)
Chris Lattner24943d22010-06-08 16:52:24 +00003476{
Greg Clayton9482f052012-03-13 23:14:29 +00003477 ModuleSP module_sp(GetModule());
3478 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00003479 {
Greg Clayton9482f052012-03-13 23:14:29 +00003480 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3481 struct uuid_command load_cmd;
Greg Clayton36da2aa2013-01-25 18:06:21 +00003482 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Greg Clayton9482f052012-03-13 23:14:29 +00003483 uint32_t i;
3484 for (i=0; i<m_header.ncmds; ++i)
Chris Lattner24943d22010-06-08 16:52:24 +00003485 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00003486 const lldb::offset_t cmd_offset = offset;
Greg Clayton9482f052012-03-13 23:14:29 +00003487 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3488 break;
3489
3490 if (load_cmd.cmd == LoadCommandUUID)
Chris Lattner24943d22010-06-08 16:52:24 +00003491 {
Greg Clayton9482f052012-03-13 23:14:29 +00003492 const uint8_t *uuid_bytes = m_data.PeekData(offset, 16);
Jason Molenda9badb6c2013-03-06 23:19:17 +00003493
Greg Clayton9482f052012-03-13 23:14:29 +00003494 if (uuid_bytes)
3495 {
Sean Callanana5689d52012-07-12 18:04:03 +00003496 // OpenCL on Mac OS X uses the same UUID for each of its object files.
3497 // We pretend these object files have no UUID to prevent crashing.
Jason Molenda9badb6c2013-03-06 23:19:17 +00003498
Sean Callanana5689d52012-07-12 18:04:03 +00003499 const uint8_t opencl_uuid[] = { 0x8c, 0x8e, 0xb3, 0x9b,
3500 0x3b, 0xa8,
3501 0x4b, 0x16,
3502 0xb6, 0xa4,
3503 0x27, 0x63, 0xbb, 0x14, 0xf0, 0x0d };
Jason Molenda9badb6c2013-03-06 23:19:17 +00003504
Sean Callanana5689d52012-07-12 18:04:03 +00003505 if (!memcmp(uuid_bytes, opencl_uuid, 16))
3506 return false;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003507
Greg Clayton9482f052012-03-13 23:14:29 +00003508 uuid->SetBytes (uuid_bytes);
3509 return true;
3510 }
3511 return false;
Chris Lattner24943d22010-06-08 16:52:24 +00003512 }
Greg Clayton9482f052012-03-13 23:14:29 +00003513 offset = cmd_offset + load_cmd.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +00003514 }
Chris Lattner24943d22010-06-08 16:52:24 +00003515 }
3516 return false;
3517}
3518
3519
3520uint32_t
3521ObjectFileMachO::GetDependentModules (FileSpecList& files)
3522{
Chris Lattner24943d22010-06-08 16:52:24 +00003523 uint32_t count = 0;
Greg Clayton9482f052012-03-13 23:14:29 +00003524 ModuleSP module_sp(GetModule());
3525 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +00003526 {
Greg Clayton9482f052012-03-13 23:14:29 +00003527 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3528 struct load_command load_cmd;
Greg Clayton36da2aa2013-01-25 18:06:21 +00003529 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Greg Clayton9482f052012-03-13 23:14:29 +00003530 const bool resolve_path = false; // Don't resolve the dependend file paths since they may not reside on this system
3531 uint32_t i;
3532 for (i=0; i<m_header.ncmds; ++i)
Chris Lattner24943d22010-06-08 16:52:24 +00003533 {
Greg Clayton9482f052012-03-13 23:14:29 +00003534 const uint32_t cmd_offset = offset;
3535 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3536 break;
Chris Lattner24943d22010-06-08 16:52:24 +00003537
Greg Clayton9482f052012-03-13 23:14:29 +00003538 switch (load_cmd.cmd)
3539 {
3540 case LoadCommandDylibLoad:
3541 case LoadCommandDylibLoadWeak:
3542 case LoadCommandDylibReexport:
3543 case LoadCommandDynamicLinkerLoad:
3544 case LoadCommandFixedVMShlibLoad:
3545 case LoadCommandDylibLoadUpward:
3546 {
3547 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
3548 const char *path = m_data.PeekCStr(name_offset);
3549 // Skip any path that starts with '@' since these are usually:
3550 // @executable_path/.../file
3551 // @rpath/.../file
3552 if (path && path[0] != '@')
3553 {
3554 FileSpec file_spec(path, resolve_path);
3555 if (files.AppendIfUnique(file_spec))
3556 count++;
3557 }
3558 }
3559 break;
3560
3561 default:
3562 break;
3563 }
3564 offset = cmd_offset + load_cmd.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +00003565 }
Chris Lattner24943d22010-06-08 16:52:24 +00003566 }
3567 return count;
3568}
3569
Jim Ingham28775942011-03-07 23:44:08 +00003570lldb_private::Address
Jason Molenda9badb6c2013-03-06 23:19:17 +00003571ObjectFileMachO::GetEntryPointAddress ()
Jim Ingham28775942011-03-07 23:44:08 +00003572{
3573 // If the object file is not an executable it can't hold the entry point. m_entry_point_address
3574 // is initialized to an invalid address, so we can just return that.
3575 // If m_entry_point_address is valid it means we've found it already, so return the cached value.
Jason Molenda9badb6c2013-03-06 23:19:17 +00003576
Jim Ingham28775942011-03-07 23:44:08 +00003577 if (!IsExecutable() || m_entry_point_address.IsValid())
3578 return m_entry_point_address;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003579
3580 // Otherwise, look for the UnixThread or Thread command. The data for the Thread command is given in
Jim Ingham28775942011-03-07 23:44:08 +00003581 // /usr/include/mach-o.h, but it is basically:
3582 //
3583 // uint32_t flavor - this is the flavor argument you would pass to thread_get_state
3584 // uint32_t count - this is the count of longs in the thread state data
3585 // struct XXX_thread_state state - this is the structure from <machine/thread_status.h> corresponding to the flavor.
3586 // <repeat this trio>
Jason Molenda9badb6c2013-03-06 23:19:17 +00003587 //
Jim Ingham28775942011-03-07 23:44:08 +00003588 // So we just keep reading the various register flavors till we find the GPR one, then read the PC out of there.
3589 // FIXME: We will need to have a "RegisterContext data provider" class at some point that can get all the registers
3590 // out of data in this form & attach them to a given thread. That should underlie the MacOS X User process plugin,
3591 // and we'll also need it for the MacOS X Core File process plugin. When we have that we can also use it here.
3592 //
3593 // For now we hard-code the offsets and flavors we need:
3594 //
3595 //
3596
Greg Clayton9482f052012-03-13 23:14:29 +00003597 ModuleSP module_sp(GetModule());
3598 if (module_sp)
Jim Ingham28775942011-03-07 23:44:08 +00003599 {
Greg Clayton9482f052012-03-13 23:14:29 +00003600 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3601 struct load_command load_cmd;
Greg Clayton36da2aa2013-01-25 18:06:21 +00003602 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Greg Clayton9482f052012-03-13 23:14:29 +00003603 uint32_t i;
3604 lldb::addr_t start_address = LLDB_INVALID_ADDRESS;
3605 bool done = false;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003606
Greg Clayton9482f052012-03-13 23:14:29 +00003607 for (i=0; i<m_header.ncmds; ++i)
Jim Ingham28775942011-03-07 23:44:08 +00003608 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00003609 const lldb::offset_t cmd_offset = offset;
Greg Clayton9482f052012-03-13 23:14:29 +00003610 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3611 break;
3612
3613 switch (load_cmd.cmd)
Jim Ingham28775942011-03-07 23:44:08 +00003614 {
Greg Clayton9482f052012-03-13 23:14:29 +00003615 case LoadCommandUnixThread:
3616 case LoadCommandThread:
Jim Ingham28775942011-03-07 23:44:08 +00003617 {
Greg Clayton9482f052012-03-13 23:14:29 +00003618 while (offset < cmd_offset + load_cmd.cmdsize)
Jim Ingham28775942011-03-07 23:44:08 +00003619 {
Greg Clayton9482f052012-03-13 23:14:29 +00003620 uint32_t flavor = m_data.GetU32(&offset);
3621 uint32_t count = m_data.GetU32(&offset);
3622 if (count == 0)
3623 {
3624 // We've gotten off somehow, log and exit;
3625 return m_entry_point_address;
Jim Ingham28775942011-03-07 23:44:08 +00003626 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003627
Greg Clayton9482f052012-03-13 23:14:29 +00003628 switch (m_header.cputype)
3629 {
3630 case llvm::MachO::CPUTypeARM:
3631 if (flavor == 1) // ARM_THREAD_STATE from mach/arm/thread_status.h
3632 {
3633 offset += 60; // This is the offset of pc in the GPR thread state data structure.
3634 start_address = m_data.GetU32(&offset);
3635 done = true;
3636 }
Jim Ingham28775942011-03-07 23:44:08 +00003637 break;
Greg Clayton9482f052012-03-13 23:14:29 +00003638 case llvm::MachO::CPUTypeI386:
3639 if (flavor == 1) // x86_THREAD_STATE32 from mach/i386/thread_status.h
3640 {
3641 offset += 40; // This is the offset of eip in the GPR thread state data structure.
3642 start_address = m_data.GetU32(&offset);
3643 done = true;
3644 }
3645 break;
3646 case llvm::MachO::CPUTypeX86_64:
3647 if (flavor == 4) // x86_THREAD_STATE64 from mach/i386/thread_status.h
3648 {
3649 offset += 16 * 8; // This is the offset of rip in the GPR thread state data structure.
3650 start_address = m_data.GetU64(&offset);
3651 done = true;
3652 }
3653 break;
3654 default:
3655 return m_entry_point_address;
3656 }
3657 // Haven't found the GPR flavor yet, skip over the data for this flavor:
3658 if (done)
3659 break;
3660 offset += count * 4;
3661 }
Jim Ingham28775942011-03-07 23:44:08 +00003662 }
Greg Clayton9482f052012-03-13 23:14:29 +00003663 break;
3664 case LoadCommandMain:
Sean Callanan6e12c7a2012-03-08 02:39:03 +00003665 {
Greg Clayton9482f052012-03-13 23:14:29 +00003666 ConstString text_segment_name ("__TEXT");
3667 uint64_t entryoffset = m_data.GetU64(&offset);
3668 SectionSP text_segment_sp = GetSectionList()->FindSectionByName(text_segment_name);
3669 if (text_segment_sp)
3670 {
3671 done = true;
3672 start_address = text_segment_sp->GetFileAddress() + entryoffset;
3673 }
Sean Callanan6e12c7a2012-03-08 02:39:03 +00003674 }
Greg Clayton9482f052012-03-13 23:14:29 +00003675
3676 default:
3677 break;
Sean Callanan6e12c7a2012-03-08 02:39:03 +00003678 }
Greg Clayton9482f052012-03-13 23:14:29 +00003679 if (done)
3680 break;
Jim Ingham28775942011-03-07 23:44:08 +00003681
Greg Clayton9482f052012-03-13 23:14:29 +00003682 // Go to the next load command:
3683 offset = cmd_offset + load_cmd.cmdsize;
Jim Ingham28775942011-03-07 23:44:08 +00003684 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003685
Greg Clayton9482f052012-03-13 23:14:29 +00003686 if (start_address != LLDB_INVALID_ADDRESS)
Greg Clayton3508c382012-02-24 01:59:29 +00003687 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00003688 // We got the start address from the load commands, so now resolve that address in the sections
Greg Clayton9482f052012-03-13 23:14:29 +00003689 // of this ObjectFile:
3690 if (!m_entry_point_address.ResolveAddressUsingFileSections (start_address, GetSectionList()))
Greg Clayton3508c382012-02-24 01:59:29 +00003691 {
Greg Clayton9482f052012-03-13 23:14:29 +00003692 m_entry_point_address.Clear();
3693 }
3694 }
3695 else
3696 {
3697 // We couldn't read the UnixThread load command - maybe it wasn't there. As a fallback look for the
3698 // "start" symbol in the main executable.
Jason Molenda9badb6c2013-03-06 23:19:17 +00003699
Greg Clayton9482f052012-03-13 23:14:29 +00003700 ModuleSP module_sp (GetModule());
Jason Molenda9badb6c2013-03-06 23:19:17 +00003701
Greg Clayton9482f052012-03-13 23:14:29 +00003702 if (module_sp)
3703 {
3704 SymbolContextList contexts;
3705 SymbolContext context;
3706 if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), eSymbolTypeCode, contexts))
3707 {
3708 if (contexts.GetContextAtIndex(0, context))
3709 m_entry_point_address = context.symbol->GetAddress();
3710 }
Greg Clayton3508c382012-02-24 01:59:29 +00003711 }
3712 }
Jim Ingham28775942011-03-07 23:44:08 +00003713 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003714
Jim Ingham28775942011-03-07 23:44:08 +00003715 return m_entry_point_address;
3716
3717}
3718
Greg Claytonb5a8f142012-02-05 02:38:54 +00003719lldb_private::Address
3720ObjectFileMachO::GetHeaderAddress ()
3721{
3722 lldb_private::Address header_addr;
3723 SectionList *section_list = GetSectionList();
3724 if (section_list)
3725 {
3726 SectionSP text_segment_sp (section_list->FindSectionByName (GetSegmentNameTEXT()));
3727 if (text_segment_sp)
3728 {
Greg Clayton3508c382012-02-24 01:59:29 +00003729 header_addr.SetSection (text_segment_sp);
Greg Claytonb5a8f142012-02-05 02:38:54 +00003730 header_addr.SetOffset (0);
3731 }
3732 }
3733 return header_addr;
3734}
3735
Greg Clayton46c9a352012-02-09 06:16:32 +00003736uint32_t
3737ObjectFileMachO::GetNumThreadContexts ()
3738{
Greg Clayton9482f052012-03-13 23:14:29 +00003739 ModuleSP module_sp(GetModule());
3740 if (module_sp)
Greg Clayton46c9a352012-02-09 06:16:32 +00003741 {
Greg Clayton9482f052012-03-13 23:14:29 +00003742 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3743 if (!m_thread_context_offsets_valid)
Greg Clayton46c9a352012-02-09 06:16:32 +00003744 {
Greg Clayton9482f052012-03-13 23:14:29 +00003745 m_thread_context_offsets_valid = true;
Greg Clayton36da2aa2013-01-25 18:06:21 +00003746 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Greg Clayton9482f052012-03-13 23:14:29 +00003747 FileRangeArray::Entry file_range;
3748 thread_command thread_cmd;
3749 for (uint32_t i=0; i<m_header.ncmds; ++i)
Greg Clayton46c9a352012-02-09 06:16:32 +00003750 {
Greg Clayton9482f052012-03-13 23:14:29 +00003751 const uint32_t cmd_offset = offset;
3752 if (m_data.GetU32(&offset, &thread_cmd, 2) == NULL)
3753 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003754
Greg Clayton9482f052012-03-13 23:14:29 +00003755 if (thread_cmd.cmd == LoadCommandThread)
3756 {
3757 file_range.SetRangeBase (offset);
3758 file_range.SetByteSize (thread_cmd.cmdsize - 8);
3759 m_thread_context_offsets.Append (file_range);
3760 }
3761 offset = cmd_offset + thread_cmd.cmdsize;
Greg Clayton46c9a352012-02-09 06:16:32 +00003762 }
Greg Clayton46c9a352012-02-09 06:16:32 +00003763 }
3764 }
3765 return m_thread_context_offsets.GetSize();
3766}
3767
3768lldb::RegisterContextSP
3769ObjectFileMachO::GetThreadContextAtIndex (uint32_t idx, lldb_private::Thread &thread)
3770{
Greg Clayton46c9a352012-02-09 06:16:32 +00003771 lldb::RegisterContextSP reg_ctx_sp;
Greg Clayton9ce95382012-02-13 23:10:39 +00003772
Greg Clayton9482f052012-03-13 23:14:29 +00003773 ModuleSP module_sp(GetModule());
3774 if (module_sp)
Greg Clayton46c9a352012-02-09 06:16:32 +00003775 {
Greg Clayton9482f052012-03-13 23:14:29 +00003776 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3777 if (!m_thread_context_offsets_valid)
3778 GetNumThreadContexts ();
3779
3780 const FileRangeArray::Entry *thread_context_file_range = m_thread_context_offsets.GetEntryAtIndex (idx);
Jim Ingham6f01c932012-10-12 17:34:26 +00003781 if (thread_context_file_range)
Greg Clayton9482f052012-03-13 23:14:29 +00003782 {
Jason Molenda9badb6c2013-03-06 23:19:17 +00003783
3784 DataExtractor data (m_data,
3785 thread_context_file_range->GetRangeBase(),
Jim Ingham6f01c932012-10-12 17:34:26 +00003786 thread_context_file_range->GetByteSize());
3787
3788 switch (m_header.cputype)
3789 {
3790 case llvm::MachO::CPUTypeARM:
3791 reg_ctx_sp.reset (new RegisterContextDarwin_arm_Mach (thread, data));
3792 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003793
Jim Ingham6f01c932012-10-12 17:34:26 +00003794 case llvm::MachO::CPUTypeI386:
3795 reg_ctx_sp.reset (new RegisterContextDarwin_i386_Mach (thread, data));
3796 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003797
Jim Ingham6f01c932012-10-12 17:34:26 +00003798 case llvm::MachO::CPUTypeX86_64:
3799 reg_ctx_sp.reset (new RegisterContextDarwin_x86_64_Mach (thread, data));
3800 break;
3801 }
Greg Clayton9482f052012-03-13 23:14:29 +00003802 }
Greg Clayton46c9a352012-02-09 06:16:32 +00003803 }
3804 return reg_ctx_sp;
3805}
3806
Greg Claytonb5a8f142012-02-05 02:38:54 +00003807
Greg Claytonca319972011-07-09 00:41:34 +00003808ObjectFile::Type
3809ObjectFileMachO::CalculateType()
3810{
3811 switch (m_header.filetype)
3812 {
3813 case HeaderFileTypeObject: // 0x1u MH_OBJECT
3814 if (GetAddressByteSize () == 4)
3815 {
3816 // 32 bit kexts are just object files, but they do have a valid
3817 // UUID load command.
3818 UUID uuid;
3819 if (GetUUID(&uuid))
3820 {
3821 // this checking for the UUID load command is not enough
Jason Molenda9badb6c2013-03-06 23:19:17 +00003822 // we could eventually look for the symbol named
Greg Claytonca319972011-07-09 00:41:34 +00003823 // "OSKextGetCurrentIdentifier" as this is required of kexts
3824 if (m_strata == eStrataInvalid)
3825 m_strata = eStrataKernel;
3826 return eTypeSharedLibrary;
3827 }
3828 }
3829 return eTypeObjectFile;
3830
3831 case HeaderFileTypeExecutable: return eTypeExecutable; // 0x2u MH_EXECUTE
3832 case HeaderFileTypeFixedVMShlib: return eTypeSharedLibrary; // 0x3u MH_FVMLIB
3833 case HeaderFileTypeCore: return eTypeCoreFile; // 0x4u MH_CORE
3834 case HeaderFileTypePreloadedExecutable: return eTypeSharedLibrary; // 0x5u MH_PRELOAD
3835 case HeaderFileTypeDynamicShlib: return eTypeSharedLibrary; // 0x6u MH_DYLIB
3836 case HeaderFileTypeDynamicLinkEditor: return eTypeDynamicLinker; // 0x7u MH_DYLINKER
3837 case HeaderFileTypeBundle: return eTypeSharedLibrary; // 0x8u MH_BUNDLE
3838 case HeaderFileTypeDynamicShlibStub: return eTypeStubLibrary; // 0x9u MH_DYLIB_STUB
3839 case HeaderFileTypeDSYM: return eTypeDebugInfo; // 0xAu MH_DSYM
3840 case HeaderFileTypeKextBundle: return eTypeSharedLibrary; // 0xBu MH_KEXT_BUNDLE
3841 default:
3842 break;
3843 }
3844 return eTypeUnknown;
3845}
3846
3847ObjectFile::Strata
3848ObjectFileMachO::CalculateStrata()
3849{
3850 switch (m_header.filetype)
3851 {
3852 case HeaderFileTypeObject: // 0x1u MH_OBJECT
3853 {
3854 // 32 bit kexts are just object files, but they do have a valid
3855 // UUID load command.
3856 UUID uuid;
3857 if (GetUUID(&uuid))
3858 {
3859 // this checking for the UUID load command is not enough
Jason Molenda9badb6c2013-03-06 23:19:17 +00003860 // we could eventually look for the symbol named
Greg Claytonca319972011-07-09 00:41:34 +00003861 // "OSKextGetCurrentIdentifier" as this is required of kexts
3862 if (m_type == eTypeInvalid)
3863 m_type = eTypeSharedLibrary;
3864
3865 return eStrataKernel;
3866 }
3867 }
3868 return eStrataUnknown;
3869
3870 case HeaderFileTypeExecutable: // 0x2u MH_EXECUTE
3871 // Check for the MH_DYLDLINK bit in the flags
3872 if (m_header.flags & HeaderFlagBitIsDynamicLinkObject)
Sean Callananac725af2012-02-10 20:22:35 +00003873 {
Greg Claytonca319972011-07-09 00:41:34 +00003874 return eStrataUser;
Sean Callananac725af2012-02-10 20:22:35 +00003875 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003876 else
Sean Callananac725af2012-02-10 20:22:35 +00003877 {
3878 SectionList *section_list = GetSectionList();
3879 if (section_list)
3880 {
3881 static ConstString g_kld_section_name ("__KLD");
3882 if (section_list->FindSectionByName(g_kld_section_name))
3883 return eStrataKernel;
3884 }
3885 }
3886 return eStrataRawImage;
Greg Claytonca319972011-07-09 00:41:34 +00003887
3888 case HeaderFileTypeFixedVMShlib: return eStrataUser; // 0x3u MH_FVMLIB
3889 case HeaderFileTypeCore: return eStrataUnknown; // 0x4u MH_CORE
Sean Callananac725af2012-02-10 20:22:35 +00003890 case HeaderFileTypePreloadedExecutable: return eStrataRawImage; // 0x5u MH_PRELOAD
Greg Claytonca319972011-07-09 00:41:34 +00003891 case HeaderFileTypeDynamicShlib: return eStrataUser; // 0x6u MH_DYLIB
3892 case HeaderFileTypeDynamicLinkEditor: return eStrataUser; // 0x7u MH_DYLINKER
3893 case HeaderFileTypeBundle: return eStrataUser; // 0x8u MH_BUNDLE
3894 case HeaderFileTypeDynamicShlibStub: return eStrataUser; // 0x9u MH_DYLIB_STUB
3895 case HeaderFileTypeDSYM: return eStrataUnknown; // 0xAu MH_DSYM
3896 case HeaderFileTypeKextBundle: return eStrataKernel; // 0xBu MH_KEXT_BUNDLE
3897 default:
3898 break;
3899 }
3900 return eStrataUnknown;
3901}
3902
3903
Greg Clayton49f4bf22012-02-22 19:41:02 +00003904uint32_t
3905ObjectFileMachO::GetVersion (uint32_t *versions, uint32_t num_versions)
3906{
Greg Clayton9482f052012-03-13 23:14:29 +00003907 ModuleSP module_sp(GetModule());
3908 if (module_sp)
Greg Clayton49f4bf22012-02-22 19:41:02 +00003909 {
Greg Clayton9482f052012-03-13 23:14:29 +00003910 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3911 struct dylib_command load_cmd;
Greg Clayton36da2aa2013-01-25 18:06:21 +00003912 lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
Greg Clayton9482f052012-03-13 23:14:29 +00003913 uint32_t version_cmd = 0;
3914 uint64_t version = 0;
3915 uint32_t i;
3916 for (i=0; i<m_header.ncmds; ++i)
Greg Clayton49f4bf22012-02-22 19:41:02 +00003917 {
Greg Clayton36da2aa2013-01-25 18:06:21 +00003918 const lldb::offset_t cmd_offset = offset;
Greg Clayton9482f052012-03-13 23:14:29 +00003919 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3920 break;
Jason Molenda9badb6c2013-03-06 23:19:17 +00003921
Greg Clayton9482f052012-03-13 23:14:29 +00003922 if (load_cmd.cmd == LoadCommandDylibIdent)
Greg Clayton49f4bf22012-02-22 19:41:02 +00003923 {
Greg Clayton9482f052012-03-13 23:14:29 +00003924 if (version_cmd == 0)
3925 {
3926 version_cmd = load_cmd.cmd;
3927 if (m_data.GetU32(&offset, &load_cmd.dylib, 4) == NULL)
3928 break;
3929 version = load_cmd.dylib.current_version;
3930 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003931 break; // Break for now unless there is another more complete version
Greg Clayton9482f052012-03-13 23:14:29 +00003932 // number load command in the future.
Greg Clayton49f4bf22012-02-22 19:41:02 +00003933 }
Greg Clayton9482f052012-03-13 23:14:29 +00003934 offset = cmd_offset + load_cmd.cmdsize;
Greg Clayton49f4bf22012-02-22 19:41:02 +00003935 }
Jason Molenda9badb6c2013-03-06 23:19:17 +00003936
Greg Clayton9482f052012-03-13 23:14:29 +00003937 if (version_cmd == LoadCommandDylibIdent)
Greg Clayton49f4bf22012-02-22 19:41:02 +00003938 {
Greg Clayton9482f052012-03-13 23:14:29 +00003939 if (versions != NULL && num_versions > 0)
3940 {
3941 if (num_versions > 0)
3942 versions[0] = (version & 0xFFFF0000ull) >> 16;
3943 if (num_versions > 1)
3944 versions[1] = (version & 0x0000FF00ull) >> 8;
3945 if (num_versions > 2)
3946 versions[2] = (version & 0x000000FFull);
3947 // Fill in an remaining version numbers with invalid values
3948 for (i=3; i<num_versions; ++i)
3949 versions[i] = UINT32_MAX;
3950 }
3951 // The LC_ID_DYLIB load command has a version with 3 version numbers
3952 // in it, so always return 3
3953 return 3;
Greg Clayton49f4bf22012-02-22 19:41:02 +00003954 }
Greg Clayton49f4bf22012-02-22 19:41:02 +00003955 }
3956 return false;
3957}
3958
Chris Lattner24943d22010-06-08 16:52:24 +00003959bool
Greg Clayton395fc332011-02-15 21:59:32 +00003960ObjectFileMachO::GetArchitecture (ArchSpec &arch)
Chris Lattner24943d22010-06-08 16:52:24 +00003961{
Greg Clayton9482f052012-03-13 23:14:29 +00003962 ModuleSP module_sp(GetModule());
3963 if (module_sp)
Greg Clayton6a64bbf2011-09-21 03:57:31 +00003964 {
Greg Clayton9482f052012-03-13 23:14:29 +00003965 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3966 arch.SetArchitecture (eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
Jason Molenda9badb6c2013-03-06 23:19:17 +00003967
Greg Clayton9482f052012-03-13 23:14:29 +00003968 // Files with type MH_PRELOAD are currently used in cases where the image
Jason Molenda9badb6c2013-03-06 23:19:17 +00003969 // debugs at the addresses in the file itself. Below we set the OS to
Greg Clayton9482f052012-03-13 23:14:29 +00003970 // unknown to make sure we use the DynamicLoaderStatic()...
3971 if (m_header.filetype == HeaderFileTypePreloadedExecutable)
3972 {
3973 arch.GetTriple().setOS (llvm::Triple::UnknownOS);
3974 }
3975 return true;
Greg Clayton6a64bbf2011-09-21 03:57:31 +00003976 }
Greg Clayton9482f052012-03-13 23:14:29 +00003977 return false;
Chris Lattner24943d22010-06-08 16:52:24 +00003978}
3979
3980
Jason Molenda45c75502013-04-16 06:24:42 +00003981UUID
3982ObjectFileMachO::GetProcessSharedCacheUUID (Process *process)
3983{
3984 UUID uuid;
3985 if (process)
3986 {
3987 addr_t all_image_infos = process->GetImageInfoAddress();
3988
3989 // The address returned by GetImageInfoAddress may be the address of dyld (don't want)
3990 // or it may be the address of the dyld_all_image_infos structure (want). The first four
3991 // bytes will be either the version field (all_image_infos) or a Mach-O file magic constant.
3992 // Version 13 and higher of dyld_all_image_infos is required to get the sharedCacheUUID field.
3993
3994 Error err;
3995 uint32_t version_or_magic = process->ReadUnsignedIntegerFromMemory (all_image_infos, 4, -1, err);
3996 if (version_or_magic != -1
3997 && version_or_magic != HeaderMagic32
3998 && version_or_magic != HeaderMagic32Swapped
3999 && version_or_magic != HeaderMagic64
4000 && version_or_magic != HeaderMagic64Swapped
4001 && version_or_magic >= 13)
4002 {
4003 addr_t sharedCacheUUID_address = LLDB_INVALID_ADDRESS;
4004 int wordsize = process->GetAddressByteSize();
4005 if (wordsize == 8)
4006 {
4007 sharedCacheUUID_address = all_image_infos + 160; // sharedCacheUUID <mach-o/dyld_images.h>
4008 }
4009 if (wordsize == 4)
4010 {
4011 sharedCacheUUID_address = all_image_infos + 84; // sharedCacheUUID <mach-o/dyld_images.h>
4012 }
4013 if (sharedCacheUUID_address != LLDB_INVALID_ADDRESS)
4014 {
4015 uuid_t shared_cache_uuid;
4016 if (process->ReadMemory (sharedCacheUUID_address, shared_cache_uuid, sizeof (uuid_t), err) == sizeof (uuid_t))
4017 {
4018 uuid.SetBytes (shared_cache_uuid);
4019 }
4020 }
4021 }
4022 }
4023 return uuid;
4024}
4025
4026UUID
4027ObjectFileMachO::GetLLDBSharedCacheUUID ()
4028{
4029 UUID uuid;
4030#if defined (__APPLE__) && defined (__arm__)
4031 uint8_t *(*dyld_get_all_image_infos)(void);
4032 dyld_get_all_image_infos = (uint8_t*(*)()) dlsym (RTLD_DEFAULT, "_dyld_get_all_image_infos");
4033 if (dyld_get_all_image_infos)
4034 {
4035 uint8_t *dyld_all_image_infos_address = dyld_get_all_image_infos();
4036 if (dyld_all_image_infos_address)
4037 {
4038 uint32_t version;
4039 memcpy (&version, dyld_all_image_infos_address, 4);
4040 if (version >= 13)
4041 {
4042 uint8_t *sharedCacheUUID_address = 0;
4043 sharedCacheUUID_address = dyld_all_image_infos_address + 84; // sharedCacheUUID <mach-o/dyld_images.h>
4044 uuid.SetBytes (sharedCacheUUID_address);
4045 }
4046 }
4047 }
4048#endif
4049 return uuid;
4050}
4051
4052
Chris Lattner24943d22010-06-08 16:52:24 +00004053//------------------------------------------------------------------
4054// PluginInterface protocol
4055//------------------------------------------------------------------
4056const char *
4057ObjectFileMachO::GetPluginName()
4058{
4059 return "ObjectFileMachO";
4060}
4061
4062const char *
4063ObjectFileMachO::GetShortPluginName()
4064{
4065 return GetPluginNameStatic();
4066}
4067
4068uint32_t
4069ObjectFileMachO::GetPluginVersion()
4070{
4071 return 1;
4072}
4073