Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / lldb / 292cca834d6ce7e78509e3bf09b7d1a4bc6614e9 / . / source / Plugins / ObjectFile / Mach-O / ObjectFileMachO.cpp
blob: cd0f10f9ee555cb87c30f7f051f6a8e878015bfc [file] [log] [blame]
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1//===-- ObjectFileMachO.cpp -------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]10#include "llvm/ADT/StringRef.h"
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]11#include "llvm/Support/MachO.h"
12
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]13#include "ObjectFileMachO.h"
14
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]15#include "lldb/Core/ArchSpec.h"
16#include "lldb/Core/DataBuffer.h"
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]17#include "lldb/Core/FileSpecList.h"
18#include "lldb/Core/Module.h"
19#include "lldb/Core/PluginManager.h"
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]20#include "lldb/Core/RangeMap.h"
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]21#include "lldb/Core/Section.h"
22#include "lldb/Core/StreamFile.h"
23#include "lldb/Core/StreamString.h"
24#include "lldb/Core/Timer.h"
25#include "lldb/Core/UUID.h"
Greg Claytondf6dc882012-01-05 03:57:59 +0000[diff] [blame]26#include "lldb/Host/Host.h"
27#include "lldb/Host/FileSpec.h"
Sean Callanan3e80cd92011-10-12 02:08:07 +0000[diff] [blame]28#include "lldb/Symbol/ClangNamespaceDecl.h"
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]29#include "lldb/Symbol/ObjectFile.h"
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]30#include "lldb/Target/Platform.h"
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]31#include "lldb/Target/Process.h"
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]32#include "lldb/Target/Target.h"
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]33#include "Plugins/Process/Utility/RegisterContextDarwin_arm.h"
34#include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]35#include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]36
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]37using namespace lldb;
38using namespace lldb_private;
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]39using namespace llvm::MachO;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]40
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]41class RegisterContextDarwin_x86_64_Mach : public RegisterContextDarwin_x86_64
42{
43public:
44 RegisterContextDarwin_x86_64_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
45 RegisterContextDarwin_x86_64 (thread, 0)
46 {
47 SetRegisterDataFrom_LC_THREAD (data);
48 }
49
50 virtual void
51 InvalidateAllRegisters ()
52 {
53 // Do nothing... registers are always valid...
54 }
55
56 void
57 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
58 {
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]59 uint32_t offset = 0;
60 SetError (GPRRegSet, Read, -1);
61 SetError (FPURegSet, Read, -1);
62 SetError (EXCRegSet, Read, -1);
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]63 bool done = false;
64
65 while (!done)
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]66 {
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]67 int flavor = data.GetU32 (&offset);
68 if (flavor == 0)
69 done = true;
70 else
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]71 {
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]72 uint32_t i;
73 uint32_t count = data.GetU32 (&offset);
74 switch (flavor)
75 {
76 case GPRRegSet:
77 for (i=0; i<count; ++i)
78 (&gpr.rax)[i] = data.GetU64(&offset);
79 SetError (GPRRegSet, Read, 0);
80 done = true;
81
82 break;
83 case FPURegSet:
84 // TODO: fill in FPU regs....
85 //SetError (FPURegSet, Read, -1);
86 done = true;
87
88 break;
89 case EXCRegSet:
90 exc.trapno = data.GetU32(&offset);
91 exc.err = data.GetU32(&offset);
92 exc.faultvaddr = data.GetU64(&offset);
93 SetError (EXCRegSet, Read, 0);
94 done = true;
95 break;
96 case 7:
97 case 8:
98 case 9:
99 // fancy flavors that encapsulate of the the above
100 // falvors...
101 break;
102
103 default:
104 done = true;
105 break;
106 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]107 }
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]108 }
109 }
110protected:
111 virtual int
112 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
113 {
114 return 0;
115 }
116
117 virtual int
118 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
119 {
120 return 0;
121 }
122
123 virtual int
124 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
125 {
126 return 0;
127 }
128
129 virtual int
130 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
131 {
132 return 0;
133 }
134
135 virtual int
136 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
137 {
138 return 0;
139 }
140
141 virtual int
142 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
143 {
144 return 0;
145 }
146};
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]147
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]148
149class RegisterContextDarwin_i386_Mach : public RegisterContextDarwin_i386
150{
151public:
152 RegisterContextDarwin_i386_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
153 RegisterContextDarwin_i386 (thread, 0)
154 {
155 SetRegisterDataFrom_LC_THREAD (data);
156 }
157
158 virtual void
159 InvalidateAllRegisters ()
160 {
161 // Do nothing... registers are always valid...
162 }
163
164 void
165 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
166 {
167 uint32_t offset = 0;
168 SetError (GPRRegSet, Read, -1);
169 SetError (FPURegSet, Read, -1);
170 SetError (EXCRegSet, Read, -1);
171 bool done = false;
172
173 while (!done)
174 {
175 int flavor = data.GetU32 (&offset);
176 if (flavor == 0)
177 done = true;
178 else
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]179 {
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]180 uint32_t i;
181 uint32_t count = data.GetU32 (&offset);
182 switch (flavor)
183 {
184 case GPRRegSet:
185 for (i=0; i<count; ++i)
186 (&gpr.eax)[i] = data.GetU32(&offset);
187 SetError (GPRRegSet, Read, 0);
188 done = true;
189
190 break;
191 case FPURegSet:
192 // TODO: fill in FPU regs....
193 //SetError (FPURegSet, Read, -1);
194 done = true;
195
196 break;
197 case EXCRegSet:
198 exc.trapno = data.GetU32(&offset);
199 exc.err = data.GetU32(&offset);
200 exc.faultvaddr = data.GetU32(&offset);
201 SetError (EXCRegSet, Read, 0);
202 done = true;
203 break;
204 case 7:
205 case 8:
206 case 9:
207 // fancy flavors that encapsulate of the the above
208 // falvors...
209 break;
210
211 default:
212 done = true;
213 break;
214 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]215 }
216 }
217 }
218protected:
219 virtual int
220 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
221 {
222 return 0;
223 }
224
225 virtual int
226 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
227 {
228 return 0;
229 }
230
231 virtual int
232 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
233 {
234 return 0;
235 }
236
237 virtual int
238 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
239 {
240 return 0;
241 }
242
243 virtual int
244 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
245 {
246 return 0;
247 }
248
249 virtual int
250 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
251 {
252 return 0;
253 }
254};
255
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]256class RegisterContextDarwin_arm_Mach : public RegisterContextDarwin_arm
257{
258public:
259 RegisterContextDarwin_arm_Mach (lldb_private::Thread &thread, const DataExtractor &data) :
260 RegisterContextDarwin_arm (thread, 0)
261 {
262 SetRegisterDataFrom_LC_THREAD (data);
263 }
264
265 virtual void
266 InvalidateAllRegisters ()
267 {
268 // Do nothing... registers are always valid...
269 }
270
271 void
272 SetRegisterDataFrom_LC_THREAD (const DataExtractor &data)
273 {
274 uint32_t offset = 0;
275 SetError (GPRRegSet, Read, -1);
276 SetError (FPURegSet, Read, -1);
277 SetError (EXCRegSet, Read, -1);
278 int flavor = data.GetU32 (&offset);
279 uint32_t count = data.GetU32 (&offset);
280 switch (flavor)
281 {
282 case GPRRegSet:
283 for (uint32_t i=0; i<count; ++i)
284 gpr.r[i] = data.GetU32(&offset);
285 SetError (GPRRegSet, Read, 0);
286 break;
287 case FPURegSet:
288 // TODO: fill in FPU regs....
289 //SetError (FPURegSet, Read, -1);
290 break;
291 case EXCRegSet:
292 exc.exception = data.GetU32(&offset);
293 exc.fsr = data.GetU32(&offset);
294 exc.far = data.GetU32(&offset);
295 SetError (EXCRegSet, Read, 0);
296 break;
297 }
298 }
299protected:
300 virtual int
301 DoReadGPR (lldb::tid_t tid, int flavor, GPR &gpr)
302 {
303 return 0;
304 }
305
306 virtual int
307 DoReadFPU (lldb::tid_t tid, int flavor, FPU &fpu)
308 {
309 return 0;
310 }
311
312 virtual int
313 DoReadEXC (lldb::tid_t tid, int flavor, EXC &exc)
314 {
315 return 0;
316 }
317
318 virtual int
319 DoWriteGPR (lldb::tid_t tid, int flavor, const GPR &gpr)
320 {
321 return 0;
322 }
323
324 virtual int
325 DoWriteFPU (lldb::tid_t tid, int flavor, const FPU &fpu)
326 {
327 return 0;
328 }
329
330 virtual int
331 DoWriteEXC (lldb::tid_t tid, int flavor, const EXC &exc)
332 {
333 return 0;
334 }
335};
336
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]337#define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]338
339void
340ObjectFileMachO::Initialize()
341{
342 PluginManager::RegisterPlugin (GetPluginNameStatic(),
343 GetPluginDescriptionStatic(),
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]344 CreateInstance,
345 CreateMemoryInstance);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]346}
347
348void
349ObjectFileMachO::Terminate()
350{
351 PluginManager::UnregisterPlugin (CreateInstance);
352}
353
354
355const char *
356ObjectFileMachO::GetPluginNameStatic()
357{
358 return "object-file.mach-o";
359}
360
361const char *
362ObjectFileMachO::GetPluginDescriptionStatic()
363{
364 return "Mach-o object file reader (32 and 64 bit)";
365}
366
367
368ObjectFile *
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]369ObjectFileMachO::CreateInstance (const lldb::ModuleSP &module_sp, DataBufferSP& data_sp, const FileSpec* file, addr_t offset, addr_t length)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]370{
Greg Claytondb2dc2b2012-01-12 05:25:17 +0000[diff] [blame]371 if (ObjectFileMachO::MagicBytesMatch(data_sp, offset, length))
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]372 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]373 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, file, offset, length));
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]374 if (objfile_ap.get() && objfile_ap->ParseHeader())
375 return objfile_ap.release();
376 }
377 return NULL;
378}
379
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]380ObjectFile *
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]381ObjectFileMachO::CreateMemoryInstance (const lldb::ModuleSP &module_sp,
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]382 DataBufferSP& data_sp,
383 const ProcessSP &process_sp,
384 lldb::addr_t header_addr)
385{
386 if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
387 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]388 std::auto_ptr<ObjectFile> objfile_ap(new ObjectFileMachO (module_sp, data_sp, process_sp, header_addr));
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]389 if (objfile_ap.get() && objfile_ap->ParseHeader())
390 return objfile_ap.release();
391 }
392 return NULL;
393}
394
395
396const ConstString &
397ObjectFileMachO::GetSegmentNameTEXT()
398{
399 static ConstString g_segment_name_TEXT ("__TEXT");
400 return g_segment_name_TEXT;
401}
402
403const ConstString &
404ObjectFileMachO::GetSegmentNameDATA()
405{
406 static ConstString g_segment_name_DATA ("__DATA");
407 return g_segment_name_DATA;
408}
409
410const ConstString &
411ObjectFileMachO::GetSegmentNameOBJC()
412{
413 static ConstString g_segment_name_OBJC ("__OBJC");
414 return g_segment_name_OBJC;
415}
416
417const ConstString &
418ObjectFileMachO::GetSegmentNameLINKEDIT()
419{
420 static ConstString g_section_name_LINKEDIT ("__LINKEDIT");
421 return g_section_name_LINKEDIT;
422}
423
424const ConstString &
425ObjectFileMachO::GetSectionNameEHFrame()
426{
427 static ConstString g_section_name_eh_frame ("__eh_frame");
428 return g_section_name_eh_frame;
429}
430
431
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]432
433static uint32_t
434MachHeaderSizeFromMagic(uint32_t magic)
435{
436 switch (magic)
437 {
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]438 case HeaderMagic32:
439 case HeaderMagic32Swapped:
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]440 return sizeof(struct mach_header);
441
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]442 case HeaderMagic64:
443 case HeaderMagic64Swapped:
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]444 return sizeof(struct mach_header_64);
445 break;
446
447 default:
448 break;
449 }
450 return 0;
451}
452
453
454bool
Greg Claytondb2dc2b2012-01-12 05:25:17 +0000[diff] [blame]455ObjectFileMachO::MagicBytesMatch (DataBufferSP& data_sp,
456 lldb::addr_t data_offset,
457 lldb::addr_t data_length)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]458{
Greg Claytondb2dc2b2012-01-12 05:25:17 +0000[diff] [blame]459 DataExtractor data;
460 data.SetData (data_sp, data_offset, data_length);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]461 uint32_t offset = 0;
462 uint32_t magic = data.GetU32(&offset);
463 return MachHeaderSizeFromMagic(magic) != 0;
464}
465
466
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]467ObjectFileMachO::ObjectFileMachO(const lldb::ModuleSP &module_sp, DataBufferSP& data_sp, const FileSpec* file, addr_t offset, addr_t length) :
468 ObjectFile(module_sp, file, offset, length, data_sp),
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]469 m_sections_ap(),
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]470 m_symtab_ap(),
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]471 m_mach_segments(),
472 m_mach_sections(),
473 m_entry_point_address(),
474 m_thread_context_offsets(),
475 m_thread_context_offsets_valid(false)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]476{
Greg Claytonddff7cc2011-02-04 21:13:05 +0000[diff] [blame]477 ::memset (&m_header, 0, sizeof(m_header));
478 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]479}
480
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]481ObjectFileMachO::ObjectFileMachO (const lldb::ModuleSP &module_sp,
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]482 lldb::DataBufferSP& header_data_sp,
483 const lldb::ProcessSP &process_sp,
484 lldb::addr_t header_addr) :
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]485 ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]486 m_sections_ap(),
487 m_symtab_ap(),
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]488 m_mach_segments(),
489 m_mach_sections(),
490 m_entry_point_address(),
491 m_thread_context_offsets(),
492 m_thread_context_offsets_valid(false)
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]493{
494 ::memset (&m_header, 0, sizeof(m_header));
495 ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
496}
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]497
498ObjectFileMachO::~ObjectFileMachO()
499{
500}
501
502
503bool
504ObjectFileMachO::ParseHeader ()
505{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]506 ModuleSP module_sp(GetModule());
507 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]508 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]509 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
510 bool can_parse = false;
511 uint32_t offset = 0;
Greg Claytoncd548032011-02-01 01:31:41 +0000[diff] [blame]512 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]513 // Leave magic in the original byte order
514 m_header.magic = m_data.GetU32(&offset);
515 switch (m_header.magic)
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]516 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]517 case HeaderMagic32:
518 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
519 m_data.SetAddressByteSize(4);
520 can_parse = true;
521 break;
522
523 case HeaderMagic64:
524 m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
525 m_data.SetAddressByteSize(8);
526 can_parse = true;
527 break;
528
529 case HeaderMagic32Swapped:
530 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
531 m_data.SetAddressByteSize(4);
532 can_parse = true;
533 break;
534
535 case HeaderMagic64Swapped:
536 m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
537 m_data.SetAddressByteSize(8);
538 can_parse = true;
539 break;
540
541 default:
542 break;
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]543 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]544
545 if (can_parse)
546 {
547 m_data.GetU32(&offset, &m_header.cputype, 6);
548
549 ArchSpec mach_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
550
551 if (SetModulesArchitecture (mach_arch))
552 {
553 const size_t header_and_lc_size = m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
554 if (m_data.GetByteSize() < header_and_lc_size)
555 {
556 DataBufferSP data_sp;
557 ProcessSP process_sp (m_process_wp.lock());
558 if (process_sp)
559 {
560 data_sp = ReadMemory (process_sp, m_offset, header_and_lc_size);
561 }
562 else
563 {
564 // Read in all only the load command data from the file on disk
565 data_sp = m_file.ReadFileContents(m_offset, header_and_lc_size);
566 if (data_sp->GetByteSize() != header_and_lc_size)
567 return false;
568 }
569 if (data_sp)
570 m_data.SetData (data_sp);
571 }
572 }
573 return true;
574 }
575 else
576 {
577 memset(&m_header, 0, sizeof(struct mach_header));
578 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]579 }
580 return false;
581}
582
583
584ByteOrder
585ObjectFileMachO::GetByteOrder () const
586{
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]587 return m_data.GetByteOrder ();
588}
589
Jim Ingham7508e732010-08-09 23:31:02 +0000[diff] [blame]590bool
591ObjectFileMachO::IsExecutable() const
592{
593 return m_header.filetype == HeaderFileTypeExecutable;
594}
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]595
596size_t
597ObjectFileMachO::GetAddressByteSize () const
598{
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]599 return m_data.GetAddressByteSize ();
600}
601
Greg Claytonb3448432011-03-24 21:19:54 +0000[diff] [blame]602AddressClass
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]603ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr)
604{
605 Symtab *symtab = GetSymtab();
606 if (symtab)
607 {
608 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
609 if (symbol)
610 {
Greg Clayton0c31d3d2012-03-07 21:03:09 +0000[diff] [blame]611 if (symbol->ValueIsAddress())
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]612 {
Greg Clayton0c31d3d2012-03-07 21:03:09 +0000[diff] [blame]613 SectionSP section_sp (symbol->GetAddress().GetSection());
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]614 if (section_sp)
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]615 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]616 const SectionType section_type = section_sp->GetType();
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]617 switch (section_type)
618 {
619 case eSectionTypeInvalid: return eAddressClassUnknown;
620 case eSectionTypeCode:
621 if (m_header.cputype == llvm::MachO::CPUTypeARM)
622 {
623 // For ARM we have a bit in the n_desc field of the symbol
624 // that tells us ARM/Thumb which is bit 0x0008.
625 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
626 return eAddressClassCodeAlternateISA;
627 }
628 return eAddressClassCode;
629
630 case eSectionTypeContainer: return eAddressClassUnknown;
Greg Clayton24a6bd92011-10-27 17:55:14 +0000[diff] [blame]631 case eSectionTypeData:
632 case eSectionTypeDataCString:
633 case eSectionTypeDataCStringPointers:
634 case eSectionTypeDataSymbolAddress:
635 case eSectionTypeData4:
636 case eSectionTypeData8:
637 case eSectionTypeData16:
638 case eSectionTypeDataPointers:
639 case eSectionTypeZeroFill:
640 case eSectionTypeDataObjCMessageRefs:
641 case eSectionTypeDataObjCCFStrings:
642 return eAddressClassData;
643 case eSectionTypeDebug:
644 case eSectionTypeDWARFDebugAbbrev:
645 case eSectionTypeDWARFDebugAranges:
646 case eSectionTypeDWARFDebugFrame:
647 case eSectionTypeDWARFDebugInfo:
648 case eSectionTypeDWARFDebugLine:
649 case eSectionTypeDWARFDebugLoc:
650 case eSectionTypeDWARFDebugMacInfo:
651 case eSectionTypeDWARFDebugPubNames:
652 case eSectionTypeDWARFDebugPubTypes:
653 case eSectionTypeDWARFDebugRanges:
654 case eSectionTypeDWARFDebugStr:
655 case eSectionTypeDWARFAppleNames:
656 case eSectionTypeDWARFAppleTypes:
657 case eSectionTypeDWARFAppleNamespaces:
658 case eSectionTypeDWARFAppleObjC:
659 return eAddressClassDebug;
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]660 case eSectionTypeEHFrame: return eAddressClassRuntime;
661 case eSectionTypeOther: return eAddressClassUnknown;
662 }
663 }
664 }
665
Greg Claytonb3448432011-03-24 21:19:54 +0000[diff] [blame]666 const SymbolType symbol_type = symbol->GetType();
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]667 switch (symbol_type)
668 {
669 case eSymbolTypeAny: return eAddressClassUnknown;
670 case eSymbolTypeAbsolute: return eAddressClassUnknown;
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]671
672 case eSymbolTypeCode:
673 case eSymbolTypeTrampoline:
674 if (m_header.cputype == llvm::MachO::CPUTypeARM)
675 {
676 // For ARM we have a bit in the n_desc field of the symbol
677 // that tells us ARM/Thumb which is bit 0x0008.
678 if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
679 return eAddressClassCodeAlternateISA;
680 }
681 return eAddressClassCode;
682
683 case eSymbolTypeData: return eAddressClassData;
684 case eSymbolTypeRuntime: return eAddressClassRuntime;
685 case eSymbolTypeException: return eAddressClassRuntime;
686 case eSymbolTypeSourceFile: return eAddressClassDebug;
687 case eSymbolTypeHeaderFile: return eAddressClassDebug;
688 case eSymbolTypeObjectFile: return eAddressClassDebug;
689 case eSymbolTypeCommonBlock: return eAddressClassDebug;
690 case eSymbolTypeBlock: return eAddressClassDebug;
691 case eSymbolTypeLocal: return eAddressClassData;
692 case eSymbolTypeParam: return eAddressClassData;
693 case eSymbolTypeVariable: return eAddressClassData;
694 case eSymbolTypeVariableType: return eAddressClassDebug;
695 case eSymbolTypeLineEntry: return eAddressClassDebug;
696 case eSymbolTypeLineHeader: return eAddressClassDebug;
697 case eSymbolTypeScopeBegin: return eAddressClassDebug;
698 case eSymbolTypeScopeEnd: return eAddressClassDebug;
699 case eSymbolTypeAdditional: return eAddressClassUnknown;
700 case eSymbolTypeCompiler: return eAddressClassDebug;
701 case eSymbolTypeInstrumentation:return eAddressClassDebug;
702 case eSymbolTypeUndefined: return eAddressClassUnknown;
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]703 case eSymbolTypeObjCClass: return eAddressClassRuntime;
704 case eSymbolTypeObjCMetaClass: return eAddressClassRuntime;
705 case eSymbolTypeObjCIVar: return eAddressClassRuntime;
Greg Claytonb1888f22011-03-19 01:12:21 +0000[diff] [blame]706 }
707 }
708 }
709 return eAddressClassUnknown;
710}
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]711
712Symtab *
713ObjectFileMachO::GetSymtab()
714{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]715 ModuleSP module_sp(GetModule());
716 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]717 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]718 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
719 if (m_symtab_ap.get() == NULL)
720 {
721 m_symtab_ap.reset(new Symtab(this));
722 Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
723 ParseSymtab (true);
724 m_symtab_ap->Finalize ();
725 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]726 }
727 return m_symtab_ap.get();
728}
729
730
731SectionList *
732ObjectFileMachO::GetSectionList()
733{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]734 ModuleSP module_sp(GetModule());
735 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]736 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]737 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
738 if (m_sections_ap.get() == NULL)
739 {
740 m_sections_ap.reset(new SectionList());
741 ParseSections();
742 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]743 }
744 return m_sections_ap.get();
745}
746
747
748size_t
749ObjectFileMachO::ParseSections ()
750{
751 lldb::user_id_t segID = 0;
752 lldb::user_id_t sectID = 0;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]753 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
754 uint32_t i;
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]755 const bool is_core = GetType() == eTypeCoreFile;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]756 //bool dump_sections = false;
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]757 ModuleSP module_sp (GetModule());
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]758 // First look up any LC_ENCRYPTION_INFO load commands
759 typedef RangeArray<uint32_t, uint32_t, 8> EncryptedFileRanges;
760 EncryptedFileRanges encrypted_file_ranges;
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]761 encryption_info_command encryption_cmd;
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]762 for (i=0; i<m_header.ncmds; ++i)
763 {
764 const uint32_t load_cmd_offset = offset;
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]765 if (m_data.GetU32(&offset, &encryption_cmd, 2) == NULL)
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]766 break;
767
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]768 if (encryption_cmd.cmd == LoadCommandEncryptionInfo)
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]769 {
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]770 if (m_data.GetU32(&offset, &encryption_cmd.cryptoff, 3))
771 {
772 if (encryption_cmd.cryptid != 0)
773 {
774 EncryptedFileRanges::Entry entry;
775 entry.SetRangeBase(encryption_cmd.cryptoff);
776 entry.SetByteSize(encryption_cmd.cryptsize);
777 encrypted_file_ranges.Append(entry);
778 }
779 }
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]780 }
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]781 offset = load_cmd_offset + encryption_cmd.cmdsize;
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]782 }
783
784 offset = MachHeaderSizeFromMagic(m_header.magic);
785
Greg Clayton54e33712012-05-25 18:09:55 +0000[diff] [blame]786 struct segment_command_64 load_cmd;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]787 for (i=0; i<m_header.ncmds; ++i)
788 {
789 const uint32_t load_cmd_offset = offset;
790 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
791 break;
792
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]793 if (load_cmd.cmd == LoadCommandSegment32 || load_cmd.cmd == LoadCommandSegment64)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]794 {
795 if (m_data.GetU8(&offset, (uint8_t*)load_cmd.segname, 16))
796 {
797 load_cmd.vmaddr = m_data.GetAddress(&offset);
798 load_cmd.vmsize = m_data.GetAddress(&offset);
799 load_cmd.fileoff = m_data.GetAddress(&offset);
800 load_cmd.filesize = m_data.GetAddress(&offset);
801 if (m_data.GetU32(&offset, &load_cmd.maxprot, 4))
802 {
Greg Clayton68ca8232011-01-25 02:58:48 +0000[diff] [blame]803
804 const bool segment_is_encrypted = (load_cmd.flags & SegmentCommandFlagBitProtectedVersion1) != 0;
805
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]806 // Keep a list of mach segments around in case we need to
807 // get at data that isn't stored in the abstracted Sections.
808 m_mach_segments.push_back (load_cmd);
809
810 ConstString segment_name (load_cmd.segname, std::min<int>(strlen(load_cmd.segname), sizeof(load_cmd.segname)));
811 // Use a segment ID of the segment index shifted left by 8 so they
812 // never conflict with any of the sections.
813 SectionSP segment_sp;
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]814 if (segment_name || is_core)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]815 {
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]816 segment_sp.reset(new Section (module_sp, // Module to which this section belongs
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]817 ++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
818 segment_name, // Name of this section
819 eSectionTypeContainer, // This section is a container of other sections.
820 load_cmd.vmaddr, // File VM address == addresses as they are found in the object file
821 load_cmd.vmsize, // VM size in bytes of this section
822 load_cmd.fileoff, // Offset to the data for this section in the file
823 load_cmd.filesize, // Size in bytes of this section as found in the the file
824 load_cmd.flags)); // Flags for this section
825
Greg Clayton68ca8232011-01-25 02:58:48 +0000[diff] [blame]826 segment_sp->SetIsEncrypted (segment_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]827 m_sections_ap->AddSection(segment_sp);
828 }
829
830 struct section_64 sect64;
Greg Claytonddff7cc2011-02-04 21:13:05 +0000[diff] [blame]831 ::memset (&sect64, 0, sizeof(sect64));
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]832 // Push a section into our mach sections for the section at
Greg Clayton6af4fad2010-10-06 01:26:32 +0000[diff] [blame]833 // index zero (NListSectionNoSection) if we don't have any
834 // mach sections yet...
835 if (m_mach_sections.empty())
836 m_mach_sections.push_back(sect64);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]837 uint32_t segment_sect_idx;
838 const lldb::user_id_t first_segment_sectID = sectID + 1;
839
840
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]841 const uint32_t num_u32s = load_cmd.cmd == LoadCommandSegment32 ? 7 : 8;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]842 for (segment_sect_idx=0; segment_sect_idx<load_cmd.nsects; ++segment_sect_idx)
843 {
844 if (m_data.GetU8(&offset, (uint8_t*)sect64.sectname, sizeof(sect64.sectname)) == NULL)
845 break;
846 if (m_data.GetU8(&offset, (uint8_t*)sect64.segname, sizeof(sect64.segname)) == NULL)
847 break;
848 sect64.addr = m_data.GetAddress(&offset);
849 sect64.size = m_data.GetAddress(&offset);
850
851 if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == NULL)
852 break;
853
854 // Keep a list of mach sections around in case we need to
855 // get at data that isn't stored in the abstracted Sections.
856 m_mach_sections.push_back (sect64);
857
858 ConstString section_name (sect64.sectname, std::min<size_t>(strlen(sect64.sectname), sizeof(sect64.sectname)));
859 if (!segment_name)
860 {
861 // We have a segment with no name so we need to conjure up
862 // segments that correspond to the section's segname if there
863 // isn't already such a section. If there is such a section,
864 // we resize the section so that it spans all sections.
865 // We also mark these sections as fake so address matches don't
866 // hit if they land in the gaps between the child sections.
867 segment_name.SetTrimmedCStringWithLength(sect64.segname, sizeof(sect64.segname));
868 segment_sp = m_sections_ap->FindSectionByName (segment_name);
869 if (segment_sp.get())
870 {
871 Section *segment = segment_sp.get();
872 // Grow the section size as needed.
873 const lldb::addr_t sect64_min_addr = sect64.addr;
874 const lldb::addr_t sect64_max_addr = sect64_min_addr + sect64.size;
875 const lldb::addr_t curr_seg_byte_size = segment->GetByteSize();
876 const lldb::addr_t curr_seg_min_addr = segment->GetFileAddress();
877 const lldb::addr_t curr_seg_max_addr = curr_seg_min_addr + curr_seg_byte_size;
878 if (sect64_min_addr >= curr_seg_min_addr)
879 {
880 const lldb::addr_t new_seg_byte_size = sect64_max_addr - curr_seg_min_addr;
881 // Only grow the section size if needed
882 if (new_seg_byte_size > curr_seg_byte_size)
883 segment->SetByteSize (new_seg_byte_size);
884 }
885 else
886 {
887 // We need to change the base address of the segment and
888 // adjust the child section offsets for all existing children.
889 const lldb::addr_t slide_amount = sect64_min_addr - curr_seg_min_addr;
890 segment->Slide(slide_amount, false);
Sean Callanan716a6642012-06-08 02:16:08 +0000[diff] [blame]891 segment->GetChildren().Slide(-slide_amount, false);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]892 segment->SetByteSize (curr_seg_max_addr - sect64_min_addr);
893 }
Greg Clayton661825b2010-06-28 23:51:11 +0000[diff] [blame]894
895 // Grow the section size as needed.
896 if (sect64.offset)
897 {
898 const lldb::addr_t segment_min_file_offset = segment->GetFileOffset();
899 const lldb::addr_t segment_max_file_offset = segment_min_file_offset + segment->GetFileSize();
900
901 const lldb::addr_t section_min_file_offset = sect64.offset;
902 const lldb::addr_t section_max_file_offset = section_min_file_offset + sect64.size;
903 const lldb::addr_t new_file_offset = std::min (section_min_file_offset, segment_min_file_offset);
904 const lldb::addr_t new_file_size = std::max (section_max_file_offset, segment_max_file_offset) - new_file_offset;
905 segment->SetFileOffset (new_file_offset);
906 segment->SetFileSize (new_file_size);
907 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]908 }
909 else
910 {
911 // Create a fake section for the section's named segment
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]912 segment_sp.reset(new Section (segment_sp, // Parent section
913 module_sp, // Module to which this section belongs
914 ++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
915 segment_name, // Name of this section
916 eSectionTypeContainer, // This section is a container of other sections.
917 sect64.addr, // File VM address == addresses as they are found in the object file
918 sect64.size, // VM size in bytes of this section
919 sect64.offset, // Offset to the data for this section in the file
920 sect64.offset ? sect64.size : 0, // Size in bytes of this section as found in the the file
921 load_cmd.flags)); // Flags for this section
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]922 segment_sp->SetIsFake(true);
923 m_sections_ap->AddSection(segment_sp);
Greg Clayton68ca8232011-01-25 02:58:48 +0000[diff] [blame]924 segment_sp->SetIsEncrypted (segment_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]925 }
926 }
927 assert (segment_sp.get());
928
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]929 uint32_t mach_sect_type = sect64.flags & SectionFlagMaskSectionType;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]930 static ConstString g_sect_name_objc_data ("__objc_data");
931 static ConstString g_sect_name_objc_msgrefs ("__objc_msgrefs");
932 static ConstString g_sect_name_objc_selrefs ("__objc_selrefs");
933 static ConstString g_sect_name_objc_classrefs ("__objc_classrefs");
934 static ConstString g_sect_name_objc_superrefs ("__objc_superrefs");
935 static ConstString g_sect_name_objc_const ("__objc_const");
936 static ConstString g_sect_name_objc_classlist ("__objc_classlist");
937 static ConstString g_sect_name_cfstring ("__cfstring");
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]938
939 static ConstString g_sect_name_dwarf_debug_abbrev ("__debug_abbrev");
940 static ConstString g_sect_name_dwarf_debug_aranges ("__debug_aranges");
941 static ConstString g_sect_name_dwarf_debug_frame ("__debug_frame");
942 static ConstString g_sect_name_dwarf_debug_info ("__debug_info");
943 static ConstString g_sect_name_dwarf_debug_line ("__debug_line");
944 static ConstString g_sect_name_dwarf_debug_loc ("__debug_loc");
945 static ConstString g_sect_name_dwarf_debug_macinfo ("__debug_macinfo");
946 static ConstString g_sect_name_dwarf_debug_pubnames ("__debug_pubnames");
947 static ConstString g_sect_name_dwarf_debug_pubtypes ("__debug_pubtypes");
948 static ConstString g_sect_name_dwarf_debug_ranges ("__debug_ranges");
949 static ConstString g_sect_name_dwarf_debug_str ("__debug_str");
Greg Claytonf6e3de22011-09-28 17:06:40 +0000[diff] [blame]950 static ConstString g_sect_name_dwarf_apple_names ("__apple_names");
951 static ConstString g_sect_name_dwarf_apple_types ("__apple_types");
Greg Clayton00db2152011-10-04 22:41:51 +0000[diff] [blame]952 static ConstString g_sect_name_dwarf_apple_namespaces ("__apple_namespac");
Greg Clayton24a6bd92011-10-27 17:55:14 +0000[diff] [blame]953 static ConstString g_sect_name_dwarf_apple_objc ("__apple_objc");
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]954 static ConstString g_sect_name_eh_frame ("__eh_frame");
Greg Clayton3fed8b92010-10-08 00:21:05 +0000[diff] [blame]955 static ConstString g_sect_name_DATA ("__DATA");
956 static ConstString g_sect_name_TEXT ("__TEXT");
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]957
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]958 SectionType sect_type = eSectionTypeOther;
959
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]960 if (section_name == g_sect_name_dwarf_debug_abbrev)
961 sect_type = eSectionTypeDWARFDebugAbbrev;
962 else if (section_name == g_sect_name_dwarf_debug_aranges)
963 sect_type = eSectionTypeDWARFDebugAranges;
964 else if (section_name == g_sect_name_dwarf_debug_frame)
965 sect_type = eSectionTypeDWARFDebugFrame;
966 else if (section_name == g_sect_name_dwarf_debug_info)
967 sect_type = eSectionTypeDWARFDebugInfo;
968 else if (section_name == g_sect_name_dwarf_debug_line)
969 sect_type = eSectionTypeDWARFDebugLine;
970 else if (section_name == g_sect_name_dwarf_debug_loc)
971 sect_type = eSectionTypeDWARFDebugLoc;
972 else if (section_name == g_sect_name_dwarf_debug_macinfo)
973 sect_type = eSectionTypeDWARFDebugMacInfo;
974 else if (section_name == g_sect_name_dwarf_debug_pubnames)
975 sect_type = eSectionTypeDWARFDebugPubNames;
976 else if (section_name == g_sect_name_dwarf_debug_pubtypes)
977 sect_type = eSectionTypeDWARFDebugPubTypes;
978 else if (section_name == g_sect_name_dwarf_debug_ranges)
979 sect_type = eSectionTypeDWARFDebugRanges;
980 else if (section_name == g_sect_name_dwarf_debug_str)
981 sect_type = eSectionTypeDWARFDebugStr;
Greg Claytonf6e3de22011-09-28 17:06:40 +0000[diff] [blame]982 else if (section_name == g_sect_name_dwarf_apple_names)
983 sect_type = eSectionTypeDWARFAppleNames;
984 else if (section_name == g_sect_name_dwarf_apple_types)
985 sect_type = eSectionTypeDWARFAppleTypes;
Greg Clayton00db2152011-10-04 22:41:51 +0000[diff] [blame]986 else if (section_name == g_sect_name_dwarf_apple_namespaces)
987 sect_type = eSectionTypeDWARFAppleNamespaces;
Greg Clayton24a6bd92011-10-27 17:55:14 +0000[diff] [blame]988 else if (section_name == g_sect_name_dwarf_apple_objc)
989 sect_type = eSectionTypeDWARFAppleObjC;
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]990 else if (section_name == g_sect_name_objc_selrefs)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]991 sect_type = eSectionTypeDataCStringPointers;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]992 else if (section_name == g_sect_name_objc_msgrefs)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]993 sect_type = eSectionTypeDataObjCMessageRefs;
Greg Clayton32a8c7e2010-07-21 22:54:26 +0000[diff] [blame]994 else if (section_name == g_sect_name_eh_frame)
995 sect_type = eSectionTypeEHFrame;
996 else if (section_name == g_sect_name_cfstring)
997 sect_type = eSectionTypeDataObjCCFStrings;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]998 else if (section_name == g_sect_name_objc_data ||
999 section_name == g_sect_name_objc_classrefs ||
1000 section_name == g_sect_name_objc_superrefs ||
1001 section_name == g_sect_name_objc_const ||
1002 section_name == g_sect_name_objc_classlist)
1003 {
1004 sect_type = eSectionTypeDataPointers;
1005 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1006
1007 if (sect_type == eSectionTypeOther)
1008 {
1009 switch (mach_sect_type)
1010 {
1011 // TODO: categorize sections by other flags for regular sections
Greg Clayton3fed8b92010-10-08 00:21:05 +0000[diff] [blame]1012 case SectionTypeRegular:
1013 if (segment_sp->GetName() == g_sect_name_TEXT)
1014 sect_type = eSectionTypeCode;
1015 else if (segment_sp->GetName() == g_sect_name_DATA)
1016 sect_type = eSectionTypeData;
1017 else
1018 sect_type = eSectionTypeOther;
1019 break;
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]1020 case SectionTypeZeroFill: sect_type = eSectionTypeZeroFill; break;
1021 case SectionTypeCStringLiterals: sect_type = eSectionTypeDataCString; break; // section with only literal C strings
1022 case SectionType4ByteLiterals: sect_type = eSectionTypeData4; break; // section with only 4 byte literals
1023 case SectionType8ByteLiterals: sect_type = eSectionTypeData8; break; // section with only 8 byte literals
1024 case SectionTypeLiteralPointers: sect_type = eSectionTypeDataPointers; break; // section with only pointers to literals
1025 case SectionTypeNonLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only non-lazy symbol pointers
1026 case SectionTypeLazySymbolPointers: sect_type = eSectionTypeDataPointers; break; // section with only lazy symbol pointers
1027 case SectionTypeSymbolStubs: sect_type = eSectionTypeCode; break; // section with only symbol stubs, byte size of stub in the reserved2 field
1028 case SectionTypeModuleInitFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for initialization
1029 case SectionTypeModuleTermFunctionPointers: sect_type = eSectionTypeDataPointers; break; // section with only function pointers for termination
1030 case SectionTypeCoalesced: sect_type = eSectionTypeOther; break;
1031 case SectionTypeZeroFillLarge: sect_type = eSectionTypeZeroFill; break;
1032 case SectionTypeInterposing: sect_type = eSectionTypeCode; break; // section with only pairs of function pointers for interposing
1033 case SectionType16ByteLiterals: sect_type = eSectionTypeData16; break; // section with only 16 byte literals
1034 case SectionTypeDTraceObjectFormat: sect_type = eSectionTypeDebug; break;
1035 case SectionTypeLazyDylibSymbolPointers: sect_type = eSectionTypeDataPointers; break;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1036 default: break;
1037 }
1038 }
1039
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1040 SectionSP section_sp(new Section (segment_sp,
1041 module_sp,
1042 ++sectID,
1043 section_name,
1044 sect_type,
1045 sect64.addr - segment_sp->GetFileAddress(),
1046 sect64.size,
1047 sect64.offset,
1048 sect64.offset == 0 ? 0 : sect64.size,
1049 sect64.flags));
Greg Clayton68ca8232011-01-25 02:58:48 +0000[diff] [blame]1050 // Set the section to be encrypted to match the segment
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]1051
1052 bool section_is_encrypted = false;
1053 if (!segment_is_encrypted && load_cmd.filesize != 0)
1054 section_is_encrypted = encrypted_file_ranges.FindEntryThatContains(sect64.offset) != NULL;
Greg Clayton68ca8232011-01-25 02:58:48 +0000[diff] [blame]1055
Greg Clayton6f7f8da2012-04-24 03:06:13 +0000[diff] [blame]1056 section_sp->SetIsEncrypted (segment_is_encrypted || section_is_encrypted);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1057 segment_sp->GetChildren().AddSection(section_sp);
1058
1059 if (segment_sp->IsFake())
1060 {
1061 segment_sp.reset();
1062 segment_name.Clear();
1063 }
1064 }
Greg Clayton0fa51242011-07-19 03:57:15 +0000[diff] [blame]1065 if (segment_sp && m_header.filetype == HeaderFileTypeDSYM)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1066 {
1067 if (first_segment_sectID <= sectID)
1068 {
1069 lldb::user_id_t sect_uid;
1070 for (sect_uid = first_segment_sectID; sect_uid <= sectID; ++sect_uid)
1071 {
1072 SectionSP curr_section_sp(segment_sp->GetChildren().FindSectionByID (sect_uid));
1073 SectionSP next_section_sp;
1074 if (sect_uid + 1 <= sectID)
1075 next_section_sp = segment_sp->GetChildren().FindSectionByID (sect_uid+1);
1076
1077 if (curr_section_sp.get())
1078 {
1079 if (curr_section_sp->GetByteSize() == 0)
1080 {
1081 if (next_section_sp.get() != NULL)
1082 curr_section_sp->SetByteSize ( next_section_sp->GetFileAddress() - curr_section_sp->GetFileAddress() );
1083 else
1084 curr_section_sp->SetByteSize ( load_cmd.vmsize );
1085 }
1086 }
1087 }
1088 }
1089 }
1090 }
1091 }
1092 }
Greg Clayton1674b122010-07-21 22:12:05 +0000[diff] [blame]1093 else if (load_cmd.cmd == LoadCommandDynamicSymtabInfo)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1094 {
1095 m_dysymtab.cmd = load_cmd.cmd;
1096 m_dysymtab.cmdsize = load_cmd.cmdsize;
1097 m_data.GetU32 (&offset, &m_dysymtab.ilocalsym, (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2);
1098 }
1099
1100 offset = load_cmd_offset + load_cmd.cmdsize;
1101 }
1102// if (dump_sections)
1103// {
1104// StreamFile s(stdout);
1105// m_sections_ap->Dump(&s, true);
1106// }
1107 return sectID; // Return the number of sections we registered with the module
1108}
1109
1110class MachSymtabSectionInfo
1111{
1112public:
1113
1114 MachSymtabSectionInfo (SectionList *section_list) :
1115 m_section_list (section_list),
1116 m_section_infos()
1117 {
1118 // Get the number of sections down to a depth of 1 to include
1119 // all segments and their sections, but no other sections that
1120 // may be added for debug map or
1121 m_section_infos.resize(section_list->GetNumSections(1));
1122 }
1123
1124
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1125 SectionSP
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1126 GetSection (uint8_t n_sect, addr_t file_addr)
1127 {
1128 if (n_sect == 0)
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1129 return SectionSP();
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1130 if (n_sect < m_section_infos.size())
1131 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1132 if (!m_section_infos[n_sect].section_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1133 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1134 SectionSP section_sp (m_section_list->FindSectionByID (n_sect));
1135 m_section_infos[n_sect].section_sp = section_sp;
1136 if (section_sp != NULL)
Greg Clayton5638d2c2011-07-10 17:32:33 +0000[diff] [blame]1137 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1138 m_section_infos[n_sect].vm_range.SetBaseAddress (section_sp->GetFileAddress());
1139 m_section_infos[n_sect].vm_range.SetByteSize (section_sp->GetByteSize());
Greg Clayton5638d2c2011-07-10 17:32:33 +0000[diff] [blame]1140 }
1141 else
1142 {
Greg Claytondf6dc882012-01-05 03:57:59 +0000[diff] [blame]1143 Host::SystemLog (Host::eSystemLogError, "error: unable to find section for section %u\n", n_sect);
Greg Clayton5638d2c2011-07-10 17:32:33 +0000[diff] [blame]1144 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1145 }
1146 if (m_section_infos[n_sect].vm_range.Contains(file_addr))
Greg Clayton811b9c52011-08-26 20:01:35 +0000[diff] [blame]1147 {
1148 // Symbol is in section.
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1149 return m_section_infos[n_sect].section_sp;
Greg Clayton811b9c52011-08-26 20:01:35 +0000[diff] [blame]1150 }
1151 else if (m_section_infos[n_sect].vm_range.GetByteSize () == 0 &&
1152 m_section_infos[n_sect].vm_range.GetBaseAddress() == file_addr)
1153 {
1154 // Symbol is in section with zero size, but has the same start
1155 // address as the section. This can happen with linker symbols
1156 // (symbols that start with the letter 'l' or 'L'.
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1157 return m_section_infos[n_sect].section_sp;
Greg Clayton811b9c52011-08-26 20:01:35 +0000[diff] [blame]1158 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1159 }
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1160 return m_section_list->FindSectionContainingFileAddress(file_addr);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1161 }
1162
1163protected:
1164 struct SectionInfo
1165 {
1166 SectionInfo () :
1167 vm_range(),
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1168 section_sp ()
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1169 {
1170 }
1171
1172 VMRange vm_range;
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]1173 SectionSP section_sp;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1174 };
1175 SectionList *m_section_list;
1176 std::vector<SectionInfo> m_section_infos;
1177};
1178
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1179size_t
1180ObjectFileMachO::ParseSymtab (bool minimize)
1181{
1182 Timer scoped_timer(__PRETTY_FUNCTION__,
1183 "ObjectFileMachO::ParseSymtab () module = %s",
1184 m_file.GetFilename().AsCString(""));
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1185 ModuleSP module_sp (GetModule());
1186 if (!module_sp)
1187 return 0;
1188
1189 struct symtab_command symtab_load_command = { 0, 0, 0, 0, 0, 0 };
1190 struct linkedit_data_command function_starts_load_command = { 0, 0, 0, 0 };
1191 typedef AddressDataArray<lldb::addr_t, bool, 100> FunctionStarts;
1192 FunctionStarts function_starts;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1193 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
1194 uint32_t i;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1195
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]1196 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
1197
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1198 for (i=0; i<m_header.ncmds; ++i)
1199 {
1200 const uint32_t cmd_offset = offset;
1201 // Read in the load command and load command size
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1202 struct load_command lc;
1203 if (m_data.GetU32(&offset, &lc, 2) == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1204 break;
1205 // Watch for the symbol table load command
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1206 switch (lc.cmd)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1207 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1208 case LoadCommandSymtab:
1209 symtab_load_command.cmd = lc.cmd;
1210 symtab_load_command.cmdsize = lc.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1211 // Read in the rest of the symtab load command
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1212 if (m_data.GetU32(&offset, &symtab_load_command.symoff, 4) == 0) // fill in symoff, nsyms, stroff, strsize fields
1213 return 0;
1214 if (symtab_load_command.symoff == 0)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]1215 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1216 if (log)
1217 module_sp->LogMessage(log.get(), "LC_SYMTAB.symoff == 0");
1218 return 0;
1219 }
1220
1221 if (symtab_load_command.stroff == 0)
1222 {
1223 if (log)
1224 module_sp->LogMessage(log.get(), "LC_SYMTAB.stroff == 0");
1225 return 0;
1226 }
1227
1228 if (symtab_load_command.nsyms == 0)
1229 {
1230 if (log)
1231 module_sp->LogMessage(log.get(), "LC_SYMTAB.nsyms == 0");
1232 return 0;
1233 }
1234
1235 if (symtab_load_command.strsize == 0)
1236 {
1237 if (log)
1238 module_sp->LogMessage(log.get(), "LC_SYMTAB.strsize == 0");
1239 return 0;
1240 }
1241 break;
1242
1243 case LoadCommandFunctionStarts:
1244 function_starts_load_command.cmd = lc.cmd;
1245 function_starts_load_command.cmdsize = lc.cmdsize;
1246 if (m_data.GetU32(&offset, &function_starts_load_command.dataoff, 2) == NULL) // fill in symoff, nsyms, stroff, strsize fields
1247 bzero (&function_starts_load_command, sizeof(function_starts_load_command));
1248 break;
1249
1250 default:
1251 break;
1252 }
1253 offset = cmd_offset + lc.cmdsize;
1254 }
1255
1256 if (symtab_load_command.cmd)
1257 {
1258 Symtab *symtab = m_symtab_ap.get();
1259 SectionList *section_list = GetSectionList();
1260 if (section_list == NULL)
1261 return 0;
1262
1263 ProcessSP process_sp (m_process_wp.lock());
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1264 Process *process = process_sp.get();
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1265
1266 const size_t addr_byte_size = m_data.GetAddressByteSize();
1267 bool bit_width_32 = addr_byte_size == 4;
1268 const size_t nlist_byte_size = bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
1269
1270 DataExtractor nlist_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize());
1271 DataExtractor strtab_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize());
1272 DataExtractor function_starts_data (NULL, 0, m_data.GetByteOrder(), m_data.GetAddressByteSize());
1273
1274 const addr_t nlist_data_byte_size = symtab_load_command.nsyms * nlist_byte_size;
1275 const addr_t strtab_data_byte_size = symtab_load_command.strsize;
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1276 addr_t strtab_addr = LLDB_INVALID_ADDRESS;
1277 if (process)
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1278 {
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1279 Target &target = process->GetTarget();
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1280 SectionSP linkedit_section_sp(section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
1281 // Reading mach file from memory in a process or core file...
1282
1283 if (linkedit_section_sp)
1284 {
1285 const addr_t linkedit_load_addr = linkedit_section_sp->GetLoadBaseAddress(&target);
1286 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
1287 const addr_t symoff_addr = linkedit_load_addr + symtab_load_command.symoff - linkedit_file_offset;
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1288 strtab_addr = linkedit_load_addr + symtab_load_command.stroff - linkedit_file_offset;
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]1289
1290 bool data_was_read = false;
1291
1292#if defined (__APPLE__) && defined (__arm__)
1293 if (m_header.flags & 0x80000000u)
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]1294 {
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]1295 // This mach-o memory file is in the dyld shared cache. If this
1296 // program is not remote and this is iOS, then this process will
1297 // share the same shared cache as the process we are debugging and
1298 // we can read the entire __LINKEDIT from the address space in this
1299 // process. This is a needed optimization that is used for local iOS
1300 // debugging only since all shared libraries in the shared cache do
1301 // not have corresponding files that exist in the file system of the
1302 // device. They have been combined into a single file. This means we
1303 // always have to load these files from memory. All of the symbol and
1304 // string tables from all of the __LINKEDIT sections from the shared
1305 // libraries in the shared cache have been merged into a single large
1306 // symbol and string table. Reading all of this symbol and string table
1307 // data across can slow down debug launch times, so we optimize this by
1308 // reading the memory for the __LINKEDIT section from this process.
1309 PlatformSP platform_sp (target.GetPlatform());
1310 if (platform_sp && platform_sp->IsHost())
1311 {
1312 data_was_read = true;
1313 nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size, eByteOrderLittle);
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1314 strtab_data.SetData((void *)strtab_addr, strtab_data_byte_size, eByteOrderLittle);
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]1315 if (function_starts_load_command.cmd)
1316 {
1317 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
1318 function_starts_data.SetData ((void *)func_start_addr, function_starts_load_command.datasize, eByteOrderLittle);
1319 }
1320 }
1321 }
1322#endif
1323
1324 if (!data_was_read)
1325 {
1326 DataBufferSP nlist_data_sp (ReadMemory (process_sp, symoff_addr, nlist_data_byte_size));
1327 if (nlist_data_sp)
1328 nlist_data.SetData (nlist_data_sp, 0, nlist_data_sp->GetByteSize());
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1329 //DataBufferSP strtab_data_sp (ReadMemory (process_sp, strtab_addr, strtab_data_byte_size));
1330 //if (strtab_data_sp)
1331 // strtab_data.SetData (strtab_data_sp, 0, strtab_data_sp->GetByteSize());
Greg Clayton29021d32012-04-18 05:19:20 +0000[diff] [blame]1332 if (function_starts_load_command.cmd)
1333 {
1334 const addr_t func_start_addr = linkedit_load_addr + function_starts_load_command.dataoff - linkedit_file_offset;
1335 DataBufferSP func_start_data_sp (ReadMemory (process_sp, func_start_addr, function_starts_load_command.datasize));
1336 if (func_start_data_sp)
1337 function_starts_data.SetData (func_start_data_sp, 0, func_start_data_sp->GetByteSize());
1338 }
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]1339 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1340 }
1341 }
1342 else
1343 {
1344 nlist_data.SetData (m_data,
1345 symtab_load_command.symoff,
1346 nlist_data_byte_size);
1347 strtab_data.SetData (m_data,
1348 symtab_load_command.stroff,
1349 strtab_data_byte_size);
1350 if (function_starts_load_command.cmd)
1351 {
1352 function_starts_data.SetData (m_data,
1353 function_starts_load_command.dataoff,
1354 function_starts_load_command.datasize);
1355 }
1356 }
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]1357
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1358 if (nlist_data.GetByteSize() == 0)
1359 {
1360 if (log)
1361 module_sp->LogMessage(log.get(), "failed to read nlist data");
1362 return 0;
1363 }
1364
1365
Greg Clayton3a5dc012012-05-25 17:04:00 +0000[diff] [blame]1366 const bool have_strtab_data = strtab_data.GetByteSize() > 0;
1367 if (!have_strtab_data)
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1368 {
Greg Clayton3a5dc012012-05-25 17:04:00 +0000[diff] [blame]1369 if (process)
1370 {
1371 if (strtab_addr == LLDB_INVALID_ADDRESS)
1372 {
1373 if (log)
1374 module_sp->LogMessage(log.get(), "failed to locate the strtab in memory");
1375 return 0;
1376 }
1377 }
1378 else
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1379 {
1380 if (log)
Greg Clayton3a5dc012012-05-25 17:04:00 +0000[diff] [blame]1381 module_sp->LogMessage(log.get(), "failed to read strtab data");
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1382 return 0;
1383 }
1384 }
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1385
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1386 const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT();
1387 const ConstString &g_segment_name_DATA = GetSegmentNameDATA();
1388 const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC();
1389 const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame();
1390 SectionSP text_section_sp(section_list->FindSectionByName(g_segment_name_TEXT));
1391 SectionSP data_section_sp(section_list->FindSectionByName(g_segment_name_DATA));
1392 SectionSP objc_section_sp(section_list->FindSectionByName(g_segment_name_OBJC));
1393 SectionSP eh_frame_section_sp;
1394 if (text_section_sp.get())
1395 eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName (g_section_name_eh_frame);
1396 else
1397 eh_frame_section_sp = section_list->FindSectionByName (g_section_name_eh_frame);
1398
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]1399 const bool is_arm = (m_header.cputype == llvm::MachO::CPUTypeARM);
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1400 if (text_section_sp && function_starts_data.GetByteSize())
1401 {
1402 FunctionStarts::Entry function_start_entry;
1403 function_start_entry.data = false;
1404 uint32_t function_start_offset = 0;
1405 function_start_entry.addr = text_section_sp->GetFileAddress();
1406 uint64_t delta;
1407 while ((delta = function_starts_data.GetULEB128(&function_start_offset)) > 0)
1408 {
1409 // Now append the current entry
1410 function_start_entry.addr += delta;
1411 function_starts.Append(function_start_entry);
1412 }
1413 }
1414
1415 const uint32_t function_starts_count = function_starts.GetSize();
1416
1417 uint8_t TEXT_eh_frame_sectID = eh_frame_section_sp.get() ? eh_frame_section_sp->GetID() : NListSectionNoSection;
1418
1419 uint32_t nlist_data_offset = 0;
1420
1421 uint32_t N_SO_index = UINT32_MAX;
1422
1423 MachSymtabSectionInfo section_info (section_list);
1424 std::vector<uint32_t> N_FUN_indexes;
1425 std::vector<uint32_t> N_NSYM_indexes;
1426 std::vector<uint32_t> N_INCL_indexes;
1427 std::vector<uint32_t> N_BRAC_indexes;
1428 std::vector<uint32_t> N_COMM_indexes;
1429 typedef std::map <uint64_t, uint32_t> ValueToSymbolIndexMap;
1430 typedef std::map <uint32_t, uint32_t> NListIndexToSymbolIndexMap;
1431 ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
1432 ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
1433 // Any symbols that get merged into another will get an entry
1434 // in this map so we know
1435 NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
1436 uint32_t nlist_idx = 0;
1437 Symbol *symbol_ptr = NULL;
1438
1439 uint32_t sym_idx = 0;
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1440 Symbol *sym = NULL;
1441 uint32_t num_syms = 0;
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]1442 std::string memory_symbol_name;
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1443 uint32_t unmapped_local_symbols_found = 0;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]1444
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1445#if defined (__APPLE__) && defined (__arm__)
1446
1447 // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been optimized by moving LOCAL
1448 // symbols out of the memory mapped portion of the DSC. The symbol information has all been retained,
1449 // but it isn't available in the normal nlist data. However, there *are* duplicate entries of *some*
1450 // LOCAL symbols in the normal nlist data. To handle this situation correctly, we must first attempt
1451 // to parse any DSC unmapped symbol information. If we find any, we set a flag that tells the normal
1452 // nlist parser to ignore all LOCAL symbols.
1453
1454 if (m_header.flags & 0x80000000u)
1455 {
1456 // Before we can start mapping the DSC, we need to make certain the target process is actually
1457 // using the cache we can find.
1458
1459 /*
1460 * TODO (FIXME!)
1461 *
1462 * Consider the case of testing with a separate DSC file.
1463 * If we go through the normal code paths, we will give symbols for the wrong DSC, and
1464 * that is bad. We need to read the target process' all_image_infos struct, and look
1465 * at the values of the processDetachedFromSharedRegion field. If that is set, we should skip
1466 * this code section.
1467 */
1468
1469 // Next we need to determine the correct path for the dyld shared cache.
1470
1471 ArchSpec header_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
1472 char dsc_path[PATH_MAX];
1473
1474 snprintf(dsc_path, sizeof(dsc_path), "%s%s%s",
1475 "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR */
1476 "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
1477 header_arch.GetArchitectureName());
1478
1479 FileSpec dsc_filespec(dsc_path, false);
1480
1481 // We need definitions of two structures in the on-disk DSC, copy them here manually
1482struct lldb_copy_dyld_cache_header
1483{
1484 char magic[16];
1485 uint32_t mappingOffset;
1486 uint32_t mappingCount;
1487 uint32_t imagesOffset;
1488 uint32_t imagesCount;
1489 uint64_t dyldBaseAddress;
1490 uint64_t codeSignatureOffset;
1491 uint64_t codeSignatureSize;
1492 uint64_t slideInfoOffset;
1493 uint64_t slideInfoSize;
1494 uint64_t localSymbolsOffset;
1495 uint64_t localSymbolsSize;
1496};
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1497struct lldb_copy_dyld_cache_local_symbols_info
1498{
1499 uint32_t nlistOffset;
1500 uint32_t nlistCount;
1501 uint32_t stringsOffset;
1502 uint32_t stringsSize;
1503 uint32_t entriesOffset;
1504 uint32_t entriesCount;
1505};
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1506struct lldb_copy_dyld_cache_local_symbols_entry
1507{
1508 uint32_t dylibOffset;
1509 uint32_t nlistStartIndex;
1510 uint32_t nlistCount;
1511};
1512
Jason Molendafd3b35d2012-06-22 03:28:35 +0000[diff] [blame]1513 /* The dyld_cache_header has a pointer to the dyld_cache_local_symbols_info structure (localSymbolsOffset).
1514 The dyld_cache_local_symbols_info structure gives us three things:
1515 1. The start and count of the nlist records in the dyld_shared_cache file
1516 2. The start and size of the strings for these nlist records
1517 3. The start and count of dyld_cache_local_symbols_entry entries
1518
1519 There is one dyld_cache_local_symbols_entry per dylib/framework in the dyld shared cache.
1520 The "dylibOffset" field is the Mach-O header of this dylib/framework in the dyld shared cache.
1521 The dyld_cache_local_symbols_entry also lists the start of this dylib/framework's nlist records
1522 and the count of how many nlist records there are for this dylib/framework.
1523 */
1524
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1525 // Process the dsc header to find the unmapped symbols
1526 //
1527 // Save some VM space, do not map the entire cache in one shot.
1528
1529 if (DataBufferSP dsc_data_sp = dsc_filespec.MemoryMapFileContents(0, sizeof(struct lldb_copy_dyld_cache_header)))
1530 {
1531 DataExtractor dsc_header_data(dsc_data_sp, m_data.GetByteOrder(), m_data.GetAddressByteSize());
1532
Jason Molendafd3b35d2012-06-22 03:28:35 +0000[diff] [blame]1533 uint32_t offset = offsetof (struct lldb_copy_dyld_cache_header, mappingOffset);
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1534 uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
1535
1536 // If the mappingOffset points to a location inside the header, we've
1537 // opened an old dyld shared cache, and should not proceed further.
1538 if (mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header))
1539 {
1540
Jason Molendafd3b35d2012-06-22 03:28:35 +0000[diff] [blame]1541 offset = offsetof (struct lldb_copy_dyld_cache_header, localSymbolsOffset);
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1542 uint64_t localSymbolsOffset = dsc_header_data.GetU64(&offset);
1543 uint64_t localSymbolsSize = dsc_header_data.GetU64(&offset);
1544
1545 if (localSymbolsOffset && localSymbolsSize)
1546 {
1547 // Map the local symbols
1548 if (DataBufferSP dsc_local_symbols_data_sp = dsc_filespec.MemoryMapFileContents(localSymbolsOffset, localSymbolsSize))
1549 {
1550 DataExtractor dsc_local_symbols_data(dsc_local_symbols_data_sp, m_data.GetByteOrder(), m_data.GetAddressByteSize());
1551
1552 offset = 0;
1553
1554 // Read the local_symbols_infos struct in one shot
1555 struct lldb_copy_dyld_cache_local_symbols_info local_symbols_info;
1556 dsc_local_symbols_data.GetU32(&offset, &local_symbols_info.nlistOffset, 6);
1557
1558 // The local_symbols_infos offsets are offsets into local symbols memory, NOT file offsets!
1559 // We first need to identify the local "entry" that matches the current header.
1560 // The "entry" is stored as a file offset in the dyld_shared_cache, so we need to
1561 // adjust the raw m_header value by slide and 0x30000000.
1562
1563 SectionSP text_section_sp(section_list->FindSectionByName(GetSegmentNameTEXT()));
1564
1565 uint32_t header_file_offset = (text_section_sp->GetFileAddress() - 0x30000000);
1566
1567 offset = local_symbols_info.entriesOffset;
1568 for (uint32_t entry_index = 0; entry_index < local_symbols_info.entriesCount; entry_index++)
1569 {
1570 struct lldb_copy_dyld_cache_local_symbols_entry local_symbols_entry;
1571 local_symbols_entry.dylibOffset = dsc_local_symbols_data.GetU32(&offset);
1572 local_symbols_entry.nlistStartIndex = dsc_local_symbols_data.GetU32(&offset);
1573 local_symbols_entry.nlistCount = dsc_local_symbols_data.GetU32(&offset);
1574
1575 if (header_file_offset == local_symbols_entry.dylibOffset)
1576 {
1577 unmapped_local_symbols_found = local_symbols_entry.nlistCount;
1578
1579 // The normal nlist code cannot correctly size the Symbols array, we need to allocate it here.
1580 sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms + unmapped_local_symbols_found - m_dysymtab.nlocalsym);
1581 num_syms = symtab->GetNumSymbols();
1582
1583 nlist_data_offset = local_symbols_info.nlistOffset + (nlist_byte_size * local_symbols_entry.nlistStartIndex);
1584 uint32_t string_table_offset = local_symbols_info.stringsOffset;
1585
1586 for (uint32_t nlist_index = 0; nlist_index < local_symbols_entry.nlistCount; nlist_index++)
1587 {
1588 /////////////////////////////
1589 {
1590 struct nlist_64 nlist;
1591 if (!dsc_local_symbols_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
1592 break;
1593
1594 nlist.n_strx = dsc_local_symbols_data.GetU32_unchecked(&nlist_data_offset);
1595 nlist.n_type = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
1596 nlist.n_sect = dsc_local_symbols_data.GetU8_unchecked (&nlist_data_offset);
1597 nlist.n_desc = dsc_local_symbols_data.GetU16_unchecked (&nlist_data_offset);
1598 nlist.n_value = dsc_local_symbols_data.GetAddress_unchecked (&nlist_data_offset);
1599
1600 SymbolType type = eSymbolTypeInvalid;
1601 const char *symbol_name = dsc_local_symbols_data.PeekCStr(string_table_offset + nlist.n_strx);
1602
1603 if (symbol_name == NULL)
1604 {
1605 // No symbol should be NULL, even the symbols with no
1606 // string values should have an offset zero which points
1607 // to an empty C-string
1608 Host::SystemLog (Host::eSystemLogError,
1609 "error: DSC unmapped local symbol[%u] has invalid string table offset 0x%x in %s/%s, ignoring symbol\n",
1610 entry_index,
1611 nlist.n_strx,
1612 module_sp->GetFileSpec().GetDirectory().GetCString(),
1613 module_sp->GetFileSpec().GetFilename().GetCString());
1614 continue;
1615 }
1616 if (symbol_name[0] == '\0')
1617 symbol_name = NULL;
1618
1619 const char *symbol_name_non_abi_mangled = NULL;
1620
1621 SectionSP symbol_section;
1622 uint32_t symbol_byte_size = 0;
1623 bool add_nlist = true;
1624 bool is_debug = ((nlist.n_type & NlistMaskStab) != 0);
1625
1626 assert (sym_idx < num_syms);
1627
1628 sym[sym_idx].SetDebug (is_debug);
1629
1630 if (is_debug)
1631 {
1632 switch (nlist.n_type)
1633 {
1634 case StabGlobalSymbol:
1635 // N_GSYM -- global symbol: name,,NO_SECT,type,0
1636 // Sometimes the N_GSYM value contains the address.
1637
1638 // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data. They
1639 // have the same address, but we want to ensure that we always find only the real symbol,
1640 // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
1641 // symbol type. This is a temporary hack to make sure the ObjectiveC symbols get treated
1642 // correctly. To do this right, we should coalesce all the GSYM & global symbols that have the
1643 // same address.
1644
1645 if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O'
1646 && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
1647 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
1648 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
1649 add_nlist = false;
1650 else
1651 {
1652 sym[sym_idx].SetExternal(true);
1653 if (nlist.n_value != 0)
1654 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1655 type = eSymbolTypeData;
1656 }
1657 break;
1658
1659 case StabFunctionName:
1660 // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0
1661 type = eSymbolTypeCompiler;
1662 break;
1663
1664 case StabFunction:
1665 // N_FUN -- procedure: name,,n_sect,linenumber,address
1666 if (symbol_name)
1667 {
1668 type = eSymbolTypeCode;
1669 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1670
1671 N_FUN_addr_to_sym_idx[nlist.n_value] = sym_idx;
1672 // We use the current number of symbols in the symbol table in lieu of
1673 // using nlist_idx in case we ever start trimming entries out
1674 N_FUN_indexes.push_back(sym_idx);
1675 }
1676 else
1677 {
1678 type = eSymbolTypeCompiler;
1679
1680 if ( !N_FUN_indexes.empty() )
1681 {
1682 // Copy the size of the function into the original STAB entry so we don't have
1683 // to hunt for it later
1684 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
1685 N_FUN_indexes.pop_back();
1686 // We don't really need the end function STAB as it contains the size which
1687 // we already placed with the original symbol, so don't add it if we want a
1688 // minimal symbol table
1689 if (minimize)
1690 add_nlist = false;
1691 }
1692 }
1693 break;
1694
1695 case StabStaticSymbol:
1696 // N_STSYM -- static symbol: name,,n_sect,type,address
1697 N_STSYM_addr_to_sym_idx[nlist.n_value] = sym_idx;
1698 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1699 type = eSymbolTypeData;
1700 break;
1701
1702 case StabLocalCommon:
1703 // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address
1704 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1705 type = eSymbolTypeCommonBlock;
1706 break;
1707
1708 case StabBeginSymbol:
1709 // N_BNSYM
1710 // We use the current number of symbols in the symbol table in lieu of
1711 // using nlist_idx in case we ever start trimming entries out
1712 if (minimize)
1713 {
1714 // Skip these if we want minimal symbol tables
1715 add_nlist = false;
1716 }
1717 else
1718 {
1719 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1720 N_NSYM_indexes.push_back(sym_idx);
1721 type = eSymbolTypeScopeBegin;
1722 }
1723 break;
1724
1725 case StabEndSymbol:
1726 // N_ENSYM
1727 // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
1728 // so that we can always skip the entire symbol if we need to navigate
1729 // more quickly at the source level when parsing STABS
1730 if (minimize)
1731 {
1732 // Skip these if we want minimal symbol tables
1733 add_nlist = false;
1734 }
1735 else
1736 {
1737 if ( !N_NSYM_indexes.empty() )
1738 {
1739 symbol_ptr = symtab->SymbolAtIndex(N_NSYM_indexes.back());
1740 symbol_ptr->SetByteSize(sym_idx + 1);
1741 symbol_ptr->SetSizeIsSibling(true);
1742 N_NSYM_indexes.pop_back();
1743 }
1744 type = eSymbolTypeScopeEnd;
1745 }
1746 break;
1747
1748
1749 case StabSourceFileOptions:
1750 // N_OPT - emitted with gcc2_compiled and in gcc source
1751 type = eSymbolTypeCompiler;
1752 break;
1753
1754 case StabRegisterSymbol:
1755 // N_RSYM - register sym: name,,NO_SECT,type,register
1756 type = eSymbolTypeVariable;
1757 break;
1758
1759 case StabSourceLine:
1760 // N_SLINE - src line: 0,,n_sect,linenumber,address
1761 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1762 type = eSymbolTypeLineEntry;
1763 break;
1764
1765 case StabStructureType:
1766 // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset
1767 type = eSymbolTypeVariableType;
1768 break;
1769
1770 case StabSourceFileName:
1771 // N_SO - source file name
1772 type = eSymbolTypeSourceFile;
1773 if (symbol_name == NULL)
1774 {
1775 if (minimize)
1776 add_nlist = false;
1777 if (N_SO_index != UINT32_MAX)
1778 {
1779 // Set the size of the N_SO to the terminating index of this N_SO
1780 // so that we can always skip the entire N_SO if we need to navigate
1781 // more quickly at the source level when parsing STABS
1782 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
1783 symbol_ptr->SetByteSize(sym_idx + (minimize ? 0 : 1));
1784 symbol_ptr->SetSizeIsSibling(true);
1785 }
1786 N_NSYM_indexes.clear();
1787 N_INCL_indexes.clear();
1788 N_BRAC_indexes.clear();
1789 N_COMM_indexes.clear();
1790 N_FUN_indexes.clear();
1791 N_SO_index = UINT32_MAX;
1792 }
1793 else
1794 {
1795 // We use the current number of symbols in the symbol table in lieu of
1796 // using nlist_idx in case we ever start trimming entries out
1797 const bool N_SO_has_full_path = symbol_name[0] == '/';
1798 if (N_SO_has_full_path)
1799 {
1800 if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
1801 {
1802 // We have two consecutive N_SO entries where the first contains a directory
1803 // and the second contains a full path.
Jason Molenda292cca82012-07-20 03:35:44 +0000[diff] [blame^]1804 sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1805 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
1806 add_nlist = false;
1807 }
1808 else
1809 {
1810 // This is the first entry in a N_SO that contains a directory or
1811 // a full path to the source file
1812 N_SO_index = sym_idx;
1813 }
1814 }
1815 else if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
1816 {
1817 // This is usually the second N_SO entry that contains just the filename,
1818 // so here we combine it with the first one if we are minimizing the symbol table
1819 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
1820 if (so_path && so_path[0])
1821 {
1822 std::string full_so_path (so_path);
1823 if (*full_so_path.rbegin() != '/')
1824 full_so_path += '/';
1825 full_so_path += symbol_name;
Jason Molenda292cca82012-07-20 03:35:44 +0000[diff] [blame^]1826 sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]1827 add_nlist = false;
1828 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
1829 }
1830 }
1831 }
1832
1833 break;
1834
1835 case StabObjectFileName:
1836 // N_OSO - object file name: name,,0,0,st_mtime
1837 type = eSymbolTypeObjectFile;
1838 break;
1839
1840 case StabLocalSymbol:
1841 // N_LSYM - local sym: name,,NO_SECT,type,offset
1842 type = eSymbolTypeLocal;
1843 break;
1844
1845 //----------------------------------------------------------------------
1846 // INCL scopes
1847 //----------------------------------------------------------------------
1848 case StabBeginIncludeFileName:
1849 // N_BINCL - include file beginning: name,,NO_SECT,0,sum
1850 // We use the current number of symbols in the symbol table in lieu of
1851 // using nlist_idx in case we ever start trimming entries out
1852 N_INCL_indexes.push_back(sym_idx);
1853 type = eSymbolTypeScopeBegin;
1854 break;
1855
1856 case StabEndIncludeFile:
1857 // N_EINCL - include file end: name,,NO_SECT,0,0
1858 // Set the size of the N_BINCL to the terminating index of this N_EINCL
1859 // so that we can always skip the entire symbol if we need to navigate
1860 // more quickly at the source level when parsing STABS
1861 if ( !N_INCL_indexes.empty() )
1862 {
1863 symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
1864 symbol_ptr->SetByteSize(sym_idx + 1);
1865 symbol_ptr->SetSizeIsSibling(true);
1866 N_INCL_indexes.pop_back();
1867 }
1868 type = eSymbolTypeScopeEnd;
1869 break;
1870
1871 case StabIncludeFileName:
1872 // N_SOL - #included file name: name,,n_sect,0,address
1873 type = eSymbolTypeHeaderFile;
1874
1875 // We currently don't use the header files on darwin
1876 if (minimize)
1877 add_nlist = false;
1878 break;
1879
1880 case StabCompilerParameters:
1881 // N_PARAMS - compiler parameters: name,,NO_SECT,0,0
1882 type = eSymbolTypeCompiler;
1883 break;
1884
1885 case StabCompilerVersion:
1886 // N_VERSION - compiler version: name,,NO_SECT,0,0
1887 type = eSymbolTypeCompiler;
1888 break;
1889
1890 case StabCompilerOptLevel:
1891 // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0
1892 type = eSymbolTypeCompiler;
1893 break;
1894
1895 case StabParameter:
1896 // N_PSYM - parameter: name,,NO_SECT,type,offset
1897 type = eSymbolTypeVariable;
1898 break;
1899
1900 case StabAlternateEntry:
1901 // N_ENTRY - alternate entry: name,,n_sect,linenumber,address
1902 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1903 type = eSymbolTypeLineEntry;
1904 break;
1905
1906 //----------------------------------------------------------------------
1907 // Left and Right Braces
1908 //----------------------------------------------------------------------
1909 case StabLeftBracket:
1910 // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address
1911 // We use the current number of symbols in the symbol table in lieu of
1912 // using nlist_idx in case we ever start trimming entries out
1913 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1914 N_BRAC_indexes.push_back(sym_idx);
1915 type = eSymbolTypeScopeBegin;
1916 break;
1917
1918 case StabRightBracket:
1919 // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address
1920 // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
1921 // so that we can always skip the entire symbol if we need to navigate
1922 // more quickly at the source level when parsing STABS
1923 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1924 if ( !N_BRAC_indexes.empty() )
1925 {
1926 symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
1927 symbol_ptr->SetByteSize(sym_idx + 1);
1928 symbol_ptr->SetSizeIsSibling(true);
1929 N_BRAC_indexes.pop_back();
1930 }
1931 type = eSymbolTypeScopeEnd;
1932 break;
1933
1934 case StabDeletedIncludeFile:
1935 // N_EXCL - deleted include file: name,,NO_SECT,0,sum
1936 type = eSymbolTypeHeaderFile;
1937 break;
1938
1939 //----------------------------------------------------------------------
1940 // COMM scopes
1941 //----------------------------------------------------------------------
1942 case StabBeginCommon:
1943 // N_BCOMM - begin common: name,,NO_SECT,0,0
1944 // We use the current number of symbols in the symbol table in lieu of
1945 // using nlist_idx in case we ever start trimming entries out
1946 type = eSymbolTypeScopeBegin;
1947 N_COMM_indexes.push_back(sym_idx);
1948 break;
1949
1950 case StabEndCommonLocal:
1951 // N_ECOML - end common (local name): 0,,n_sect,0,address
1952 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1953 // Fall through
1954
1955 case StabEndCommon:
1956 // N_ECOMM - end common: name,,n_sect,0,0
1957 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
1958 // so that we can always skip the entire symbol if we need to navigate
1959 // more quickly at the source level when parsing STABS
1960 if ( !N_COMM_indexes.empty() )
1961 {
1962 symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
1963 symbol_ptr->SetByteSize(sym_idx + 1);
1964 symbol_ptr->SetSizeIsSibling(true);
1965 N_COMM_indexes.pop_back();
1966 }
1967 type = eSymbolTypeScopeEnd;
1968 break;
1969
1970 case StabLength:
1971 // N_LENG - second stab entry with length information
1972 type = eSymbolTypeAdditional;
1973 break;
1974
1975 default: break;
1976 }
1977 }
1978 else
1979 {
1980 //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type;
1981 uint8_t n_type = NlistMaskType & nlist.n_type;
1982 sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0);
1983
1984 switch (n_type)
1985 {
1986 case NListTypeIndirect: // N_INDR - Fall through
1987 case NListTypePreboundUndefined:// N_PBUD - Fall through
1988 case NListTypeUndefined: // N_UNDF
1989 type = eSymbolTypeUndefined;
1990 break;
1991
1992 case NListTypeAbsolute: // N_ABS
1993 type = eSymbolTypeAbsolute;
1994 break;
1995
1996 case NListTypeSection: // N_SECT
1997 {
1998 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
1999
2000 if (symbol_section == NULL)
2001 {
2002 // TODO: warn about this?
2003 add_nlist = false;
2004 break;
2005 }
2006
2007 if (TEXT_eh_frame_sectID == nlist.n_sect)
2008 {
2009 type = eSymbolTypeException;
2010 }
2011 else
2012 {
2013 uint32_t section_type = symbol_section->Get() & SectionFlagMaskSectionType;
2014
2015 switch (section_type)
2016 {
2017 case SectionTypeRegular: break; // regular section
2018 //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section
2019 case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings
2020 case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals
2021 case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals
2022 case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals
2023 case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
2024 case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
2025 case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
2026 case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization
2027 case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination
2028 //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced
2029 //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes)
2030 case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing
2031 case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals
2032 case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break;
2033 case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break;
2034 default: break;
2035 }
2036
2037 if (type == eSymbolTypeInvalid)
2038 {
2039 const char *symbol_sect_name = symbol_section->GetName().AsCString();
2040 if (symbol_section->IsDescendant (text_section_sp.get()))
2041 {
2042 if (symbol_section->IsClear(SectionAttrUserPureInstructions |
2043 SectionAttrUserSelfModifyingCode |
2044 SectionAttrSytemSomeInstructions))
2045 type = eSymbolTypeData;
2046 else
2047 type = eSymbolTypeCode;
2048 }
2049 else
2050 if (symbol_section->IsDescendant(data_section_sp.get()))
2051 {
2052 if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
2053 {
2054 type = eSymbolTypeRuntime;
2055
2056 if (symbol_name &&
2057 symbol_name[0] == '_' &&
2058 symbol_name[1] == 'O' &&
2059 symbol_name[2] == 'B')
2060 {
2061 llvm::StringRef symbol_name_ref(symbol_name);
2062 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
2063 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
2064 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
2065 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
2066 {
2067 symbol_name_non_abi_mangled = symbol_name + 1;
2068 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
2069 type = eSymbolTypeObjCClass;
2070 }
2071 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
2072 {
2073 symbol_name_non_abi_mangled = symbol_name + 1;
2074 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
2075 type = eSymbolTypeObjCMetaClass;
2076 }
2077 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
2078 {
2079 symbol_name_non_abi_mangled = symbol_name + 1;
2080 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
2081 type = eSymbolTypeObjCIVar;
2082 }
2083 }
2084 }
2085 else
2086 if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
2087 {
2088 type = eSymbolTypeException;
2089 }
2090 else
2091 {
2092 type = eSymbolTypeData;
2093 }
2094 }
2095 else
2096 if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
2097 {
2098 type = eSymbolTypeTrampoline;
2099 }
2100 else
2101 if (symbol_section->IsDescendant(objc_section_sp.get()))
2102 {
2103 type = eSymbolTypeRuntime;
2104 if (symbol_name && symbol_name[0] == '.')
2105 {
2106 llvm::StringRef symbol_name_ref(symbol_name);
2107 static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
2108 if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
2109 {
2110 symbol_name_non_abi_mangled = symbol_name;
2111 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
2112 type = eSymbolTypeObjCClass;
2113 }
2114 }
2115 }
2116 }
2117 }
2118 }
2119 break;
2120 }
2121 }
2122
2123 if (add_nlist)
2124 {
2125 uint64_t symbol_value = nlist.n_value;
2126 bool symbol_name_is_mangled = false;
2127
2128 if (symbol_name_non_abi_mangled)
2129 {
Jason Molenda292cca82012-07-20 03:35:44 +0000[diff] [blame^]2130 sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
2131 sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]2132 }
2133 else
2134 {
2135 if (symbol_name && symbol_name[0] == '_')
2136 {
2137 symbol_name_is_mangled = symbol_name[1] == '_';
2138 symbol_name++; // Skip the leading underscore
2139 }
2140
2141 if (symbol_name)
2142 {
Jason Molenda292cca82012-07-20 03:35:44 +0000[diff] [blame^]2143 sym[sym_idx].GetMangled().SetValue(ConstString(symbol_name), symbol_name_is_mangled);
Jason Molendab62abd52012-06-21 01:51:02 +0000[diff] [blame]2144 }
2145 }
2146
2147 if (is_debug == false)
2148 {
2149 if (type == eSymbolTypeCode)
2150 {
2151 // See if we can find a N_FUN entry for any code symbols.
2152 // If we do find a match, and the name matches, then we
2153 // can merge the two into just the function symbol to avoid
2154 // duplicate entries in the symbol table
2155 ValueToSymbolIndexMap::const_iterator pos = N_FUN_addr_to_sym_idx.find (nlist.n_value);
2156 if (pos != N_FUN_addr_to_sym_idx.end())
2157 {
2158 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2159 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2160 {
2161 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2162 // We just need the flags from the linker symbol, so put these flags
2163 // into the N_FUN flags to avoid duplicate symbols in the symbol table
2164 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2165 sym[sym_idx].Clear();
2166 continue;
2167 }
2168 }
2169 }
2170 else if (type == eSymbolTypeData)
2171 {
2172 // See if we can find a N_STSYM entry for any data symbols.
2173 // If we do find a match, and the name matches, then we
2174 // can merge the two into just the Static symbol to avoid
2175 // duplicate entries in the symbol table
2176 ValueToSymbolIndexMap::const_iterator pos = N_STSYM_addr_to_sym_idx.find (nlist.n_value);
2177 if (pos != N_STSYM_addr_to_sym_idx.end())
2178 {
2179 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2180 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2181 {
2182 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2183 // We just need the flags from the linker symbol, so put these flags
2184 // into the N_STSYM flags to avoid duplicate symbols in the symbol table
2185 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2186 sym[sym_idx].Clear();
2187 continue;
2188 }
2189 }
2190 }
2191 }
2192 if (symbol_section)
2193 {
2194 const addr_t section_file_addr = symbol_section->GetFileAddress();
2195 if (symbol_byte_size == 0 && function_starts_count > 0)
2196 {
2197 addr_t symbol_lookup_file_addr = nlist.n_value;
2198 // Do an exact address match for non-ARM addresses, else get the closest since
2199 // the symbol might be a thumb symbol which has an address with bit zero set
2200 FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
2201 if (is_arm && func_start_entry)
2202 {
2203 // Verify that the function start address is the symbol address (ARM)
2204 // or the symbol address + 1 (thumb)
2205 if (func_start_entry->addr != symbol_lookup_file_addr &&
2206 func_start_entry->addr != (symbol_lookup_file_addr + 1))
2207 {
2208 // Not the right entry, NULL it out...
2209 func_start_entry = NULL;
2210 }
2211 }
2212 if (func_start_entry)
2213 {
2214 func_start_entry->data = true;
2215
2216 addr_t symbol_file_addr = func_start_entry->addr;
2217 uint32_t symbol_flags = 0;
2218 if (is_arm)
2219 {
2220 if (symbol_file_addr & 1)
2221 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
2222 symbol_file_addr &= 0xfffffffffffffffeull;
2223 }
2224
2225 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
2226 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
2227 if (next_func_start_entry)
2228 {
2229 addr_t next_symbol_file_addr = next_func_start_entry->addr;
2230 // Be sure the clear the Thumb address bit when we calculate the size
2231 // from the current and next address
2232 if (is_arm)
2233 next_symbol_file_addr &= 0xfffffffffffffffeull;
2234 symbol_byte_size = std::min<lldb::addr_t>(next_symbol_file_addr - symbol_file_addr, section_end_file_addr - symbol_file_addr);
2235 }
2236 else
2237 {
2238 symbol_byte_size = section_end_file_addr - symbol_file_addr;
2239 }
2240 }
2241 }
2242 symbol_value -= section_file_addr;
2243 }
2244
2245 sym[sym_idx].SetID (nlist_idx);
2246 sym[sym_idx].SetType (type);
2247 sym[sym_idx].GetAddress().SetSection (symbol_section);
2248 sym[sym_idx].GetAddress().SetOffset (symbol_value);
2249 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2250
2251 if (symbol_byte_size > 0)
2252 sym[sym_idx].SetByteSize(symbol_byte_size);
2253
2254 ++sym_idx;
2255 }
2256 else
2257 {
2258 sym[sym_idx].Clear();
2259 }
2260
2261 }
2262 /////////////////////////////
2263 }
2264 break; // No more entries to consider
2265 }
2266 }
2267 }
2268 }
2269 }
2270 }
2271 }
2272
2273 // Must reset this in case it was mutated above!
2274 nlist_data_offset = 0;
2275#endif
2276
2277 // If the sym array was not created while parsing the DSC unmapped
2278 // symbols, create it now.
2279 if (sym == NULL)
2280 {
2281 sym = symtab->Resize (symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
2282 num_syms = symtab->GetNumSymbols();
2283 }
2284
2285 if (unmapped_local_symbols_found)
2286 {
2287 assert(m_dysymtab.ilocalsym == 0);
2288 nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
2289 nlist_idx = m_dysymtab.nlocalsym;
2290 }
2291 else
2292 {
2293 nlist_idx = 0;
2294 }
2295
2296 for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx)
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2297 {
2298 struct nlist_64 nlist;
2299 if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
2300 break;
2301
2302 nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset);
2303 nlist.n_type = nlist_data.GetU8_unchecked (&nlist_data_offset);
2304 nlist.n_sect = nlist_data.GetU8_unchecked (&nlist_data_offset);
2305 nlist.n_desc = nlist_data.GetU16_unchecked (&nlist_data_offset);
2306 nlist.n_value = nlist_data.GetAddress_unchecked (&nlist_data_offset);
2307
2308 SymbolType type = eSymbolTypeInvalid;
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]2309 const char *symbol_name = NULL;
2310
Greg Clayton3a5dc012012-05-25 17:04:00 +0000[diff] [blame]2311 if (have_strtab_data)
Greg Claytondd29b972012-05-18 23:20:01 +0000[diff] [blame]2312 {
2313 symbol_name = strtab_data.PeekCStr(nlist.n_strx);
2314
2315 if (symbol_name == NULL)
2316 {
2317 // No symbol should be NULL, even the symbols with no
2318 // string values should have an offset zero which points
2319 // to an empty C-string
2320 Host::SystemLog (Host::eSystemLogError,
2321 "error: symbol[%u] has invalid string table offset 0x%x in %s/%s, ignoring symbol\n",
2322 nlist_idx,
2323 nlist.n_strx,
2324 module_sp->GetFileSpec().GetDirectory().GetCString(),
2325 module_sp->GetFileSpec().GetFilename().GetCString());
2326 continue;
2327 }
2328 if (symbol_name[0] == '\0')
2329 symbol_name = NULL;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2330 }
Greg Clayton3a5dc012012-05-25 17:04:00 +0000[diff] [blame]2331 else
2332 {
2333 const addr_t str_addr = strtab_addr + nlist.n_strx;
2334 Error str_error;
2335 if (process->ReadCStringFromMemory(str_addr, memory_symbol_name, str_error))
2336 symbol_name = memory_symbol_name.c_str();
2337 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2338 const char *symbol_name_non_abi_mangled = NULL;
2339
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2340 SectionSP symbol_section;
2341 uint32_t symbol_byte_size = 0;
2342 bool add_nlist = true;
2343 bool is_debug = ((nlist.n_type & NlistMaskStab) != 0);
2344
2345 assert (sym_idx < num_syms);
2346
2347 sym[sym_idx].SetDebug (is_debug);
2348
2349 if (is_debug)
2350 {
2351 switch (nlist.n_type)
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]2352 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2353 case StabGlobalSymbol:
2354 // N_GSYM -- global symbol: name,,NO_SECT,type,0
2355 // Sometimes the N_GSYM value contains the address.
2356
2357 // FIXME: In the .o files, we have a GSYM and a debug symbol for all the ObjC data. They
2358 // have the same address, but we want to ensure that we always find only the real symbol,
2359 // 'cause we don't currently correctly attribute the GSYM one to the ObjCClass/Ivar/MetaClass
2360 // symbol type. This is a temporary hack to make sure the ObjectiveC symbols get treated
2361 // correctly. To do this right, we should coalesce all the GSYM & global symbols that have the
2362 // same address.
2363
2364 if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O'
2365 && (strncmp (symbol_name, "_OBJC_IVAR_$_", strlen ("_OBJC_IVAR_$_")) == 0
2366 || strncmp (symbol_name, "_OBJC_CLASS_$_", strlen ("_OBJC_CLASS_$_")) == 0
2367 || strncmp (symbol_name, "_OBJC_METACLASS_$_", strlen ("_OBJC_METACLASS_$_")) == 0))
2368 add_nlist = false;
2369 else
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]2370 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2371 sym[sym_idx].SetExternal(true);
2372 if (nlist.n_value != 0)
2373 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2374 type = eSymbolTypeData;
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]2375 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2376 break;
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]2377
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2378 case StabFunctionName:
2379 // N_FNAME -- procedure name (f77 kludge): name,,NO_SECT,0,0
2380 type = eSymbolTypeCompiler;
2381 break;
Greg Clayton0fea0512011-12-30 00:32:24 +0000[diff] [blame]2382
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2383 case StabFunction:
2384 // N_FUN -- procedure: name,,n_sect,linenumber,address
2385 if (symbol_name)
Greg Claytona9c4f312011-10-31 20:50:40 +0000[diff] [blame]2386 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2387 type = eSymbolTypeCode;
2388 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2389
2390 N_FUN_addr_to_sym_idx[nlist.n_value] = sym_idx;
2391 // We use the current number of symbols in the symbol table in lieu of
2392 // using nlist_idx in case we ever start trimming entries out
2393 N_FUN_indexes.push_back(sym_idx);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2394 }
2395 else
2396 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2397 type = eSymbolTypeCompiler;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2398
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2399 if ( !N_FUN_indexes.empty() )
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2400 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2401 // Copy the size of the function into the original STAB entry so we don't have
2402 // to hunt for it later
2403 symtab->SymbolAtIndex(N_FUN_indexes.back())->SetByteSize(nlist.n_value);
2404 N_FUN_indexes.pop_back();
2405 // We don't really need the end function STAB as it contains the size which
2406 // we already placed with the original symbol, so don't add it if we want a
2407 // minimal symbol table
2408 if (minimize)
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2409 add_nlist = false;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2410 }
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2411 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2412 break;
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2413
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2414 case StabStaticSymbol:
2415 // N_STSYM -- static symbol: name,,n_sect,type,address
2416 N_STSYM_addr_to_sym_idx[nlist.n_value] = sym_idx;
2417 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2418 type = eSymbolTypeData;
2419 break;
2420
2421 case StabLocalCommon:
2422 // N_LCSYM -- .lcomm symbol: name,,n_sect,type,address
2423 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2424 type = eSymbolTypeCommonBlock;
2425 break;
2426
2427 case StabBeginSymbol:
2428 // N_BNSYM
2429 // We use the current number of symbols in the symbol table in lieu of
2430 // using nlist_idx in case we ever start trimming entries out
2431 if (minimize)
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2432 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2433 // Skip these if we want minimal symbol tables
2434 add_nlist = false;
2435 }
2436 else
2437 {
2438 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2439 N_NSYM_indexes.push_back(sym_idx);
2440 type = eSymbolTypeScopeBegin;
2441 }
2442 break;
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2443
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2444 case StabEndSymbol:
2445 // N_ENSYM
2446 // Set the size of the N_BNSYM to the terminating index of this N_ENSYM
2447 // so that we can always skip the entire symbol if we need to navigate
2448 // more quickly at the source level when parsing STABS
2449 if (minimize)
2450 {
2451 // Skip these if we want minimal symbol tables
2452 add_nlist = false;
2453 }
2454 else
2455 {
2456 if ( !N_NSYM_indexes.empty() )
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2457 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2458 symbol_ptr = symtab->SymbolAtIndex(N_NSYM_indexes.back());
2459 symbol_ptr->SetByteSize(sym_idx + 1);
2460 symbol_ptr->SetSizeIsSibling(true);
2461 N_NSYM_indexes.pop_back();
2462 }
2463 type = eSymbolTypeScopeEnd;
2464 }
2465 break;
2466
2467
2468 case StabSourceFileOptions:
2469 // N_OPT - emitted with gcc2_compiled and in gcc source
2470 type = eSymbolTypeCompiler;
2471 break;
2472
2473 case StabRegisterSymbol:
2474 // N_RSYM - register sym: name,,NO_SECT,type,register
2475 type = eSymbolTypeVariable;
2476 break;
2477
2478 case StabSourceLine:
2479 // N_SLINE - src line: 0,,n_sect,linenumber,address
2480 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2481 type = eSymbolTypeLineEntry;
2482 break;
2483
2484 case StabStructureType:
2485 // N_SSYM - structure elt: name,,NO_SECT,type,struct_offset
2486 type = eSymbolTypeVariableType;
2487 break;
2488
2489 case StabSourceFileName:
2490 // N_SO - source file name
2491 type = eSymbolTypeSourceFile;
2492 if (symbol_name == NULL)
2493 {
2494 if (minimize)
2495 add_nlist = false;
2496 if (N_SO_index != UINT32_MAX)
2497 {
2498 // Set the size of the N_SO to the terminating index of this N_SO
2499 // so that we can always skip the entire N_SO if we need to navigate
2500 // more quickly at the source level when parsing STABS
2501 symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
2502 symbol_ptr->SetByteSize(sym_idx + (minimize ? 0 : 1));
2503 symbol_ptr->SetSizeIsSibling(true);
2504 }
2505 N_NSYM_indexes.clear();
2506 N_INCL_indexes.clear();
2507 N_BRAC_indexes.clear();
2508 N_COMM_indexes.clear();
2509 N_FUN_indexes.clear();
2510 N_SO_index = UINT32_MAX;
2511 }
2512 else
2513 {
2514 // We use the current number of symbols in the symbol table in lieu of
2515 // using nlist_idx in case we ever start trimming entries out
Greg Clayton5fa6cd32012-05-30 20:20:34 +0000[diff] [blame]2516 const bool N_SO_has_full_path = symbol_name[0] == '/';
2517 if (N_SO_has_full_path)
2518 {
2519 if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2520 {
2521 // We have two consecutive N_SO entries where the first contains a directory
2522 // and the second contains a full path.
Greg Claytonc0240042012-07-18 23:18:10 +0000[diff] [blame]2523 sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name), false);
Greg Clayton5fa6cd32012-05-30 20:20:34 +0000[diff] [blame]2524 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2525 add_nlist = false;
2526 }
2527 else
2528 {
2529 // This is the first entry in a N_SO that contains a directory or
2530 // a full path to the source file
2531 N_SO_index = sym_idx;
2532 }
2533 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2534 else if (minimize && (N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms))
2535 {
Greg Clayton5fa6cd32012-05-30 20:20:34 +0000[diff] [blame]2536 // This is usually the second N_SO entry that contains just the filename,
2537 // so here we combine it with the first one if we are minimizing the symbol table
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2538 const char *so_path = sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
2539 if (so_path && so_path[0])
2540 {
2541 std::string full_so_path (so_path);
2542 if (*full_so_path.rbegin() != '/')
2543 full_so_path += '/';
2544 full_so_path += symbol_name;
Greg Claytonc0240042012-07-18 23:18:10 +0000[diff] [blame]2545 sym[sym_idx - 1].GetMangled().SetValue(ConstString(full_so_path.c_str()), false);
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2546 add_nlist = false;
2547 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2548 }
2549 }
2550 }
2551
2552 break;
2553
2554 case StabObjectFileName:
2555 // N_OSO - object file name: name,,0,0,st_mtime
2556 type = eSymbolTypeObjectFile;
2557 break;
2558
2559 case StabLocalSymbol:
2560 // N_LSYM - local sym: name,,NO_SECT,type,offset
2561 type = eSymbolTypeLocal;
2562 break;
2563
2564 //----------------------------------------------------------------------
2565 // INCL scopes
2566 //----------------------------------------------------------------------
2567 case StabBeginIncludeFileName:
2568 // N_BINCL - include file beginning: name,,NO_SECT,0,sum
2569 // We use the current number of symbols in the symbol table in lieu of
2570 // using nlist_idx in case we ever start trimming entries out
2571 N_INCL_indexes.push_back(sym_idx);
2572 type = eSymbolTypeScopeBegin;
2573 break;
2574
2575 case StabEndIncludeFile:
2576 // N_EINCL - include file end: name,,NO_SECT,0,0
2577 // Set the size of the N_BINCL to the terminating index of this N_EINCL
2578 // so that we can always skip the entire symbol if we need to navigate
2579 // more quickly at the source level when parsing STABS
2580 if ( !N_INCL_indexes.empty() )
2581 {
2582 symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
2583 symbol_ptr->SetByteSize(sym_idx + 1);
2584 symbol_ptr->SetSizeIsSibling(true);
2585 N_INCL_indexes.pop_back();
2586 }
2587 type = eSymbolTypeScopeEnd;
2588 break;
2589
2590 case StabIncludeFileName:
2591 // N_SOL - #included file name: name,,n_sect,0,address
2592 type = eSymbolTypeHeaderFile;
2593
2594 // We currently don't use the header files on darwin
2595 if (minimize)
2596 add_nlist = false;
2597 break;
2598
2599 case StabCompilerParameters:
2600 // N_PARAMS - compiler parameters: name,,NO_SECT,0,0
2601 type = eSymbolTypeCompiler;
2602 break;
2603
2604 case StabCompilerVersion:
2605 // N_VERSION - compiler version: name,,NO_SECT,0,0
2606 type = eSymbolTypeCompiler;
2607 break;
2608
2609 case StabCompilerOptLevel:
2610 // N_OLEVEL - compiler -O level: name,,NO_SECT,0,0
2611 type = eSymbolTypeCompiler;
2612 break;
2613
2614 case StabParameter:
2615 // N_PSYM - parameter: name,,NO_SECT,type,offset
2616 type = eSymbolTypeVariable;
2617 break;
2618
2619 case StabAlternateEntry:
2620 // N_ENTRY - alternate entry: name,,n_sect,linenumber,address
2621 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2622 type = eSymbolTypeLineEntry;
2623 break;
2624
2625 //----------------------------------------------------------------------
2626 // Left and Right Braces
2627 //----------------------------------------------------------------------
2628 case StabLeftBracket:
2629 // N_LBRAC - left bracket: 0,,NO_SECT,nesting level,address
2630 // We use the current number of symbols in the symbol table in lieu of
2631 // using nlist_idx in case we ever start trimming entries out
2632 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2633 N_BRAC_indexes.push_back(sym_idx);
2634 type = eSymbolTypeScopeBegin;
2635 break;
2636
2637 case StabRightBracket:
2638 // N_RBRAC - right bracket: 0,,NO_SECT,nesting level,address
2639 // Set the size of the N_LBRAC to the terminating index of this N_RBRAC
2640 // so that we can always skip the entire symbol if we need to navigate
2641 // more quickly at the source level when parsing STABS
2642 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2643 if ( !N_BRAC_indexes.empty() )
2644 {
2645 symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
2646 symbol_ptr->SetByteSize(sym_idx + 1);
2647 symbol_ptr->SetSizeIsSibling(true);
2648 N_BRAC_indexes.pop_back();
2649 }
2650 type = eSymbolTypeScopeEnd;
2651 break;
2652
2653 case StabDeletedIncludeFile:
2654 // N_EXCL - deleted include file: name,,NO_SECT,0,sum
2655 type = eSymbolTypeHeaderFile;
2656 break;
2657
2658 //----------------------------------------------------------------------
2659 // COMM scopes
2660 //----------------------------------------------------------------------
2661 case StabBeginCommon:
2662 // N_BCOMM - begin common: name,,NO_SECT,0,0
2663 // We use the current number of symbols in the symbol table in lieu of
2664 // using nlist_idx in case we ever start trimming entries out
2665 type = eSymbolTypeScopeBegin;
2666 N_COMM_indexes.push_back(sym_idx);
2667 break;
2668
2669 case StabEndCommonLocal:
2670 // N_ECOML - end common (local name): 0,,n_sect,0,address
2671 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2672 // Fall through
2673
2674 case StabEndCommon:
2675 // N_ECOMM - end common: name,,n_sect,0,0
2676 // Set the size of the N_BCOMM to the terminating index of this N_ECOMM/N_ECOML
2677 // so that we can always skip the entire symbol if we need to navigate
2678 // more quickly at the source level when parsing STABS
2679 if ( !N_COMM_indexes.empty() )
2680 {
2681 symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
2682 symbol_ptr->SetByteSize(sym_idx + 1);
2683 symbol_ptr->SetSizeIsSibling(true);
2684 N_COMM_indexes.pop_back();
2685 }
2686 type = eSymbolTypeScopeEnd;
2687 break;
2688
2689 case StabLength:
2690 // N_LENG - second stab entry with length information
2691 type = eSymbolTypeAdditional;
2692 break;
2693
2694 default: break;
2695 }
2696 }
2697 else
2698 {
2699 //uint8_t n_pext = NlistMaskPrivateExternal & nlist.n_type;
2700 uint8_t n_type = NlistMaskType & nlist.n_type;
2701 sym[sym_idx].SetExternal((NlistMaskExternal & nlist.n_type) != 0);
2702
2703 switch (n_type)
2704 {
2705 case NListTypeIndirect: // N_INDR - Fall through
2706 case NListTypePreboundUndefined:// N_PBUD - Fall through
2707 case NListTypeUndefined: // N_UNDF
2708 type = eSymbolTypeUndefined;
2709 break;
2710
2711 case NListTypeAbsolute: // N_ABS
2712 type = eSymbolTypeAbsolute;
2713 break;
2714
2715 case NListTypeSection: // N_SECT
2716 {
2717 symbol_section = section_info.GetSection (nlist.n_sect, nlist.n_value);
2718
2719 if (symbol_section == NULL)
2720 {
2721 // TODO: warn about this?
2722 add_nlist = false;
2723 break;
2724 }
2725
2726 if (TEXT_eh_frame_sectID == nlist.n_sect)
2727 {
2728 type = eSymbolTypeException;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2729 }
2730 else
2731 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2732 uint32_t section_type = symbol_section->Get() & SectionFlagMaskSectionType;
2733
2734 switch (section_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2735 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2736 case SectionTypeRegular: break; // regular section
2737 //case SectionTypeZeroFill: type = eSymbolTypeData; break; // zero fill on demand section
2738 case SectionTypeCStringLiterals: type = eSymbolTypeData; break; // section with only literal C strings
2739 case SectionType4ByteLiterals: type = eSymbolTypeData; break; // section with only 4 byte literals
2740 case SectionType8ByteLiterals: type = eSymbolTypeData; break; // section with only 8 byte literals
2741 case SectionTypeLiteralPointers: type = eSymbolTypeTrampoline; break; // section with only pointers to literals
2742 case SectionTypeNonLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only non-lazy symbol pointers
2743 case SectionTypeLazySymbolPointers: type = eSymbolTypeTrampoline; break; // section with only lazy symbol pointers
2744 case SectionTypeSymbolStubs: type = eSymbolTypeTrampoline; break; // section with only symbol stubs, byte size of stub in the reserved2 field
2745 case SectionTypeModuleInitFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for initialization
2746 case SectionTypeModuleTermFunctionPointers: type = eSymbolTypeCode; break; // section with only function pointers for termination
2747 //case SectionTypeCoalesced: type = eSymbolType; break; // section contains symbols that are to be coalesced
2748 //case SectionTypeZeroFillLarge: type = eSymbolTypeData; break; // zero fill on demand section (that can be larger than 4 gigabytes)
2749 case SectionTypeInterposing: type = eSymbolTypeTrampoline; break; // section with only pairs of function pointers for interposing
2750 case SectionType16ByteLiterals: type = eSymbolTypeData; break; // section with only 16 byte literals
2751 case SectionTypeDTraceObjectFormat: type = eSymbolTypeInstrumentation; break;
2752 case SectionTypeLazyDylibSymbolPointers: type = eSymbolTypeTrampoline; break;
2753 default: break;
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2754 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2755
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2756 if (type == eSymbolTypeInvalid)
Greg Clayton3f69eac2011-12-03 02:30:59 +0000[diff] [blame]2757 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2758 const char *symbol_sect_name = symbol_section->GetName().AsCString();
2759 if (symbol_section->IsDescendant (text_section_sp.get()))
Greg Clayton576a68b2010-09-08 16:38:06 +0000[diff] [blame]2760 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2761 if (symbol_section->IsClear(SectionAttrUserPureInstructions |
2762 SectionAttrUserSelfModifyingCode |
2763 SectionAttrSytemSomeInstructions))
2764 type = eSymbolTypeData;
2765 else
2766 type = eSymbolTypeCode;
Greg Clayton576a68b2010-09-08 16:38:06 +0000[diff] [blame]2767 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2768 else
2769 if (symbol_section->IsDescendant(data_section_sp.get()))
Greg Clayton576a68b2010-09-08 16:38:06 +0000[diff] [blame]2770 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2771 if (symbol_sect_name && ::strstr (symbol_sect_name, "__objc") == symbol_sect_name)
Greg Clayton7c36fa02010-09-11 03:13:28 +0000[diff] [blame]2772 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2773 type = eSymbolTypeRuntime;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2774
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2775 if (symbol_name &&
2776 symbol_name[0] == '_' &&
2777 symbol_name[1] == 'O' &&
2778 symbol_name[2] == 'B')
Greg Clayton637029b2010-09-12 05:25:16 +0000[diff] [blame]2779 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2780 llvm::StringRef symbol_name_ref(symbol_name);
2781 static const llvm::StringRef g_objc_v2_prefix_class ("_OBJC_CLASS_$_");
2782 static const llvm::StringRef g_objc_v2_prefix_metaclass ("_OBJC_METACLASS_$_");
2783 static const llvm::StringRef g_objc_v2_prefix_ivar ("_OBJC_IVAR_$_");
2784 if (symbol_name_ref.startswith(g_objc_v2_prefix_class))
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2785 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2786 symbol_name_non_abi_mangled = symbol_name + 1;
2787 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
2788 type = eSymbolTypeObjCClass;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2789 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2790 else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass))
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2791 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2792 symbol_name_non_abi_mangled = symbol_name + 1;
2793 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
2794 type = eSymbolTypeObjCMetaClass;
2795 }
2796 else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar))
2797 {
2798 symbol_name_non_abi_mangled = symbol_name + 1;
2799 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
2800 type = eSymbolTypeObjCIVar;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2801 }
2802 }
2803 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2804 else
2805 if (symbol_sect_name && ::strstr (symbol_sect_name, "__gcc_except_tab") == symbol_sect_name)
2806 {
2807 type = eSymbolTypeException;
2808 }
2809 else
2810 {
2811 type = eSymbolTypeData;
2812 }
2813 }
2814 else
2815 if (symbol_sect_name && ::strstr (symbol_sect_name, "__IMPORT") == symbol_sect_name)
2816 {
2817 type = eSymbolTypeTrampoline;
2818 }
2819 else
2820 if (symbol_section->IsDescendant(objc_section_sp.get()))
2821 {
2822 type = eSymbolTypeRuntime;
2823 if (symbol_name && symbol_name[0] == '.')
2824 {
2825 llvm::StringRef symbol_name_ref(symbol_name);
2826 static const llvm::StringRef g_objc_v1_prefix_class (".objc_class_name_");
2827 if (symbol_name_ref.startswith(g_objc_v1_prefix_class))
2828 {
2829 symbol_name_non_abi_mangled = symbol_name;
2830 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
2831 type = eSymbolTypeObjCClass;
2832 }
2833 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2834 }
2835 }
2836 }
2837 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2838 break;
2839 }
2840 }
2841
2842 if (add_nlist)
2843 {
2844 uint64_t symbol_value = nlist.n_value;
2845 bool symbol_name_is_mangled = false;
2846
2847 if (symbol_name_non_abi_mangled)
2848 {
Greg Claytonc0240042012-07-18 23:18:10 +0000[diff] [blame]2849 sym[sym_idx].GetMangled().SetMangledName (ConstString(symbol_name_non_abi_mangled));
2850 sym[sym_idx].GetMangled().SetDemangledName (ConstString(symbol_name));
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]2851 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2852 else
2853 {
2854 if (symbol_name && symbol_name[0] == '_')
2855 {
2856 symbol_name_is_mangled = symbol_name[1] == '_';
2857 symbol_name++; // Skip the leading underscore
2858 }
2859
2860 if (symbol_name)
2861 {
Greg Claytonc0240042012-07-18 23:18:10 +0000[diff] [blame]2862 sym[sym_idx].GetMangled().SetValue(ConstString(symbol_name), symbol_name_is_mangled);
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2863 }
2864 }
2865
2866 if (is_debug == false)
2867 {
2868 if (type == eSymbolTypeCode)
2869 {
2870 // See if we can find a N_FUN entry for any code symbols.
2871 // If we do find a match, and the name matches, then we
2872 // can merge the two into just the function symbol to avoid
2873 // duplicate entries in the symbol table
2874 ValueToSymbolIndexMap::const_iterator pos = N_FUN_addr_to_sym_idx.find (nlist.n_value);
2875 if (pos != N_FUN_addr_to_sym_idx.end())
2876 {
2877 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2878 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2879 {
2880 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2881 // We just need the flags from the linker symbol, so put these flags
2882 // into the N_FUN flags to avoid duplicate symbols in the symbol table
2883 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2884 sym[sym_idx].Clear();
2885 continue;
2886 }
2887 }
2888 }
2889 else if (type == eSymbolTypeData)
2890 {
2891 // See if we can find a N_STSYM entry for any data symbols.
2892 // If we do find a match, and the name matches, then we
2893 // can merge the two into just the Static symbol to avoid
2894 // duplicate entries in the symbol table
2895 ValueToSymbolIndexMap::const_iterator pos = N_STSYM_addr_to_sym_idx.find (nlist.n_value);
2896 if (pos != N_STSYM_addr_to_sym_idx.end())
2897 {
2898 if ((symbol_name_is_mangled == true && sym[sym_idx].GetMangled().GetMangledName() == sym[pos->second].GetMangled().GetMangledName()) ||
2899 (symbol_name_is_mangled == false && sym[sym_idx].GetMangled().GetDemangledName() == sym[pos->second].GetMangled().GetDemangledName()))
2900 {
2901 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
2902 // We just need the flags from the linker symbol, so put these flags
2903 // into the N_STSYM flags to avoid duplicate symbols in the symbol table
2904 sym[pos->second].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2905 sym[sym_idx].Clear();
2906 continue;
2907 }
2908 }
2909 }
2910 }
2911 if (symbol_section)
2912 {
2913 const addr_t section_file_addr = symbol_section->GetFileAddress();
2914 if (symbol_byte_size == 0 && function_starts_count > 0)
2915 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2916 addr_t symbol_lookup_file_addr = nlist.n_value;
2917 // Do an exact address match for non-ARM addresses, else get the closest since
2918 // the symbol might be a thumb symbol which has an address with bit zero set
2919 FunctionStarts::Entry *func_start_entry = function_starts.FindEntry (symbol_lookup_file_addr, !is_arm);
2920 if (is_arm && func_start_entry)
2921 {
2922 // Verify that the function start address is the symbol address (ARM)
2923 // or the symbol address + 1 (thumb)
2924 if (func_start_entry->addr != symbol_lookup_file_addr &&
2925 func_start_entry->addr != (symbol_lookup_file_addr + 1))
2926 {
2927 // Not the right entry, NULL it out...
2928 func_start_entry = NULL;
2929 }
2930 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2931 if (func_start_entry)
2932 {
2933 func_start_entry->data = true;
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2934
2935 addr_t symbol_file_addr = func_start_entry->addr;
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2936 if (is_arm)
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2937 symbol_file_addr &= 0xfffffffffffffffeull;
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2938
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2939 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
2940 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
2941 if (next_func_start_entry)
2942 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2943 addr_t next_symbol_file_addr = next_func_start_entry->addr;
2944 // Be sure the clear the Thumb address bit when we calculate the size
2945 // from the current and next address
2946 if (is_arm)
2947 next_symbol_file_addr &= 0xfffffffffffffffeull;
2948 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 +0000[diff] [blame]2949 }
2950 else
2951 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]2952 symbol_byte_size = section_end_file_addr - symbol_file_addr;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]2953 }
2954 }
2955 }
2956 symbol_value -= section_file_addr;
2957 }
2958
2959 sym[sym_idx].SetID (nlist_idx);
2960 sym[sym_idx].SetType (type);
2961 sym[sym_idx].GetAddress().SetSection (symbol_section);
2962 sym[sym_idx].GetAddress().SetOffset (symbol_value);
2963 sym[sym_idx].SetFlags (nlist.n_type << 16 | nlist.n_desc);
2964
2965 if (symbol_byte_size > 0)
2966 sym[sym_idx].SetByteSize(symbol_byte_size);
2967
2968 ++sym_idx;
2969 }
2970 else
2971 {
2972 sym[sym_idx].Clear();
2973 }
2974
2975 }
2976
2977 // STAB N_GSYM entries end up having a symbol type eSymbolTypeGlobal and when the symbol value
2978 // is zero, the address of the global ends up being in a non-STAB entry. Try and fix up all
2979 // such entries by figuring out what the address for the global is by looking up this non-STAB
2980 // entry and copying the value into the debug symbol's value to save us the hassle in the
2981 // debug symbol parser.
2982
2983 Symbol *global_symbol = NULL;
2984 for (nlist_idx = 0;
2985 nlist_idx < symtab_load_command.nsyms && (global_symbol = symtab->FindSymbolWithType (eSymbolTypeData, Symtab::eDebugYes, Symtab::eVisibilityAny, nlist_idx)) != NULL;
2986 nlist_idx++)
2987 {
2988 if (global_symbol->GetAddress().GetFileAddress() == 0)
2989 {
2990 std::vector<uint32_t> indexes;
2991 if (symtab->AppendSymbolIndexesWithName (global_symbol->GetMangled().GetName(), indexes) > 0)
2992 {
2993 std::vector<uint32_t>::const_iterator pos;
2994 std::vector<uint32_t>::const_iterator end = indexes.end();
2995 for (pos = indexes.begin(); pos != end; ++pos)
2996 {
2997 symbol_ptr = symtab->SymbolAtIndex(*pos);
2998 if (symbol_ptr != global_symbol && symbol_ptr->IsDebug() == false)
2999 {
3000 global_symbol->GetAddress() = symbol_ptr->GetAddress();
3001 break;
3002 }
3003 }
3004 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3005 }
3006 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3007
3008 uint32_t synthetic_sym_id = symtab_load_command.nsyms;
3009
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3010 if (function_starts_count > 0)
3011 {
3012 char synthetic_function_symbol[PATH_MAX];
3013 uint32_t num_synthetic_function_symbols = 0;
3014 for (i=0; i<function_starts_count; ++i)
3015 {
3016 if (function_starts.GetEntryRef (i).data == false)
3017 ++num_synthetic_function_symbols;
3018 }
3019
3020 if (num_synthetic_function_symbols > 0)
3021 {
3022 if (num_syms < sym_idx + num_synthetic_function_symbols)
3023 {
3024 num_syms = sym_idx + num_synthetic_function_symbols;
3025 sym = symtab->Resize (num_syms);
3026 }
3027 uint32_t synthetic_function_symbol_idx = 0;
3028 for (i=0; i<function_starts_count; ++i)
3029 {
3030 const FunctionStarts::Entry *func_start_entry = function_starts.GetEntryAtIndex (i);
3031 if (func_start_entry->data == false)
3032 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]3033 addr_t symbol_file_addr = func_start_entry->addr;
3034 uint32_t symbol_flags = 0;
3035 if (is_arm)
3036 {
3037 if (symbol_file_addr & 1)
3038 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
3039 symbol_file_addr &= 0xfffffffffffffffeull;
3040 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3041 Address symbol_addr;
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]3042 if (module_sp->ResolveFileAddress (symbol_file_addr, symbol_addr))
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3043 {
3044 SectionSP symbol_section (symbol_addr.GetSection());
3045 uint32_t symbol_byte_size = 0;
3046 if (symbol_section)
3047 {
3048 const addr_t section_file_addr = symbol_section->GetFileAddress();
3049 const FunctionStarts::Entry *next_func_start_entry = function_starts.FindNextEntry (func_start_entry);
3050 const addr_t section_end_file_addr = section_file_addr + symbol_section->GetByteSize();
3051 if (next_func_start_entry)
3052 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]3053 addr_t next_symbol_file_addr = next_func_start_entry->addr;
3054 if (is_arm)
3055 next_symbol_file_addr &= 0xfffffffffffffffeull;
3056 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 +0000[diff] [blame]3057 }
3058 else
3059 {
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]3060 symbol_byte_size = section_end_file_addr - symbol_file_addr;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3061 }
3062 snprintf (synthetic_function_symbol,
3063 sizeof(synthetic_function_symbol),
3064 "___lldb_unnamed_function%u$$%s",
3065 ++synthetic_function_symbol_idx,
3066 module_sp->GetFileSpec().GetFilename().GetCString());
3067 sym[sym_idx].SetID (synthetic_sym_id++);
Greg Claytonc0240042012-07-18 23:18:10 +0000[diff] [blame]3068 sym[sym_idx].GetMangled().SetDemangledName(ConstString(synthetic_function_symbol));
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3069 sym[sym_idx].SetType (eSymbolTypeCode);
3070 sym[sym_idx].SetIsSynthetic (true);
3071 sym[sym_idx].GetAddress() = symbol_addr;
Greg Claytond2653c22012-03-14 01:53:24 +0000[diff] [blame]3072 if (symbol_flags)
3073 sym[sym_idx].SetFlags (symbol_flags);
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3074 if (symbol_byte_size)
3075 sym[sym_idx].SetByteSize (symbol_byte_size);
3076 ++sym_idx;
3077 }
3078 }
3079 }
3080 }
3081 }
3082 }
3083
3084 // Trim our symbols down to just what we ended up with after
3085 // removing any symbols.
3086 if (sym_idx < num_syms)
3087 {
3088 num_syms = sym_idx;
3089 sym = symtab->Resize (num_syms);
3090 }
3091
3092 // Now synthesize indirect symbols
3093 if (m_dysymtab.nindirectsyms != 0)
3094 {
3095 DataExtractor indirect_symbol_index_data (m_data, m_dysymtab.indirectsymoff, m_dysymtab.nindirectsyms * 4);
3096
3097 if (indirect_symbol_index_data.GetByteSize())
3098 {
3099 NListIndexToSymbolIndexMap::const_iterator end_index_pos = m_nlist_idx_to_sym_idx.end();
3100
3101 for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size(); ++sect_idx)
3102 {
3103 if ((m_mach_sections[sect_idx].flags & SectionFlagMaskSectionType) == SectionTypeSymbolStubs)
3104 {
3105 uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2;
3106 if (symbol_stub_byte_size == 0)
3107 continue;
3108
3109 const uint32_t num_symbol_stubs = m_mach_sections[sect_idx].size / symbol_stub_byte_size;
3110
3111 if (num_symbol_stubs == 0)
3112 continue;
3113
3114 const uint32_t symbol_stub_index_offset = m_mach_sections[sect_idx].reserved1;
3115 for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx)
3116 {
3117 const uint32_t symbol_stub_index = symbol_stub_index_offset + stub_idx;
3118 const lldb::addr_t symbol_stub_addr = m_mach_sections[sect_idx].addr + (stub_idx * symbol_stub_byte_size);
3119 uint32_t symbol_stub_offset = symbol_stub_index * 4;
3120 if (indirect_symbol_index_data.ValidOffsetForDataOfSize(symbol_stub_offset, 4))
3121 {
3122 const uint32_t stub_sym_id = indirect_symbol_index_data.GetU32 (&symbol_stub_offset);
3123 if (stub_sym_id & (IndirectSymbolAbsolute | IndirectSymbolLocal))
3124 continue;
3125
3126 NListIndexToSymbolIndexMap::const_iterator index_pos = m_nlist_idx_to_sym_idx.find (stub_sym_id);
3127 Symbol *stub_symbol = NULL;
3128 if (index_pos != end_index_pos)
3129 {
3130 // We have a remapping from the original nlist index to
3131 // a current symbol index, so just look this up by index
3132 stub_symbol = symtab->SymbolAtIndex (index_pos->second);
3133 }
3134 else
3135 {
3136 // We need to lookup a symbol using the original nlist
3137 // symbol index since this index is coming from the
3138 // S_SYMBOL_STUBS
3139 stub_symbol = symtab->FindSymbolByID (stub_sym_id);
3140 }
3141
3142 assert (stub_symbol);
3143 if (stub_symbol)
3144 {
3145 Address so_addr(symbol_stub_addr, section_list);
3146
3147 if (stub_symbol->GetType() == eSymbolTypeUndefined)
3148 {
3149 // Change the external symbol into a trampoline that makes sense
3150 // These symbols were N_UNDF N_EXT, and are useless to us, so we
3151 // can re-use them so we don't have to make up a synthetic symbol
3152 // for no good reason.
3153 stub_symbol->SetType (eSymbolTypeTrampoline);
3154 stub_symbol->SetExternal (false);
3155 stub_symbol->GetAddress() = so_addr;
3156 stub_symbol->SetByteSize (symbol_stub_byte_size);
3157 }
3158 else
3159 {
3160 // Make a synthetic symbol to describe the trampoline stub
Jason Molenda2a76fbf2012-04-24 02:09:58 +0000[diff] [blame]3161 Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3162 if (sym_idx >= num_syms)
Jason Molenda2a76fbf2012-04-24 02:09:58 +0000[diff] [blame]3163 {
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3164 sym = symtab->Resize (++num_syms);
Jason Molenda2a76fbf2012-04-24 02:09:58 +0000[diff] [blame]3165 stub_symbol = NULL; // this pointer no longer valid
3166 }
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3167 sym[sym_idx].SetID (synthetic_sym_id++);
Jason Molenda2a76fbf2012-04-24 02:09:58 +0000[diff] [blame]3168 sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
Greg Clayton4aa2edf2012-03-09 04:26:05 +0000[diff] [blame]3169 sym[sym_idx].SetType (eSymbolTypeTrampoline);
3170 sym[sym_idx].SetIsSynthetic (true);
3171 sym[sym_idx].GetAddress() = so_addr;
3172 sym[sym_idx].SetByteSize (symbol_stub_byte_size);
3173 ++sym_idx;
3174 }
3175 }
3176 }
3177 }
3178 }
3179 }
3180 }
3181 }
3182 return symtab->GetNumSymbols();
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3183 }
3184 return 0;
3185}
3186
3187
3188void
3189ObjectFileMachO::Dump (Stream *s)
3190{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3191 ModuleSP module_sp(GetModule());
3192 if (module_sp)
3193 {
3194 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3195 s->Printf("%p: ", this);
3196 s->Indent();
3197 if (m_header.magic == HeaderMagic64 || m_header.magic == HeaderMagic64Swapped)
3198 s->PutCString("ObjectFileMachO64");
3199 else
3200 s->PutCString("ObjectFileMachO32");
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3201
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3202 ArchSpec header_arch(eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3203
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3204 *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n";
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3205
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3206 if (m_sections_ap.get())
3207 m_sections_ap->Dump(s, NULL, true, UINT32_MAX);
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3208
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3209 if (m_symtab_ap.get())
3210 m_symtab_ap->Dump(s, NULL, eSortOrderNone);
3211 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3212}
3213
3214
3215bool
Greg Clayton0467c782011-02-04 18:53:10 +0000[diff] [blame]3216ObjectFileMachO::GetUUID (lldb_private::UUID* uuid)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3217{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3218 ModuleSP module_sp(GetModule());
3219 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3220 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3221 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3222 struct uuid_command load_cmd;
3223 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
3224 uint32_t i;
3225 for (i=0; i<m_header.ncmds; ++i)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3226 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3227 const uint32_t cmd_offset = offset;
3228 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3229 break;
3230
3231 if (load_cmd.cmd == LoadCommandUUID)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3232 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3233 const uint8_t *uuid_bytes = m_data.PeekData(offset, 16);
Sean Callanana5689d52012-07-12 18:04:03 +0000[diff] [blame]3234
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3235 if (uuid_bytes)
3236 {
Sean Callanana5689d52012-07-12 18:04:03 +0000[diff] [blame]3237 // OpenCL on Mac OS X uses the same UUID for each of its object files.
3238 // We pretend these object files have no UUID to prevent crashing.
3239
3240 const uint8_t opencl_uuid[] = { 0x8c, 0x8e, 0xb3, 0x9b,
3241 0x3b, 0xa8,
3242 0x4b, 0x16,
3243 0xb6, 0xa4,
3244 0x27, 0x63, 0xbb, 0x14, 0xf0, 0x0d };
3245
3246 if (!memcmp(uuid_bytes, opencl_uuid, 16))
3247 return false;
3248
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3249 uuid->SetBytes (uuid_bytes);
3250 return true;
3251 }
3252 return false;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3253 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3254 offset = cmd_offset + load_cmd.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3255 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3256 }
3257 return false;
3258}
3259
3260
3261uint32_t
3262ObjectFileMachO::GetDependentModules (FileSpecList& files)
3263{
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3264 uint32_t count = 0;
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3265 ModuleSP module_sp(GetModule());
3266 if (module_sp)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3267 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3268 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3269 struct load_command load_cmd;
3270 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
3271 const bool resolve_path = false; // Don't resolve the dependend file paths since they may not reside on this system
3272 uint32_t i;
3273 for (i=0; i<m_header.ncmds; ++i)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3274 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3275 const uint32_t cmd_offset = offset;
3276 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3277 break;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3278
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3279 switch (load_cmd.cmd)
3280 {
3281 case LoadCommandDylibLoad:
3282 case LoadCommandDylibLoadWeak:
3283 case LoadCommandDylibReexport:
3284 case LoadCommandDynamicLinkerLoad:
3285 case LoadCommandFixedVMShlibLoad:
3286 case LoadCommandDylibLoadUpward:
3287 {
3288 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
3289 const char *path = m_data.PeekCStr(name_offset);
3290 // Skip any path that starts with '@' since these are usually:
3291 // @executable_path/.../file
3292 // @rpath/.../file
3293 if (path && path[0] != '@')
3294 {
3295 FileSpec file_spec(path, resolve_path);
3296 if (files.AppendIfUnique(file_spec))
3297 count++;
3298 }
3299 }
3300 break;
3301
3302 default:
3303 break;
3304 }
3305 offset = cmd_offset + load_cmd.cmdsize;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3306 }
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3307 }
3308 return count;
3309}
3310
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3311lldb_private::Address
3312ObjectFileMachO::GetEntryPointAddress ()
3313{
3314 // If the object file is not an executable it can't hold the entry point. m_entry_point_address
3315 // is initialized to an invalid address, so we can just return that.
3316 // If m_entry_point_address is valid it means we've found it already, so return the cached value.
3317
3318 if (!IsExecutable() || m_entry_point_address.IsValid())
3319 return m_entry_point_address;
3320
3321 // Otherwise, look for the UnixThread or Thread command. The data for the Thread command is given in
3322 // /usr/include/mach-o.h, but it is basically:
3323 //
3324 // uint32_t flavor - this is the flavor argument you would pass to thread_get_state
3325 // uint32_t count - this is the count of longs in the thread state data
3326 // struct XXX_thread_state state - this is the structure from <machine/thread_status.h> corresponding to the flavor.
3327 // <repeat this trio>
3328 //
3329 // So we just keep reading the various register flavors till we find the GPR one, then read the PC out of there.
3330 // FIXME: We will need to have a "RegisterContext data provider" class at some point that can get all the registers
3331 // out of data in this form & attach them to a given thread. That should underlie the MacOS X User process plugin,
3332 // and we'll also need it for the MacOS X Core File process plugin. When we have that we can also use it here.
3333 //
3334 // For now we hard-code the offsets and flavors we need:
3335 //
3336 //
3337
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3338 ModuleSP module_sp(GetModule());
3339 if (module_sp)
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3340 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3341 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3342 struct load_command load_cmd;
3343 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
3344 uint32_t i;
3345 lldb::addr_t start_address = LLDB_INVALID_ADDRESS;
3346 bool done = false;
3347
3348 for (i=0; i<m_header.ncmds; ++i)
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3349 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3350 const uint32_t cmd_offset = offset;
3351 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3352 break;
3353
3354 switch (load_cmd.cmd)
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3355 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3356 case LoadCommandUnixThread:
3357 case LoadCommandThread:
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3358 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3359 while (offset < cmd_offset + load_cmd.cmdsize)
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3360 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3361 uint32_t flavor = m_data.GetU32(&offset);
3362 uint32_t count = m_data.GetU32(&offset);
3363 if (count == 0)
3364 {
3365 // We've gotten off somehow, log and exit;
3366 return m_entry_point_address;
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3367 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3368
3369 switch (m_header.cputype)
3370 {
3371 case llvm::MachO::CPUTypeARM:
3372 if (flavor == 1) // ARM_THREAD_STATE from mach/arm/thread_status.h
3373 {
3374 offset += 60; // This is the offset of pc in the GPR thread state data structure.
3375 start_address = m_data.GetU32(&offset);
3376 done = true;
3377 }
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3378 break;
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3379 case llvm::MachO::CPUTypeI386:
3380 if (flavor == 1) // x86_THREAD_STATE32 from mach/i386/thread_status.h
3381 {
3382 offset += 40; // This is the offset of eip in the GPR thread state data structure.
3383 start_address = m_data.GetU32(&offset);
3384 done = true;
3385 }
3386 break;
3387 case llvm::MachO::CPUTypeX86_64:
3388 if (flavor == 4) // x86_THREAD_STATE64 from mach/i386/thread_status.h
3389 {
3390 offset += 16 * 8; // This is the offset of rip in the GPR thread state data structure.
3391 start_address = m_data.GetU64(&offset);
3392 done = true;
3393 }
3394 break;
3395 default:
3396 return m_entry_point_address;
3397 }
3398 // Haven't found the GPR flavor yet, skip over the data for this flavor:
3399 if (done)
3400 break;
3401 offset += count * 4;
3402 }
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3403 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3404 break;
3405 case LoadCommandMain:
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000[diff] [blame]3406 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3407 ConstString text_segment_name ("__TEXT");
3408 uint64_t entryoffset = m_data.GetU64(&offset);
3409 SectionSP text_segment_sp = GetSectionList()->FindSectionByName(text_segment_name);
3410 if (text_segment_sp)
3411 {
3412 done = true;
3413 start_address = text_segment_sp->GetFileAddress() + entryoffset;
3414 }
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000[diff] [blame]3415 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3416
3417 default:
3418 break;
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000[diff] [blame]3419 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3420 if (done)
3421 break;
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3422
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3423 // Go to the next load command:
3424 offset = cmd_offset + load_cmd.cmdsize;
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3425 }
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3426
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3427 if (start_address != LLDB_INVALID_ADDRESS)
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]3428 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3429 // We got the start address from the load commands, so now resolve that address in the sections
3430 // of this ObjectFile:
3431 if (!m_entry_point_address.ResolveAddressUsingFileSections (start_address, GetSectionList()))
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]3432 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3433 m_entry_point_address.Clear();
3434 }
3435 }
3436 else
3437 {
3438 // We couldn't read the UnixThread load command - maybe it wasn't there. As a fallback look for the
3439 // "start" symbol in the main executable.
3440
3441 ModuleSP module_sp (GetModule());
3442
3443 if (module_sp)
3444 {
3445 SymbolContextList contexts;
3446 SymbolContext context;
3447 if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), eSymbolTypeCode, contexts))
3448 {
3449 if (contexts.GetContextAtIndex(0, context))
3450 m_entry_point_address = context.symbol->GetAddress();
3451 }
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]3452 }
3453 }
Jim Ingham28775942011-03-07 23:44:08 +0000[diff] [blame]3454 }
3455
3456 return m_entry_point_address;
3457
3458}
3459
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]3460lldb_private::Address
3461ObjectFileMachO::GetHeaderAddress ()
3462{
3463 lldb_private::Address header_addr;
3464 SectionList *section_list = GetSectionList();
3465 if (section_list)
3466 {
3467 SectionSP text_segment_sp (section_list->FindSectionByName (GetSegmentNameTEXT()));
3468 if (text_segment_sp)
3469 {
Greg Clayton3508c382012-02-24 01:59:29 +0000[diff] [blame]3470 header_addr.SetSection (text_segment_sp);
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]3471 header_addr.SetOffset (0);
3472 }
3473 }
3474 return header_addr;
3475}
3476
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3477uint32_t
3478ObjectFileMachO::GetNumThreadContexts ()
3479{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3480 ModuleSP module_sp(GetModule());
3481 if (module_sp)
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3482 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3483 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3484 if (!m_thread_context_offsets_valid)
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3485 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3486 m_thread_context_offsets_valid = true;
3487 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
3488 FileRangeArray::Entry file_range;
3489 thread_command thread_cmd;
3490 for (uint32_t i=0; i<m_header.ncmds; ++i)
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3491 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3492 const uint32_t cmd_offset = offset;
3493 if (m_data.GetU32(&offset, &thread_cmd, 2) == NULL)
3494 break;
3495
3496 if (thread_cmd.cmd == LoadCommandThread)
3497 {
3498 file_range.SetRangeBase (offset);
3499 file_range.SetByteSize (thread_cmd.cmdsize - 8);
3500 m_thread_context_offsets.Append (file_range);
3501 }
3502 offset = cmd_offset + thread_cmd.cmdsize;
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3503 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3504 }
3505 }
3506 return m_thread_context_offsets.GetSize();
3507}
3508
3509lldb::RegisterContextSP
3510ObjectFileMachO::GetThreadContextAtIndex (uint32_t idx, lldb_private::Thread &thread)
3511{
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3512 lldb::RegisterContextSP reg_ctx_sp;
Greg Clayton9ce95382012-02-13 23:10:39 +0000[diff] [blame]3513
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3514 ModuleSP module_sp(GetModule());
3515 if (module_sp)
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3516 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3517 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3518 if (!m_thread_context_offsets_valid)
3519 GetNumThreadContexts ();
3520
3521 const FileRangeArray::Entry *thread_context_file_range = m_thread_context_offsets.GetEntryAtIndex (idx);
3522
3523 DataExtractor data (m_data,
3524 thread_context_file_range->GetRangeBase(),
3525 thread_context_file_range->GetByteSize());
3526
3527 switch (m_header.cputype)
3528 {
3529 case llvm::MachO::CPUTypeARM:
3530 reg_ctx_sp.reset (new RegisterContextDarwin_arm_Mach (thread, data));
3531 break;
3532
3533 case llvm::MachO::CPUTypeI386:
3534 reg_ctx_sp.reset (new RegisterContextDarwin_i386_Mach (thread, data));
3535 break;
3536
3537 case llvm::MachO::CPUTypeX86_64:
3538 reg_ctx_sp.reset (new RegisterContextDarwin_x86_64_Mach (thread, data));
3539 break;
3540 }
Greg Clayton46c9a352012-02-09 06:16:32 +0000[diff] [blame]3541 }
3542 return reg_ctx_sp;
3543}
3544
Greg Claytonb5a8f142012-02-05 02:38:54 +0000[diff] [blame]3545
Greg Claytonca319972011-07-09 00:41:34 +0000[diff] [blame]3546ObjectFile::Type
3547ObjectFileMachO::CalculateType()
3548{
3549 switch (m_header.filetype)
3550 {
3551 case HeaderFileTypeObject: // 0x1u MH_OBJECT
3552 if (GetAddressByteSize () == 4)
3553 {
3554 // 32 bit kexts are just object files, but they do have a valid
3555 // UUID load command.
3556 UUID uuid;
3557 if (GetUUID(&uuid))
3558 {
3559 // this checking for the UUID load command is not enough
3560 // we could eventually look for the symbol named
3561 // "OSKextGetCurrentIdentifier" as this is required of kexts
3562 if (m_strata == eStrataInvalid)
3563 m_strata = eStrataKernel;
3564 return eTypeSharedLibrary;
3565 }
3566 }
3567 return eTypeObjectFile;
3568
3569 case HeaderFileTypeExecutable: return eTypeExecutable; // 0x2u MH_EXECUTE
3570 case HeaderFileTypeFixedVMShlib: return eTypeSharedLibrary; // 0x3u MH_FVMLIB
3571 case HeaderFileTypeCore: return eTypeCoreFile; // 0x4u MH_CORE
3572 case HeaderFileTypePreloadedExecutable: return eTypeSharedLibrary; // 0x5u MH_PRELOAD
3573 case HeaderFileTypeDynamicShlib: return eTypeSharedLibrary; // 0x6u MH_DYLIB
3574 case HeaderFileTypeDynamicLinkEditor: return eTypeDynamicLinker; // 0x7u MH_DYLINKER
3575 case HeaderFileTypeBundle: return eTypeSharedLibrary; // 0x8u MH_BUNDLE
3576 case HeaderFileTypeDynamicShlibStub: return eTypeStubLibrary; // 0x9u MH_DYLIB_STUB
3577 case HeaderFileTypeDSYM: return eTypeDebugInfo; // 0xAu MH_DSYM
3578 case HeaderFileTypeKextBundle: return eTypeSharedLibrary; // 0xBu MH_KEXT_BUNDLE
3579 default:
3580 break;
3581 }
3582 return eTypeUnknown;
3583}
3584
3585ObjectFile::Strata
3586ObjectFileMachO::CalculateStrata()
3587{
3588 switch (m_header.filetype)
3589 {
3590 case HeaderFileTypeObject: // 0x1u MH_OBJECT
3591 {
3592 // 32 bit kexts are just object files, but they do have a valid
3593 // UUID load command.
3594 UUID uuid;
3595 if (GetUUID(&uuid))
3596 {
3597 // this checking for the UUID load command is not enough
3598 // we could eventually look for the symbol named
3599 // "OSKextGetCurrentIdentifier" as this is required of kexts
3600 if (m_type == eTypeInvalid)
3601 m_type = eTypeSharedLibrary;
3602
3603 return eStrataKernel;
3604 }
3605 }
3606 return eStrataUnknown;
3607
3608 case HeaderFileTypeExecutable: // 0x2u MH_EXECUTE
3609 // Check for the MH_DYLDLINK bit in the flags
3610 if (m_header.flags & HeaderFlagBitIsDynamicLinkObject)
Sean Callananac725af2012-02-10 20:22:35 +0000[diff] [blame]3611 {
Greg Claytonca319972011-07-09 00:41:34 +0000[diff] [blame]3612 return eStrataUser;
Sean Callananac725af2012-02-10 20:22:35 +0000[diff] [blame]3613 }
3614 else
3615 {
3616 SectionList *section_list = GetSectionList();
3617 if (section_list)
3618 {
3619 static ConstString g_kld_section_name ("__KLD");
3620 if (section_list->FindSectionByName(g_kld_section_name))
3621 return eStrataKernel;
3622 }
3623 }
3624 return eStrataRawImage;
Greg Claytonca319972011-07-09 00:41:34 +0000[diff] [blame]3625
3626 case HeaderFileTypeFixedVMShlib: return eStrataUser; // 0x3u MH_FVMLIB
3627 case HeaderFileTypeCore: return eStrataUnknown; // 0x4u MH_CORE
Sean Callananac725af2012-02-10 20:22:35 +0000[diff] [blame]3628 case HeaderFileTypePreloadedExecutable: return eStrataRawImage; // 0x5u MH_PRELOAD
Greg Claytonca319972011-07-09 00:41:34 +0000[diff] [blame]3629 case HeaderFileTypeDynamicShlib: return eStrataUser; // 0x6u MH_DYLIB
3630 case HeaderFileTypeDynamicLinkEditor: return eStrataUser; // 0x7u MH_DYLINKER
3631 case HeaderFileTypeBundle: return eStrataUser; // 0x8u MH_BUNDLE
3632 case HeaderFileTypeDynamicShlibStub: return eStrataUser; // 0x9u MH_DYLIB_STUB
3633 case HeaderFileTypeDSYM: return eStrataUnknown; // 0xAu MH_DSYM
3634 case HeaderFileTypeKextBundle: return eStrataKernel; // 0xBu MH_KEXT_BUNDLE
3635 default:
3636 break;
3637 }
3638 return eStrataUnknown;
3639}
3640
3641
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3642uint32_t
3643ObjectFileMachO::GetVersion (uint32_t *versions, uint32_t num_versions)
3644{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3645 ModuleSP module_sp(GetModule());
3646 if (module_sp)
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3647 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3648 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3649 struct dylib_command load_cmd;
3650 uint32_t offset = MachHeaderSizeFromMagic(m_header.magic);
3651 uint32_t version_cmd = 0;
3652 uint64_t version = 0;
3653 uint32_t i;
3654 for (i=0; i<m_header.ncmds; ++i)
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3655 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3656 const uint32_t cmd_offset = offset;
3657 if (m_data.GetU32(&offset, &load_cmd, 2) == NULL)
3658 break;
3659
3660 if (load_cmd.cmd == LoadCommandDylibIdent)
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3661 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3662 if (version_cmd == 0)
3663 {
3664 version_cmd = load_cmd.cmd;
3665 if (m_data.GetU32(&offset, &load_cmd.dylib, 4) == NULL)
3666 break;
3667 version = load_cmd.dylib.current_version;
3668 }
3669 break; // Break for now unless there is another more complete version
3670 // number load command in the future.
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3671 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3672 offset = cmd_offset + load_cmd.cmdsize;
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3673 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3674
3675 if (version_cmd == LoadCommandDylibIdent)
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3676 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3677 if (versions != NULL && num_versions > 0)
3678 {
3679 if (num_versions > 0)
3680 versions[0] = (version & 0xFFFF0000ull) >> 16;
3681 if (num_versions > 1)
3682 versions[1] = (version & 0x0000FF00ull) >> 8;
3683 if (num_versions > 2)
3684 versions[2] = (version & 0x000000FFull);
3685 // Fill in an remaining version numbers with invalid values
3686 for (i=3; i<num_versions; ++i)
3687 versions[i] = UINT32_MAX;
3688 }
3689 // The LC_ID_DYLIB load command has a version with 3 version numbers
3690 // in it, so always return 3
3691 return 3;
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3692 }
Greg Clayton49f4bf22012-02-22 19:41:02 +0000[diff] [blame]3693 }
3694 return false;
3695}
3696
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3697bool
Greg Clayton395fc332011-02-15 21:59:32 +0000[diff] [blame]3698ObjectFileMachO::GetArchitecture (ArchSpec &arch)
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3699{
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3700 ModuleSP module_sp(GetModule());
3701 if (module_sp)
Greg Clayton6a64bbf2011-09-21 03:57:31 +0000[diff] [blame]3702 {
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3703 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
3704 arch.SetArchitecture (eArchTypeMachO, m_header.cputype, m_header.cpusubtype);
3705
3706 // Files with type MH_PRELOAD are currently used in cases where the image
3707 // debugs at the addresses in the file itself. Below we set the OS to
3708 // unknown to make sure we use the DynamicLoaderStatic()...
3709 if (m_header.filetype == HeaderFileTypePreloadedExecutable)
3710 {
3711 arch.GetTriple().setOS (llvm::Triple::UnknownOS);
3712 }
3713 return true;
Greg Clayton6a64bbf2011-09-21 03:57:31 +0000[diff] [blame]3714 }
Greg Clayton9482f052012-03-13 23:14:29 +0000[diff] [blame]3715 return false;
Chris Lattner24943d22010-06-08 16:52:24 +0000[diff] [blame]3716}
3717
3718
3719//------------------------------------------------------------------
3720// PluginInterface protocol
3721//------------------------------------------------------------------
3722const char *
3723ObjectFileMachO::GetPluginName()
3724{
3725 return "ObjectFileMachO";
3726}
3727
3728const char *
3729ObjectFileMachO::GetShortPluginName()
3730{
3731 return GetPluginNameStatic();
3732}
3733
3734uint32_t
3735ObjectFileMachO::GetPluginVersion()
3736{
3737 return 1;
3738}
3739