LLDB mainline
ObjectFileMachO.cpp
Go to the documentation of this file.
1//===-- ObjectFileMachO.cpp -----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/ADT/ScopeExit.h"
10#include "llvm/ADT/StringRef.h"
11
16#include "lldb/Core/Debugger.h"
17#include "lldb/Core/Module.h"
20#include "lldb/Core/Progress.h"
21#include "lldb/Core/Section.h"
22#include "lldb/Host/Host.h"
28#include "lldb/Target/Process.h"
30#include "lldb/Target/Target.h"
31#include "lldb/Target/Thread.h"
38#include "lldb/Utility/Log.h"
41#include "lldb/Utility/Status.h"
43#include "lldb/Utility/Timer.h"
44#include "lldb/Utility/UUID.h"
45
46#include "lldb/Host/SafeMachO.h"
47
48#include "llvm/ADT/DenseSet.h"
49#include "llvm/Support/FormatVariadic.h"
50#include "llvm/Support/MemoryBuffer.h"
51
52#include "ObjectFileMachO.h"
53
54#if defined(__APPLE__)
55#include <TargetConditionals.h>
56// GetLLDBSharedCacheUUID() needs to call dlsym()
57#include <dlfcn.h>
58#include <mach/mach_init.h>
59#include <mach/vm_map.h>
60#include <lldb/Host/SafeMachO.h>
61#endif
62
63#ifndef __APPLE__
65#else
66#include <uuid/uuid.h>
67#endif
68
69#include <bitset>
70#include <memory>
71#include <optional>
72
73// Unfortunately the signpost header pulls in the system MachO header, too.
74#ifdef CPU_TYPE_ARM
75#undef CPU_TYPE_ARM
76#endif
77#ifdef CPU_TYPE_ARM64
78#undef CPU_TYPE_ARM64
79#endif
80#ifdef CPU_TYPE_ARM64_32
81#undef CPU_TYPE_ARM64_32
82#endif
83#ifdef CPU_TYPE_X86_64
84#undef CPU_TYPE_X86_64
85#endif
86#ifdef MH_DYLINKER
87#undef MH_DYLINKER
88#endif
89#ifdef MH_OBJECT
90#undef MH_OBJECT
91#endif
92#ifdef LC_VERSION_MIN_MACOSX
93#undef LC_VERSION_MIN_MACOSX
94#endif
95#ifdef LC_VERSION_MIN_IPHONEOS
96#undef LC_VERSION_MIN_IPHONEOS
97#endif
98#ifdef LC_VERSION_MIN_TVOS
99#undef LC_VERSION_MIN_TVOS
100#endif
101#ifdef LC_VERSION_MIN_WATCHOS
102#undef LC_VERSION_MIN_WATCHOS
103#endif
104#ifdef LC_BUILD_VERSION
105#undef LC_BUILD_VERSION
106#endif
107#ifdef PLATFORM_MACOS
108#undef PLATFORM_MACOS
109#endif
110#ifdef PLATFORM_MACCATALYST
111#undef PLATFORM_MACCATALYST
112#endif
113#ifdef PLATFORM_IOS
114#undef PLATFORM_IOS
115#endif
116#ifdef PLATFORM_IOSSIMULATOR
117#undef PLATFORM_IOSSIMULATOR
118#endif
119#ifdef PLATFORM_TVOS
120#undef PLATFORM_TVOS
121#endif
122#ifdef PLATFORM_TVOSSIMULATOR
123#undef PLATFORM_TVOSSIMULATOR
124#endif
125#ifdef PLATFORM_WATCHOS
126#undef PLATFORM_WATCHOS
127#endif
128#ifdef PLATFORM_WATCHOSSIMULATOR
129#undef PLATFORM_WATCHOSSIMULATOR
130#endif
131
132#define THUMB_ADDRESS_BIT_MASK 0xfffffffffffffffeull
133using namespace lldb;
134using namespace lldb_private;
135using namespace llvm::MachO;
136
137static constexpr llvm::StringLiteral g_loader_path = "@loader_path";
138static constexpr llvm::StringLiteral g_executable_path = "@executable_path";
139
141
142static void PrintRegisterValue(RegisterContext *reg_ctx, const char *name,
143 const char *alt_name, size_t reg_byte_size,
144 Stream &data) {
145 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(name);
146 if (reg_info == nullptr)
147 reg_info = reg_ctx->GetRegisterInfoByName(alt_name);
148 if (reg_info) {
150 if (reg_ctx->ReadRegister(reg_info, reg_value)) {
151 if (reg_info->byte_size >= reg_byte_size)
152 data.Write(reg_value.GetBytes(), reg_byte_size);
153 else {
154 data.Write(reg_value.GetBytes(), reg_info->byte_size);
155 for (size_t i = 0, n = reg_byte_size - reg_info->byte_size; i < n; ++i)
156 data.PutChar(0);
157 }
158 return;
159 }
160 }
161 // Just write zeros if all else fails
162 for (size_t i = 0; i < reg_byte_size; ++i)
163 data.PutChar(0);
164}
165
167public:
173
174 void InvalidateAllRegisters() override {
175 // Do nothing... registers are always valid...
176 }
177
179 lldb::offset_t offset = 0;
180 SetError(GPRRegSet, Read, -1);
181 SetError(FPURegSet, Read, -1);
182 SetError(EXCRegSet, Read, -1);
183
184 while (offset < data.GetByteSize()) {
185 int flavor = data.GetU32(&offset);
186 if (flavor == 0)
187 break;
188 uint32_t count = data.GetU32(&offset);
189 switch (flavor) {
190 case GPRRegSet: {
191 uint32_t *gpr_data = reinterpret_cast<uint32_t *>(&gpr.rax);
192 for (uint32_t i = 0; i < count && offset < data.GetByteSize(); ++i)
193 gpr_data[i] = data.GetU32(&offset);
195 } break;
196 case FPURegSet:
197 // TODO: fill in FPU regs....
198 SetError(FPURegSet, Read, -1);
199 break;
200 case EXCRegSet:
201 exc.trapno = data.GetU32(&offset);
202 exc.err = data.GetU32(&offset);
203 exc.faultvaddr = data.GetU64(&offset);
205 break;
206 default:
207 offset += count * 4;
208 break;
209 }
210 }
211 }
212
213 static bool Create_LC_THREAD(Thread *thread, Stream &data) {
214 RegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
215 if (reg_ctx_sp) {
216 RegisterContext *reg_ctx = reg_ctx_sp.get();
217
218 data.PutHex32(GPRRegSet); // Flavor
220 PrintRegisterValue(reg_ctx, "rax", nullptr, 8, data);
221 PrintRegisterValue(reg_ctx, "rbx", nullptr, 8, data);
222 PrintRegisterValue(reg_ctx, "rcx", nullptr, 8, data);
223 PrintRegisterValue(reg_ctx, "rdx", nullptr, 8, data);
224 PrintRegisterValue(reg_ctx, "rdi", nullptr, 8, data);
225 PrintRegisterValue(reg_ctx, "rsi", nullptr, 8, data);
226 PrintRegisterValue(reg_ctx, "rbp", nullptr, 8, data);
227 PrintRegisterValue(reg_ctx, "rsp", nullptr, 8, data);
228 PrintRegisterValue(reg_ctx, "r8", nullptr, 8, data);
229 PrintRegisterValue(reg_ctx, "r9", nullptr, 8, data);
230 PrintRegisterValue(reg_ctx, "r10", nullptr, 8, data);
231 PrintRegisterValue(reg_ctx, "r11", nullptr, 8, data);
232 PrintRegisterValue(reg_ctx, "r12", nullptr, 8, data);
233 PrintRegisterValue(reg_ctx, "r13", nullptr, 8, data);
234 PrintRegisterValue(reg_ctx, "r14", nullptr, 8, data);
235 PrintRegisterValue(reg_ctx, "r15", nullptr, 8, data);
236 PrintRegisterValue(reg_ctx, "rip", nullptr, 8, data);
237 PrintRegisterValue(reg_ctx, "rflags", nullptr, 8, data);
238 PrintRegisterValue(reg_ctx, "cs", nullptr, 8, data);
239 PrintRegisterValue(reg_ctx, "fs", nullptr, 8, data);
240 PrintRegisterValue(reg_ctx, "gs", nullptr, 8, data);
241
242 // // Write out the FPU registers
243 // const size_t fpu_byte_size = sizeof(FPU);
244 // size_t bytes_written = 0;
245 // data.PutHex32 (FPURegSet);
246 // data.PutHex32 (fpu_byte_size/sizeof(uint64_t));
247 // bytes_written += data.PutHex32(0); // uint32_t pad[0]
248 // bytes_written += data.PutHex32(0); // uint32_t pad[1]
249 // bytes_written += WriteRegister (reg_ctx, "fcw", "fctrl", 2,
250 // data); // uint16_t fcw; // "fctrl"
251 // bytes_written += WriteRegister (reg_ctx, "fsw" , "fstat", 2,
252 // data); // uint16_t fsw; // "fstat"
253 // bytes_written += WriteRegister (reg_ctx, "ftw" , "ftag", 1,
254 // data); // uint8_t ftw; // "ftag"
255 // bytes_written += data.PutHex8 (0); // uint8_t pad1;
256 // bytes_written += WriteRegister (reg_ctx, "fop" , NULL, 2,
257 // data); // uint16_t fop; // "fop"
258 // bytes_written += WriteRegister (reg_ctx, "fioff", "ip", 4,
259 // data); // uint32_t ip; // "fioff"
260 // bytes_written += WriteRegister (reg_ctx, "fiseg", NULL, 2,
261 // data); // uint16_t cs; // "fiseg"
262 // bytes_written += data.PutHex16 (0); // uint16_t pad2;
263 // bytes_written += WriteRegister (reg_ctx, "dp", "fooff" , 4,
264 // data); // uint32_t dp; // "fooff"
265 // bytes_written += WriteRegister (reg_ctx, "foseg", NULL, 2,
266 // data); // uint16_t ds; // "foseg"
267 // bytes_written += data.PutHex16 (0); // uint16_t pad3;
268 // bytes_written += WriteRegister (reg_ctx, "mxcsr", NULL, 4,
269 // data); // uint32_t mxcsr;
270 // bytes_written += WriteRegister (reg_ctx, "mxcsrmask", NULL,
271 // 4, data);// uint32_t mxcsrmask;
272 // bytes_written += WriteRegister (reg_ctx, "stmm0", NULL,
273 // sizeof(MMSReg), data);
274 // bytes_written += WriteRegister (reg_ctx, "stmm1", NULL,
275 // sizeof(MMSReg), data);
276 // bytes_written += WriteRegister (reg_ctx, "stmm2", NULL,
277 // sizeof(MMSReg), data);
278 // bytes_written += WriteRegister (reg_ctx, "stmm3", NULL,
279 // sizeof(MMSReg), data);
280 // bytes_written += WriteRegister (reg_ctx, "stmm4", NULL,
281 // sizeof(MMSReg), data);
282 // bytes_written += WriteRegister (reg_ctx, "stmm5", NULL,
283 // sizeof(MMSReg), data);
284 // bytes_written += WriteRegister (reg_ctx, "stmm6", NULL,
285 // sizeof(MMSReg), data);
286 // bytes_written += WriteRegister (reg_ctx, "stmm7", NULL,
287 // sizeof(MMSReg), data);
288 // bytes_written += WriteRegister (reg_ctx, "xmm0" , NULL,
289 // sizeof(XMMReg), data);
290 // bytes_written += WriteRegister (reg_ctx, "xmm1" , NULL,
291 // sizeof(XMMReg), data);
292 // bytes_written += WriteRegister (reg_ctx, "xmm2" , NULL,
293 // sizeof(XMMReg), data);
294 // bytes_written += WriteRegister (reg_ctx, "xmm3" , NULL,
295 // sizeof(XMMReg), data);
296 // bytes_written += WriteRegister (reg_ctx, "xmm4" , NULL,
297 // sizeof(XMMReg), data);
298 // bytes_written += WriteRegister (reg_ctx, "xmm5" , NULL,
299 // sizeof(XMMReg), data);
300 // bytes_written += WriteRegister (reg_ctx, "xmm6" , NULL,
301 // sizeof(XMMReg), data);
302 // bytes_written += WriteRegister (reg_ctx, "xmm7" , NULL,
303 // sizeof(XMMReg), data);
304 // bytes_written += WriteRegister (reg_ctx, "xmm8" , NULL,
305 // sizeof(XMMReg), data);
306 // bytes_written += WriteRegister (reg_ctx, "xmm9" , NULL,
307 // sizeof(XMMReg), data);
308 // bytes_written += WriteRegister (reg_ctx, "xmm10", NULL,
309 // sizeof(XMMReg), data);
310 // bytes_written += WriteRegister (reg_ctx, "xmm11", NULL,
311 // sizeof(XMMReg), data);
312 // bytes_written += WriteRegister (reg_ctx, "xmm12", NULL,
313 // sizeof(XMMReg), data);
314 // bytes_written += WriteRegister (reg_ctx, "xmm13", NULL,
315 // sizeof(XMMReg), data);
316 // bytes_written += WriteRegister (reg_ctx, "xmm14", NULL,
317 // sizeof(XMMReg), data);
318 // bytes_written += WriteRegister (reg_ctx, "xmm15", NULL,
319 // sizeof(XMMReg), data);
320 //
321 // // Fill rest with zeros
322 // for (size_t i=0, n = fpu_byte_size - bytes_written; i<n; ++
323 // i)
324 // data.PutChar(0);
325
326 // Write out the EXC registers
327 data.PutHex32(EXCRegSet);
329 PrintRegisterValue(reg_ctx, "trapno", nullptr, 4, data);
330 PrintRegisterValue(reg_ctx, "err", nullptr, 4, data);
331 PrintRegisterValue(reg_ctx, "faultvaddr", nullptr, 8, data);
332 return true;
333 }
334 return false;
335 }
336
337protected:
338 int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override { return -1; }
339
340 int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override { return -1; }
341
342 int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override { return -1; }
343
344 int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override {
345 return 0;
346 }
347
348 int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override {
349 return 0;
350 }
351
352 int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override {
353 return 0;
354 }
355};
356
358public:
364
365 void InvalidateAllRegisters() override {
366 // Do nothing... registers are always valid...
367 }
368
370 lldb::offset_t offset = 0;
371 SetError(GPRRegSet, Read, -1);
372 SetError(FPURegSet, Read, -1);
373 SetError(EXCRegSet, Read, -1);
374
375 while (offset < data.GetByteSize()) {
376 int flavor = data.GetU32(&offset);
377 uint32_t count = data.GetU32(&offset);
378 offset_t next_thread_state = offset + (count * 4);
379 switch (flavor) {
380 case GPRAltRegSet:
381 case GPRRegSet: {
382 // r0-r15, plus CPSR
383 uint32_t gpr_buf_count = (sizeof(gpr.r) / sizeof(gpr.r[0])) + 1;
384 if (count == gpr_buf_count) {
385 for (uint32_t i = 0; i < (count - 1); ++i) {
386 gpr.r[i] = data.GetU32(&offset);
387 }
388 gpr.cpsr = data.GetU32(&offset);
389
391 }
392 } break;
393
394 case FPURegSet: {
395 uint8_t *fpu_reg_buf = (uint8_t *)&fpu.floats;
396 const int fpu_reg_buf_size = sizeof(fpu.floats);
397 if (data.ExtractBytes(offset, fpu_reg_buf_size, eByteOrderLittle,
398 fpu_reg_buf) == fpu_reg_buf_size) {
399 offset += fpu_reg_buf_size;
400 fpu.fpscr = data.GetU32(&offset);
402 }
403 } break;
404
405 case EXCRegSet:
406 if (count == 3) {
407 exc.exception = data.GetU32(&offset);
408 exc.fsr = data.GetU32(&offset);
409 exc.far = data.GetU32(&offset);
411 }
412 break;
413 }
414 offset = next_thread_state;
415 }
416 }
417
418 static bool Create_LC_THREAD(Thread *thread, Stream &data) {
419 RegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
420 if (reg_ctx_sp) {
421 RegisterContext *reg_ctx = reg_ctx_sp.get();
422
423 data.PutHex32(GPRRegSet); // Flavor
425 PrintRegisterValue(reg_ctx, "r0", nullptr, 4, data);
426 PrintRegisterValue(reg_ctx, "r1", nullptr, 4, data);
427 PrintRegisterValue(reg_ctx, "r2", nullptr, 4, data);
428 PrintRegisterValue(reg_ctx, "r3", nullptr, 4, data);
429 PrintRegisterValue(reg_ctx, "r4", nullptr, 4, data);
430 PrintRegisterValue(reg_ctx, "r5", nullptr, 4, data);
431 PrintRegisterValue(reg_ctx, "r6", nullptr, 4, data);
432 PrintRegisterValue(reg_ctx, "r7", nullptr, 4, data);
433 PrintRegisterValue(reg_ctx, "r8", nullptr, 4, data);
434 PrintRegisterValue(reg_ctx, "r9", nullptr, 4, data);
435 PrintRegisterValue(reg_ctx, "r10", nullptr, 4, data);
436 PrintRegisterValue(reg_ctx, "r11", nullptr, 4, data);
437 PrintRegisterValue(reg_ctx, "r12", nullptr, 4, data);
438 PrintRegisterValue(reg_ctx, "sp", nullptr, 4, data);
439 PrintRegisterValue(reg_ctx, "lr", nullptr, 4, data);
440 PrintRegisterValue(reg_ctx, "pc", nullptr, 4, data);
441 PrintRegisterValue(reg_ctx, "cpsr", nullptr, 4, data);
442
443 // Write out the EXC registers
444 // data.PutHex32 (EXCRegSet);
445 // data.PutHex32 (EXCWordCount);
446 // WriteRegister (reg_ctx, "exception", NULL, 4, data);
447 // WriteRegister (reg_ctx, "fsr", NULL, 4, data);
448 // WriteRegister (reg_ctx, "far", NULL, 4, data);
449 return true;
450 }
451 return false;
452 }
453
454protected:
455 int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override { return -1; }
456
457 int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override { return -1; }
458
459 int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override { return -1; }
460
461 int DoReadDBG(lldb::tid_t tid, int flavor, DBG &dbg) override { return -1; }
462
463 int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override {
464 return 0;
465 }
466
467 int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override {
468 return 0;
469 }
470
471 int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override {
472 return 0;
473 }
474
475 int DoWriteDBG(lldb::tid_t tid, int flavor, const DBG &dbg) override {
476 return -1;
477 }
478};
479
481public:
487
488 void InvalidateAllRegisters() override {
489 // Do nothing... registers are always valid...
490 }
491
493 lldb::offset_t offset = 0;
494 SetError(GPRRegSet, Read, -1);
495 SetError(FPURegSet, Read, -1);
496 SetError(EXCRegSet, Read, -1);
497 while (offset < data.GetByteSize()) {
498 int flavor = data.GetU32(&offset);
499 uint32_t count = data.GetU32(&offset);
500 offset_t next_thread_state = offset + (count * 4);
501 switch (flavor) {
502 case GPRRegSet:
503 // x0-x29 + fp + lr + sp + pc (== 33 64-bit registers) plus cpsr (1
504 // 32-bit register)
505 if (count >= (33 * 2) + 1) {
506 for (uint32_t i = 0; i < 29; ++i)
507 gpr.x[i] = data.GetU64(&offset);
508 gpr.fp = data.GetU64(&offset);
509 gpr.lr = data.GetU64(&offset);
510 gpr.sp = data.GetU64(&offset);
511 gpr.pc = data.GetU64(&offset);
512 gpr.cpsr = data.GetU32(&offset);
514 }
515 break;
516 case FPURegSet: {
517 uint8_t *fpu_reg_buf = (uint8_t *)&fpu.v[0];
518 const int fpu_reg_buf_size = sizeof(fpu);
519 if (fpu_reg_buf_size == count * sizeof(uint32_t) &&
520 data.ExtractBytes(offset, fpu_reg_buf_size, eByteOrderLittle,
521 fpu_reg_buf) == fpu_reg_buf_size) {
523 }
524 } break;
525 case EXCRegSet:
526 if (count == 4) {
527 exc.far = data.GetU64(&offset);
528 exc.esr = data.GetU32(&offset);
529 exc.exception = data.GetU32(&offset);
531 }
532 break;
533 }
534 offset = next_thread_state;
535 }
536 }
537
538 static bool Create_LC_THREAD(Thread *thread, Stream &data) {
539 RegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
540 if (reg_ctx_sp) {
541 RegisterContext *reg_ctx = reg_ctx_sp.get();
542
543 data.PutHex32(GPRRegSet); // Flavor
545 PrintRegisterValue(reg_ctx, "x0", nullptr, 8, data);
546 PrintRegisterValue(reg_ctx, "x1", nullptr, 8, data);
547 PrintRegisterValue(reg_ctx, "x2", nullptr, 8, data);
548 PrintRegisterValue(reg_ctx, "x3", nullptr, 8, data);
549 PrintRegisterValue(reg_ctx, "x4", nullptr, 8, data);
550 PrintRegisterValue(reg_ctx, "x5", nullptr, 8, data);
551 PrintRegisterValue(reg_ctx, "x6", nullptr, 8, data);
552 PrintRegisterValue(reg_ctx, "x7", nullptr, 8, data);
553 PrintRegisterValue(reg_ctx, "x8", nullptr, 8, data);
554 PrintRegisterValue(reg_ctx, "x9", nullptr, 8, data);
555 PrintRegisterValue(reg_ctx, "x10", nullptr, 8, data);
556 PrintRegisterValue(reg_ctx, "x11", nullptr, 8, data);
557 PrintRegisterValue(reg_ctx, "x12", nullptr, 8, data);
558 PrintRegisterValue(reg_ctx, "x13", nullptr, 8, data);
559 PrintRegisterValue(reg_ctx, "x14", nullptr, 8, data);
560 PrintRegisterValue(reg_ctx, "x15", nullptr, 8, data);
561 PrintRegisterValue(reg_ctx, "x16", nullptr, 8, data);
562 PrintRegisterValue(reg_ctx, "x17", nullptr, 8, data);
563 PrintRegisterValue(reg_ctx, "x18", nullptr, 8, data);
564 PrintRegisterValue(reg_ctx, "x19", nullptr, 8, data);
565 PrintRegisterValue(reg_ctx, "x20", nullptr, 8, data);
566 PrintRegisterValue(reg_ctx, "x21", nullptr, 8, data);
567 PrintRegisterValue(reg_ctx, "x22", nullptr, 8, data);
568 PrintRegisterValue(reg_ctx, "x23", nullptr, 8, data);
569 PrintRegisterValue(reg_ctx, "x24", nullptr, 8, data);
570 PrintRegisterValue(reg_ctx, "x25", nullptr, 8, data);
571 PrintRegisterValue(reg_ctx, "x26", nullptr, 8, data);
572 PrintRegisterValue(reg_ctx, "x27", nullptr, 8, data);
573 PrintRegisterValue(reg_ctx, "x28", nullptr, 8, data);
574 PrintRegisterValue(reg_ctx, "fp", nullptr, 8, data);
575 PrintRegisterValue(reg_ctx, "lr", nullptr, 8, data);
576 PrintRegisterValue(reg_ctx, "sp", nullptr, 8, data);
577 PrintRegisterValue(reg_ctx, "pc", nullptr, 8, data);
578 PrintRegisterValue(reg_ctx, "cpsr", nullptr, 4, data);
579 data.PutHex32(0); // uint32_t pad at the end
580
581 // Write out the EXC registers
582 data.PutHex32(EXCRegSet);
584 PrintRegisterValue(reg_ctx, "far", nullptr, 8, data);
585 PrintRegisterValue(reg_ctx, "esr", nullptr, 4, data);
586 PrintRegisterValue(reg_ctx, "exception", nullptr, 4, data);
587 return true;
588 }
589 return false;
590 }
591
592protected:
593 int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override { return -1; }
594
595 int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override { return -1; }
596
597 int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override { return -1; }
598
599 int DoReadDBG(lldb::tid_t tid, int flavor, DBG &dbg) override { return -1; }
600
601 int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override {
602 return 0;
603 }
604
605 int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override {
606 return 0;
607 }
608
609 int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override {
610 return 0;
611 }
612
613 int DoWriteDBG(lldb::tid_t tid, int flavor, const DBG &dbg) override {
614 return -1;
615 }
616};
617
620public:
626
627 void InvalidateAllRegisters() override {
628 // Do nothing... registers are always valid...
629 }
630
632 lldb::offset_t offset = 0;
633 SetError(GPRRegSet, Read, -1);
634 SetError(FPURegSet, Read, -1);
635 SetError(EXCRegSet, Read, -1);
636 SetError(CSRRegSet, Read, -1);
637 while (offset < data.GetByteSize()) {
638 int flavor = data.GetU32(&offset);
639 uint32_t count = data.GetU32(&offset);
640 offset_t next_thread_state = offset + (count * 4);
641 switch (flavor) {
642 case GPRRegSet:
643 // x0-x31 + pc
644 if (count >= 32) {
645 for (uint32_t i = 0; i < 32; ++i)
646 ((uint32_t *)&gpr.x0)[i] = data.GetU32(&offset);
647 gpr.pc = data.GetU32(&offset);
649 }
650 break;
651 case FPURegSet: {
652 // f0-f31 + fcsr
653 if (count >= 32) {
654 for (uint32_t i = 0; i < 32; ++i)
655 ((uint32_t *)&fpr.f0)[i] = data.GetU32(&offset);
656 fpr.fcsr = data.GetU32(&offset);
658 }
659 } break;
660 case EXCRegSet:
661 if (count == 3) {
662 exc.exception = data.GetU32(&offset);
663 exc.fsr = data.GetU32(&offset);
664 exc.far = data.GetU32(&offset);
666 }
667 break;
668 }
669 offset = next_thread_state;
670 }
671 }
672
673 static bool Create_LC_THREAD(Thread *thread, Stream &data) {
674 RegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
675 if (reg_ctx_sp) {
676 RegisterContext *reg_ctx = reg_ctx_sp.get();
677
678 data.PutHex32(GPRRegSet); // Flavor
680 PrintRegisterValue(reg_ctx, "x0", nullptr, 4, data);
681 PrintRegisterValue(reg_ctx, "x1", nullptr, 4, data);
682 PrintRegisterValue(reg_ctx, "x2", nullptr, 4, data);
683 PrintRegisterValue(reg_ctx, "x3", nullptr, 4, data);
684 PrintRegisterValue(reg_ctx, "x4", nullptr, 4, data);
685 PrintRegisterValue(reg_ctx, "x5", nullptr, 4, data);
686 PrintRegisterValue(reg_ctx, "x6", nullptr, 4, data);
687 PrintRegisterValue(reg_ctx, "x7", nullptr, 4, data);
688 PrintRegisterValue(reg_ctx, "x8", nullptr, 4, data);
689 PrintRegisterValue(reg_ctx, "x9", nullptr, 4, data);
690 PrintRegisterValue(reg_ctx, "x10", nullptr, 4, data);
691 PrintRegisterValue(reg_ctx, "x11", nullptr, 4, data);
692 PrintRegisterValue(reg_ctx, "x12", nullptr, 4, data);
693 PrintRegisterValue(reg_ctx, "x13", nullptr, 4, data);
694 PrintRegisterValue(reg_ctx, "x14", nullptr, 4, data);
695 PrintRegisterValue(reg_ctx, "x15", nullptr, 4, data);
696 PrintRegisterValue(reg_ctx, "x16", nullptr, 4, data);
697 PrintRegisterValue(reg_ctx, "x17", nullptr, 4, data);
698 PrintRegisterValue(reg_ctx, "x18", nullptr, 4, data);
699 PrintRegisterValue(reg_ctx, "x19", nullptr, 4, data);
700 PrintRegisterValue(reg_ctx, "x20", nullptr, 4, data);
701 PrintRegisterValue(reg_ctx, "x21", nullptr, 4, data);
702 PrintRegisterValue(reg_ctx, "x22", nullptr, 4, data);
703 PrintRegisterValue(reg_ctx, "x23", nullptr, 4, data);
704 PrintRegisterValue(reg_ctx, "x24", nullptr, 4, data);
705 PrintRegisterValue(reg_ctx, "x25", nullptr, 4, data);
706 PrintRegisterValue(reg_ctx, "x26", nullptr, 4, data);
707 PrintRegisterValue(reg_ctx, "x27", nullptr, 4, data);
708 PrintRegisterValue(reg_ctx, "x28", nullptr, 4, data);
709 PrintRegisterValue(reg_ctx, "x29", nullptr, 4, data);
710 PrintRegisterValue(reg_ctx, "x30", nullptr, 4, data);
711 PrintRegisterValue(reg_ctx, "x31", nullptr, 4, data);
712 PrintRegisterValue(reg_ctx, "pc", nullptr, 4, data);
713 data.PutHex32(0); // uint32_t pad at the end
714
715 // Write out the EXC registers
716 data.PutHex32(EXCRegSet);
718 PrintRegisterValue(reg_ctx, "exception", nullptr, 4, data);
719 PrintRegisterValue(reg_ctx, "fsr", nullptr, 4, data);
720 PrintRegisterValue(reg_ctx, "far", nullptr, 4, data);
721 return true;
722 }
723 return false;
724 }
725
726protected:
727 int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override { return -1; }
728
729 int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override { return -1; }
730
731 int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override { return -1; }
732
733 int DoReadCSR(lldb::tid_t tid, int flavor, CSR &csr) override { return -1; }
734
735 int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override {
736 return 0;
737 }
738
739 int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override {
740 return 0;
741 }
742
743 int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override {
744 return 0;
745 }
746
747 int DoWriteCSR(lldb::tid_t tid, int flavor, const CSR &csr) override {
748 return 0;
749 }
750};
751
752static uint32_t MachHeaderSizeFromMagic(uint32_t magic) {
753 switch (magic) {
754 case MH_MAGIC:
755 case MH_CIGAM:
756 return sizeof(struct llvm::MachO::mach_header);
757
758 case MH_MAGIC_64:
759 case MH_CIGAM_64:
760 return sizeof(struct llvm::MachO::mach_header_64);
761 break;
762
763 default:
764 break;
765 }
766 return 0;
767}
768
769#define MACHO_NLIST_ARM_SYMBOL_IS_THUMB 0x0008
770
772
778
782
784 DataBufferSP data_sp,
785 lldb::offset_t data_offset,
786 const FileSpec *file,
787 lldb::offset_t file_offset,
788 lldb::offset_t length) {
789 if (!data_sp) {
790 data_sp = MapFileData(*file, length, file_offset);
791 if (!data_sp)
792 return nullptr;
793 data_offset = 0;
794 }
795
796 if (!ObjectFileMachO::MagicBytesMatch(data_sp, data_offset, length))
797 return nullptr;
798
799 // Update the data to contain the entire file if it doesn't already
800 if (data_sp->GetByteSize() < length) {
801 data_sp = MapFileData(*file, length, file_offset);
802 if (!data_sp)
803 return nullptr;
804 data_offset = 0;
805 }
806 auto objfile_up = std::make_unique<ObjectFileMachO>(
807 module_sp, data_sp, data_offset, file, file_offset, length);
808 if (!objfile_up || !objfile_up->ParseHeader())
809 return nullptr;
810
811 return objfile_up.release();
812}
813
815 const lldb::ModuleSP &module_sp, WritableDataBufferSP data_sp,
816 const ProcessSP &process_sp, lldb::addr_t header_addr) {
817 if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
818 std::unique_ptr<ObjectFile> objfile_up(
819 new ObjectFileMachO(module_sp, data_sp, process_sp, header_addr));
820 if (objfile_up.get() && objfile_up->ParseHeader())
821 return objfile_up.release();
822 }
823 return nullptr;
824}
825
827 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
828 lldb::offset_t data_offset, lldb::offset_t file_offset,
830 const size_t initial_count = specs.GetSize();
831
832 if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
833 DataExtractor data;
834 data.SetData(data_sp);
835 llvm::MachO::mach_header header;
836 if (ParseHeader(data, &data_offset, header)) {
837 size_t header_and_load_cmds =
838 header.sizeofcmds + MachHeaderSizeFromMagic(header.magic);
839 if (header_and_load_cmds >= data_sp->GetByteSize()) {
840 data_sp = MapFileData(file, header_and_load_cmds, file_offset);
841 data.SetData(data_sp);
842 data_offset = MachHeaderSizeFromMagic(header.magic);
843 }
844 if (data_sp) {
845 ModuleSpec base_spec;
846 base_spec.GetFileSpec() = file;
847 base_spec.SetObjectOffset(file_offset);
848 base_spec.SetObjectSize(length);
849 GetAllArchSpecs(header, data, data_offset, base_spec, specs);
850 }
851 }
852 }
853 return specs.GetSize() - initial_count;
854}
855
857 static ConstString g_segment_name_TEXT("__TEXT");
858 return g_segment_name_TEXT;
859}
860
862 static ConstString g_segment_name_DATA("__DATA");
863 return g_segment_name_DATA;
864}
865
867 static ConstString g_segment_name("__DATA_DIRTY");
868 return g_segment_name;
869}
870
872 static ConstString g_segment_name("__DATA_CONST");
873 return g_segment_name;
874}
875
877 static ConstString g_segment_name_OBJC("__OBJC");
878 return g_segment_name_OBJC;
879}
880
882 static ConstString g_section_name_LINKEDIT("__LINKEDIT");
883 return g_section_name_LINKEDIT;
884}
885
887 static ConstString g_section_name("__DWARF");
888 return g_section_name;
889}
890
892 static ConstString g_section_name("__LLVM_COV");
893 return g_section_name;
894}
895
897 static ConstString g_section_name_eh_frame("__eh_frame");
898 return g_section_name_eh_frame;
899}
900
902 static ConstString g_section_name_lldb_no_nlist("__lldb_no_nlist");
903 return g_section_name_lldb_no_nlist;
904}
905
907 lldb::addr_t data_offset,
908 lldb::addr_t data_length) {
909 DataExtractor data;
910 data.SetData(data_sp, data_offset, data_length);
911 lldb::offset_t offset = 0;
912 uint32_t magic = data.GetU32(&offset);
913
914 offset += 4; // cputype
915 offset += 4; // cpusubtype
916 uint32_t filetype = data.GetU32(&offset);
917
918 // A fileset has a Mach-O header but is not an
919 // individual file and must be handled via an
920 // ObjectContainer plugin.
921 if (filetype == llvm::MachO::MH_FILESET)
922 return false;
923
924 return MachHeaderSizeFromMagic(magic) != 0;
925}
926
928 DataBufferSP data_sp,
929 lldb::offset_t data_offset,
930 const FileSpec *file,
931 lldb::offset_t file_offset,
932 lldb::offset_t length)
933 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
937 ::memset(&m_header, 0, sizeof(m_header));
938 ::memset(&m_dysymtab, 0, sizeof(m_dysymtab));
939}
940
942 lldb::WritableDataBufferSP header_data_sp,
943 const lldb::ProcessSP &process_sp,
944 lldb::addr_t header_addr)
945 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
949 ::memset(&m_header, 0, sizeof(m_header));
950 ::memset(&m_dysymtab, 0, sizeof(m_dysymtab));
951}
952
954 lldb::offset_t *data_offset_ptr,
955 llvm::MachO::mach_header &header) {
957 // Leave magic in the original byte order
958 header.magic = data.GetU32(data_offset_ptr);
959 bool can_parse = false;
960 bool is_64_bit = false;
961 switch (header.magic) {
962 case MH_MAGIC:
964 data.SetAddressByteSize(4);
965 can_parse = true;
966 break;
967
968 case MH_MAGIC_64:
970 data.SetAddressByteSize(8);
971 can_parse = true;
972 is_64_bit = true;
973 break;
974
975 case MH_CIGAM:
978 : eByteOrderBig);
979 data.SetAddressByteSize(4);
980 can_parse = true;
981 break;
982
983 case MH_CIGAM_64:
986 : eByteOrderBig);
987 data.SetAddressByteSize(8);
988 is_64_bit = true;
989 can_parse = true;
990 break;
991
992 default:
993 break;
994 }
995
996 if (can_parse) {
997 data.GetU32(data_offset_ptr, &header.cputype, 6);
998 if (is_64_bit)
999 *data_offset_ptr += 4;
1000 return true;
1001 } else {
1002 memset(&header, 0, sizeof(header));
1003 }
1004 return false;
1005}
1006
1008 ModuleSP module_sp(GetModule());
1009 if (!module_sp)
1010 return false;
1011
1012 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
1013 bool can_parse = false;
1014 lldb::offset_t offset = 0;
1015 m_data.SetByteOrder(endian::InlHostByteOrder());
1016 // Leave magic in the original byte order
1017 m_header.magic = m_data.GetU32(&offset);
1018 switch (m_header.magic) {
1019 case MH_MAGIC:
1020 m_data.SetByteOrder(endian::InlHostByteOrder());
1021 m_data.SetAddressByteSize(4);
1022 can_parse = true;
1023 break;
1024
1025 case MH_MAGIC_64:
1026 m_data.SetByteOrder(endian::InlHostByteOrder());
1027 m_data.SetAddressByteSize(8);
1028 can_parse = true;
1029 break;
1030
1031 case MH_CIGAM:
1034 : eByteOrderBig);
1035 m_data.SetAddressByteSize(4);
1036 can_parse = true;
1037 break;
1038
1039 case MH_CIGAM_64:
1042 : eByteOrderBig);
1043 m_data.SetAddressByteSize(8);
1044 can_parse = true;
1045 break;
1046
1047 default:
1048 break;
1049 }
1050
1051 if (can_parse) {
1052 m_data.GetU32(&offset, &m_header.cputype, 6);
1053
1054 ModuleSpecList all_specs;
1055 ModuleSpec base_spec;
1057 base_spec, all_specs);
1058
1059 for (unsigned i = 0, e = all_specs.GetSize(); i != e; ++i) {
1060 ArchSpec mach_arch =
1062
1063 // Check if the module has a required architecture
1064 const ArchSpec &module_arch = module_sp->GetArchitecture();
1065 if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
1066 continue;
1067
1068 if (SetModulesArchitecture(mach_arch)) {
1069 const size_t header_and_lc_size =
1070 m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
1071 if (m_data.GetByteSize() < header_and_lc_size) {
1072 DataBufferSP data_sp;
1073 ProcessSP process_sp(m_process_wp.lock());
1074 if (process_sp) {
1075 data_sp = ReadMemory(process_sp, m_memory_addr, header_and_lc_size);
1076 } else {
1077 // Read in all only the load command data from the file on disk
1078 data_sp = MapFileData(m_file, header_and_lc_size, m_file_offset);
1079 if (data_sp->GetByteSize() != header_and_lc_size)
1080 continue;
1081 }
1082 if (data_sp)
1083 m_data.SetData(data_sp);
1084 }
1085 }
1086 return true;
1087 }
1088 // None found.
1089 return false;
1090 } else {
1091 memset(&m_header, 0, sizeof(struct llvm::MachO::mach_header));
1092 }
1093 return false;
1094}
1095
1097 return m_data.GetByteOrder();
1098}
1099
1101 return m_header.filetype == MH_EXECUTE;
1102}
1103
1105 return m_header.filetype == MH_DYLINKER;
1106}
1107
1109 return m_header.flags & MH_DYLIB_IN_CACHE;
1110}
1111
1113 return m_header.filetype == MH_KEXT_BUNDLE;
1114}
1115
1117 return m_data.GetAddressByteSize();
1118}
1119
1121 Symtab *symtab = GetSymtab();
1122 if (!symtab)
1124
1125 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
1126 if (symbol) {
1127 if (symbol->ValueIsAddress()) {
1128 SectionSP section_sp(symbol->GetAddressRef().GetSection());
1129 if (section_sp) {
1130 const lldb::SectionType section_type = section_sp->GetType();
1131 switch (section_type) {
1134
1135 case eSectionTypeCode:
1136 if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
1137 // For ARM we have a bit in the n_desc field of the symbol that
1138 // tells us ARM/Thumb which is bit 0x0008.
1141 }
1142 return AddressClass::eCode;
1143
1146
1147 case eSectionTypeData:
1151 case eSectionTypeData4:
1152 case eSectionTypeData8:
1153 case eSectionTypeData16:
1160 return AddressClass::eData;
1161
1162 case eSectionTypeDebug:
1197 case eSectionTypeCTF:
1201 return AddressClass::eDebug;
1202
1208
1214 case eSectionTypeOther:
1216 }
1217 }
1218 }
1219
1220 const SymbolType symbol_type = symbol->GetType();
1221 switch (symbol_type) {
1222 case eSymbolTypeAny:
1226
1227 case eSymbolTypeCode:
1230 if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
1231 // For ARM we have a bit in the n_desc field of the symbol that tells
1232 // us ARM/Thumb which is bit 0x0008.
1235 }
1236 return AddressClass::eCode;
1237
1238 case eSymbolTypeData:
1239 return AddressClass::eData;
1240 case eSymbolTypeRuntime:
1245 return AddressClass::eDebug;
1247 return AddressClass::eDebug;
1249 return AddressClass::eDebug;
1251 return AddressClass::eDebug;
1252 case eSymbolTypeBlock:
1253 return AddressClass::eDebug;
1254 case eSymbolTypeLocal:
1255 return AddressClass::eData;
1256 case eSymbolTypeParam:
1257 return AddressClass::eData;
1259 return AddressClass::eData;
1261 return AddressClass::eDebug;
1263 return AddressClass::eDebug;
1265 return AddressClass::eDebug;
1267 return AddressClass::eDebug;
1269 return AddressClass::eDebug;
1273 return AddressClass::eDebug;
1275 return AddressClass::eDebug;
1286 }
1287 }
1289}
1290
1292 if (m_dysymtab.cmd == 0) {
1293 ModuleSP module_sp(GetModule());
1294 if (module_sp) {
1296 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
1297 const lldb::offset_t load_cmd_offset = offset;
1298
1299 llvm::MachO::load_command lc = {};
1300 if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
1301 break;
1302 if (lc.cmd == LC_DYSYMTAB) {
1303 m_dysymtab.cmd = lc.cmd;
1304 m_dysymtab.cmdsize = lc.cmdsize;
1305 if (m_data.GetU32(&offset, &m_dysymtab.ilocalsym,
1306 (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2) ==
1307 nullptr) {
1308 // Clear m_dysymtab if we were unable to read all items from the
1309 // load command
1310 ::memset(&m_dysymtab, 0, sizeof(m_dysymtab));
1311 }
1312 }
1313 offset = load_cmd_offset + lc.cmdsize;
1314 }
1315 }
1316 }
1317 if (m_dysymtab.cmd)
1318 return m_dysymtab.nlocalsym <= 1;
1319 return false;
1320}
1321
1323 EncryptedFileRanges result;
1325
1326 llvm::MachO::encryption_info_command encryption_cmd;
1327 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
1328 const lldb::offset_t load_cmd_offset = offset;
1329 if (m_data.GetU32(&offset, &encryption_cmd, 2) == nullptr)
1330 break;
1331
1332 // LC_ENCRYPTION_INFO and LC_ENCRYPTION_INFO_64 have the same sizes for the
1333 // 3 fields we care about, so treat them the same.
1334 if (encryption_cmd.cmd == LC_ENCRYPTION_INFO ||
1335 encryption_cmd.cmd == LC_ENCRYPTION_INFO_64) {
1336 if (m_data.GetU32(&offset, &encryption_cmd.cryptoff, 3)) {
1337 if (encryption_cmd.cryptid != 0) {
1339 entry.SetRangeBase(encryption_cmd.cryptoff);
1340 entry.SetByteSize(encryption_cmd.cryptsize);
1341 result.Append(entry);
1342 }
1343 }
1344 }
1345 offset = load_cmd_offset + encryption_cmd.cmdsize;
1346 }
1347
1348 return result;
1349}
1350
1352 llvm::MachO::segment_command_64 &seg_cmd, uint32_t cmd_idx) {
1353 if (m_length == 0 || seg_cmd.filesize == 0)
1354 return;
1355
1356 if (IsSharedCacheBinary() && !IsInMemory()) {
1357 // In shared cache images, the load commands are relative to the
1358 // shared cache file, and not the specific image we are
1359 // examining. Let's fix this up so that it looks like a normal
1360 // image.
1361 if (strncmp(seg_cmd.segname, GetSegmentNameTEXT().GetCString(),
1362 sizeof(seg_cmd.segname)) == 0)
1363 m_text_address = seg_cmd.vmaddr;
1364 if (strncmp(seg_cmd.segname, GetSegmentNameLINKEDIT().GetCString(),
1365 sizeof(seg_cmd.segname)) == 0)
1366 m_linkedit_original_offset = seg_cmd.fileoff;
1367
1368 seg_cmd.fileoff = seg_cmd.vmaddr - m_text_address;
1369 }
1370
1371 if (seg_cmd.fileoff > m_length) {
1372 // We have a load command that says it extends past the end of the file.
1373 // This is likely a corrupt file. We don't have any way to return an error
1374 // condition here (this method was likely invoked from something like
1375 // ObjectFile::GetSectionList()), so we just null out the section contents,
1376 // and dump a message to stdout. The most common case here is core file
1377 // debugging with a truncated file.
1378 const char *lc_segment_name =
1379 seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
1380 GetModule()->ReportWarning(
1381 "load command {0} {1} has a fileoff ({2:x16}) that extends beyond "
1382 "the end of the file ({3:x16}), ignoring this section",
1383 cmd_idx, lc_segment_name, seg_cmd.fileoff, m_length);
1384
1385 seg_cmd.fileoff = 0;
1386 seg_cmd.filesize = 0;
1387 }
1388
1389 if (seg_cmd.fileoff + seg_cmd.filesize > m_length) {
1390 // We have a load command that says it extends past the end of the file.
1391 // This is likely a corrupt file. We don't have any way to return an error
1392 // condition here (this method was likely invoked from something like
1393 // ObjectFile::GetSectionList()), so we just null out the section contents,
1394 // and dump a message to stdout. The most common case here is core file
1395 // debugging with a truncated file.
1396 const char *lc_segment_name =
1397 seg_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
1398 GetModule()->ReportWarning(
1399 "load command {0} {1} has a fileoff + filesize ({2:x16}) that "
1400 "extends beyond the end of the file ({3:x16}), the segment will be "
1401 "truncated to match",
1402 cmd_idx, lc_segment_name, seg_cmd.fileoff + seg_cmd.filesize, m_length);
1403
1404 // Truncate the length
1405 seg_cmd.filesize = m_length - seg_cmd.fileoff;
1406 }
1407}
1408
1409static uint32_t
1410GetSegmentPermissions(const llvm::MachO::segment_command_64 &seg_cmd) {
1411 uint32_t result = 0;
1412 if (seg_cmd.initprot & VM_PROT_READ)
1413 result |= ePermissionsReadable;
1414 if (seg_cmd.initprot & VM_PROT_WRITE)
1415 result |= ePermissionsWritable;
1416 if (seg_cmd.initprot & VM_PROT_EXECUTE)
1417 result |= ePermissionsExecutable;
1418 return result;
1419}
1420
1421static lldb::SectionType GetSectionType(uint32_t flags,
1422 ConstString section_name) {
1423
1424 if (flags & (S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS))
1425 return eSectionTypeCode;
1426
1427 uint32_t mach_sect_type = flags & SECTION_TYPE;
1428 static ConstString g_sect_name_objc_data("__objc_data");
1429 static ConstString g_sect_name_objc_msgrefs("__objc_msgrefs");
1430 static ConstString g_sect_name_objc_selrefs("__objc_selrefs");
1431 static ConstString g_sect_name_objc_classrefs("__objc_classrefs");
1432 static ConstString g_sect_name_objc_superrefs("__objc_superrefs");
1433 static ConstString g_sect_name_objc_const("__objc_const");
1434 static ConstString g_sect_name_objc_classlist("__objc_classlist");
1435 static ConstString g_sect_name_cfstring("__cfstring");
1436
1437 static ConstString g_sect_name_dwarf_debug_str_offs("__debug_str_offs");
1438 static ConstString g_sect_name_dwarf_debug_str_offs_dwo("__debug_str_offs.dwo");
1439 static ConstString g_sect_name_dwarf_apple_names("__apple_names");
1440 static ConstString g_sect_name_dwarf_apple_types("__apple_types");
1441 static ConstString g_sect_name_dwarf_apple_namespaces("__apple_namespac");
1442 static ConstString g_sect_name_dwarf_apple_objc("__apple_objc");
1443 static ConstString g_sect_name_eh_frame("__eh_frame");
1444 static ConstString g_sect_name_compact_unwind("__unwind_info");
1445 static ConstString g_sect_name_text("__text");
1446 static ConstString g_sect_name_data("__data");
1447 static ConstString g_sect_name_go_symtab("__gosymtab");
1448 static ConstString g_sect_name_ctf("__ctf");
1449 static ConstString g_sect_name_lldb_summaries("__lldbsummaries");
1450 static ConstString g_sect_name_lldb_formatters("__lldbformatters");
1451 static ConstString g_sect_name_swift_ast("__swift_ast");
1452
1453 if (section_name == g_sect_name_dwarf_debug_str_offs)
1455 if (section_name == g_sect_name_dwarf_debug_str_offs_dwo)
1457
1458 llvm::StringRef stripped_name = section_name.GetStringRef();
1459 if (stripped_name.consume_front("__debug_"))
1460 return ObjectFile::GetDWARFSectionTypeFromName(stripped_name);
1461
1462 if (section_name == g_sect_name_dwarf_apple_names)
1464 if (section_name == g_sect_name_dwarf_apple_types)
1466 if (section_name == g_sect_name_dwarf_apple_namespaces)
1468 if (section_name == g_sect_name_dwarf_apple_objc)
1470 if (section_name == g_sect_name_objc_selrefs)
1472 if (section_name == g_sect_name_objc_msgrefs)
1474 if (section_name == g_sect_name_eh_frame)
1475 return eSectionTypeEHFrame;
1476 if (section_name == g_sect_name_compact_unwind)
1478 if (section_name == g_sect_name_cfstring)
1480 if (section_name == g_sect_name_go_symtab)
1481 return eSectionTypeGoSymtab;
1482 if (section_name == g_sect_name_ctf)
1483 return eSectionTypeCTF;
1484 if (section_name == g_sect_name_lldb_summaries)
1486 if (section_name == g_sect_name_lldb_formatters)
1488 if (section_name == g_sect_name_swift_ast)
1490 if (section_name == g_sect_name_objc_data ||
1491 section_name == g_sect_name_objc_classrefs ||
1492 section_name == g_sect_name_objc_superrefs ||
1493 section_name == g_sect_name_objc_const ||
1494 section_name == g_sect_name_objc_classlist) {
1496 }
1497
1498 switch (mach_sect_type) {
1499 // TODO: categorize sections by other flags for regular sections
1500 case S_REGULAR:
1501 if (section_name == g_sect_name_text)
1502 return eSectionTypeCode;
1503 if (section_name == g_sect_name_data)
1504 return eSectionTypeData;
1505 return eSectionTypeOther;
1506 case S_ZEROFILL:
1507 return eSectionTypeZeroFill;
1508 case S_CSTRING_LITERALS: // section with only literal C strings
1510 case S_4BYTE_LITERALS: // section with only 4 byte literals
1511 return eSectionTypeData4;
1512 case S_8BYTE_LITERALS: // section with only 8 byte literals
1513 return eSectionTypeData8;
1514 case S_LITERAL_POINTERS: // section with only pointers to literals
1516 case S_NON_LAZY_SYMBOL_POINTERS: // section with only non-lazy symbol pointers
1518 case S_LAZY_SYMBOL_POINTERS: // section with only lazy symbol pointers
1520 case S_SYMBOL_STUBS: // section with only symbol stubs, byte size of stub in
1521 // the reserved2 field
1522 return eSectionTypeCode;
1523 case S_MOD_INIT_FUNC_POINTERS: // section with only function pointers for
1524 // initialization
1526 case S_MOD_TERM_FUNC_POINTERS: // section with only function pointers for
1527 // termination
1529 case S_COALESCED:
1530 return eSectionTypeOther;
1531 case S_GB_ZEROFILL:
1532 return eSectionTypeZeroFill;
1533 case S_INTERPOSING: // section with only pairs of function pointers for
1534 // interposing
1535 return eSectionTypeCode;
1536 case S_16BYTE_LITERALS: // section with only 16 byte literals
1537 return eSectionTypeData16;
1538 case S_DTRACE_DOF:
1539 return eSectionTypeDebug;
1540 case S_LAZY_DYLIB_SYMBOL_POINTERS:
1542 default:
1543 return eSectionTypeOther;
1544 }
1545}
1546
1558
1560 const llvm::MachO::load_command &load_cmd_, lldb::offset_t offset,
1561 uint32_t cmd_idx, SegmentParsingContext &context) {
1562 llvm::MachO::segment_command_64 load_cmd;
1563 memcpy(&load_cmd, &load_cmd_, sizeof(load_cmd_));
1564
1565 if (!m_data.GetU8(&offset, (uint8_t *)load_cmd.segname, 16))
1566 return;
1567
1568 ModuleSP module_sp = GetModule();
1569 const bool is_core = GetType() == eTypeCoreFile;
1570 const bool is_dsym = (m_header.filetype == MH_DSYM);
1571 bool add_section = true;
1572 bool add_to_unified = true;
1573 ConstString const_segname(
1574 load_cmd.segname, strnlen(load_cmd.segname, sizeof(load_cmd.segname)));
1575
1576 SectionSP unified_section_sp(
1577 context.UnifiedList.FindSectionByName(const_segname));
1578 if (is_dsym && unified_section_sp) {
1579 if (const_segname == GetSegmentNameLINKEDIT()) {
1580 // We need to keep the __LINKEDIT segment private to this object file
1581 // only
1582 add_to_unified = false;
1583 } else {
1584 // This is the dSYM file and this section has already been created by the
1585 // object file, no need to create it.
1586 add_section = false;
1587 }
1588 }
1589 load_cmd.vmaddr = m_data.GetAddress(&offset);
1590 load_cmd.vmsize = m_data.GetAddress(&offset);
1591 load_cmd.fileoff = m_data.GetAddress(&offset);
1592 load_cmd.filesize = m_data.GetAddress(&offset);
1593 if (!m_data.GetU32(&offset, &load_cmd.maxprot, 4))
1594 return;
1595
1596 SanitizeSegmentCommand(load_cmd, cmd_idx);
1597
1598 const uint32_t segment_permissions = GetSegmentPermissions(load_cmd);
1599 const bool segment_is_encrypted =
1600 (load_cmd.flags & SG_PROTECTED_VERSION_1) != 0;
1601
1602 // Use a segment ID of the segment index shifted left by 8 so they never
1603 // conflict with any of the sections.
1604 SectionSP segment_sp;
1605 if (add_section && (const_segname || is_core)) {
1606 segment_sp = std::make_shared<Section>(
1607 module_sp, // Module to which this section belongs
1608 this, // Object file to which this sections belongs
1609 ++context.NextSegmentIdx
1610 << 8, // Section ID is the 1 based segment index
1611 // shifted right by 8 bits as not to collide with any of the 256
1612 // section IDs that are possible
1613 const_segname, // Name of this section
1614 eSectionTypeContainer, // This section is a container of other
1615 // sections.
1616 load_cmd.vmaddr, // File VM address == addresses as they are
1617 // found in the object file
1618 load_cmd.vmsize, // VM size in bytes of this section
1619 load_cmd.fileoff, // Offset to the data for this section in
1620 // the file
1621 load_cmd.filesize, // Size in bytes of this section as found
1622 // in the file
1623 0, // Segments have no alignment information
1624 load_cmd.flags); // Flags for this section
1625
1626 segment_sp->SetIsEncrypted(segment_is_encrypted);
1627 m_sections_up->AddSection(segment_sp);
1628 segment_sp->SetPermissions(segment_permissions);
1629 if (add_to_unified)
1630 context.UnifiedList.AddSection(segment_sp);
1631 } else if (unified_section_sp) {
1632 // If this is a dSYM and the file addresses in the dSYM differ from the
1633 // file addresses in the ObjectFile, we must use the file base address for
1634 // the Section from the dSYM for the DWARF to resolve correctly.
1635 // This only happens with binaries in the shared cache in practice;
1636 // normally a mismatch like this would give a binary & dSYM that do not
1637 // match UUIDs. When a binary is included in the shared cache, its
1638 // segments are rearranged to optimize the shared cache, so its file
1639 // addresses will differ from what the ObjectFile had originally,
1640 // and what the dSYM has.
1641 if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr) {
1642 Log *log = GetLog(LLDBLog::Symbols);
1643 if (log) {
1644 log->Printf(
1645 "Installing dSYM's %s segment file address over ObjectFile's "
1646 "so symbol table/debug info resolves correctly for %s",
1647 const_segname.AsCString(),
1648 module_sp->GetFileSpec().GetFilename().AsCString());
1649 }
1650
1651 // Make sure we've parsed the symbol table from the ObjectFile before
1652 // we go around changing its Sections.
1653 module_sp->GetObjectFile()->GetSymtab();
1654 // eh_frame would present the same problems but we parse that on a per-
1655 // function basis as-needed so it's more difficult to remove its use of
1656 // the Sections. Realistically, the environments where this code path
1657 // will be taken will not have eh_frame sections.
1658
1659 unified_section_sp->SetFileAddress(load_cmd.vmaddr);
1660
1661 // Notify the module that the section addresses have been changed once
1662 // we're done so any file-address caches can be updated.
1663 context.FileAddressesChanged = true;
1664 }
1665 m_sections_up->AddSection(unified_section_sp);
1666 }
1667
1668 llvm::MachO::section_64 sect64;
1669 ::memset(&sect64, 0, sizeof(sect64));
1670 // Push a section into our mach sections for the section at index zero
1671 // (NO_SECT) if we don't have any mach sections yet...
1672 if (m_mach_sections.empty())
1673 m_mach_sections.push_back(sect64);
1674 uint32_t segment_sect_idx;
1675 const lldb::user_id_t first_segment_sectID = context.NextSectionIdx + 1;
1676
1677 const uint32_t num_u32s = load_cmd.cmd == LC_SEGMENT ? 7 : 8;
1678 for (segment_sect_idx = 0; segment_sect_idx < load_cmd.nsects;
1679 ++segment_sect_idx) {
1680 if (m_data.GetU8(&offset, (uint8_t *)sect64.sectname,
1681 sizeof(sect64.sectname)) == nullptr)
1682 break;
1683 if (m_data.GetU8(&offset, (uint8_t *)sect64.segname,
1684 sizeof(sect64.segname)) == nullptr)
1685 break;
1686 sect64.addr = m_data.GetAddress(&offset);
1687 sect64.size = m_data.GetAddress(&offset);
1688
1689 if (m_data.GetU32(&offset, &sect64.offset, num_u32s) == nullptr)
1690 break;
1691
1692 if (IsSharedCacheBinary() && !IsInMemory()) {
1693 sect64.offset = sect64.addr - m_text_address;
1694 }
1695
1696 // Keep a list of mach sections around in case we need to get at data that
1697 // isn't stored in the abstracted Sections.
1698 m_mach_sections.push_back(sect64);
1699
1700 if (add_section) {
1701 ConstString section_name(
1702 sect64.sectname, strnlen(sect64.sectname, sizeof(sect64.sectname)));
1703 if (!const_segname) {
1704 // We have a segment with no name so we need to conjure up segments
1705 // that correspond to the section's segname if there isn't already such
1706 // a section. If there is such a section, we resize the section so that
1707 // it spans all sections. We also mark these sections as fake so
1708 // address matches don't hit if they land in the gaps between the child
1709 // sections.
1710 const_segname.SetTrimmedCStringWithLength(sect64.segname,
1711 sizeof(sect64.segname));
1712 segment_sp = context.UnifiedList.FindSectionByName(const_segname);
1713 if (segment_sp.get()) {
1714 Section *segment = segment_sp.get();
1715 // Grow the section size as needed.
1716 const lldb::addr_t sect64_min_addr = sect64.addr;
1717 const lldb::addr_t sect64_max_addr = sect64_min_addr + sect64.size;
1718 const lldb::addr_t curr_seg_byte_size = segment->GetByteSize();
1719 const lldb::addr_t curr_seg_min_addr = segment->GetFileAddress();
1720 const lldb::addr_t curr_seg_max_addr =
1721 curr_seg_min_addr + curr_seg_byte_size;
1722 if (sect64_min_addr >= curr_seg_min_addr) {
1723 const lldb::addr_t new_seg_byte_size =
1724 sect64_max_addr - curr_seg_min_addr;
1725 // Only grow the section size if needed
1726 if (new_seg_byte_size > curr_seg_byte_size)
1727 segment->SetByteSize(new_seg_byte_size);
1728 } else {
1729 // We need to change the base address of the segment and adjust the
1730 // child section offsets for all existing children.
1731 const lldb::addr_t slide_amount =
1732 sect64_min_addr - curr_seg_min_addr;
1733 segment->Slide(slide_amount, false);
1734 segment->GetChildren().Slide(-slide_amount, false);
1735 segment->SetByteSize(curr_seg_max_addr - sect64_min_addr);
1736 }
1737
1738 // Grow the section size as needed.
1739 if (sect64.offset) {
1740 const lldb::addr_t segment_min_file_offset =
1741 segment->GetFileOffset();
1742 const lldb::addr_t segment_max_file_offset =
1743 segment_min_file_offset + segment->GetFileSize();
1744
1745 const lldb::addr_t section_min_file_offset = sect64.offset;
1746 const lldb::addr_t section_max_file_offset =
1747 section_min_file_offset + sect64.size;
1748 const lldb::addr_t new_file_offset =
1749 std::min(section_min_file_offset, segment_min_file_offset);
1750 const lldb::addr_t new_file_size =
1751 std::max(section_max_file_offset, segment_max_file_offset) -
1752 new_file_offset;
1753 segment->SetFileOffset(new_file_offset);
1754 segment->SetFileSize(new_file_size);
1755 }
1756 } else {
1757 // Create a fake section for the section's named segment
1758 segment_sp = std::make_shared<Section>(
1759 segment_sp, // Parent section
1760 module_sp, // Module to which this section belongs
1761 this, // Object file to which this section belongs
1762 ++context.NextSegmentIdx
1763 << 8, // Section ID is the 1 based segment index
1764 // shifted right by 8 bits as not to
1765 // collide with any of the 256 section IDs
1766 // that are possible
1767 const_segname, // Name of this section
1768 eSectionTypeContainer, // This section is a container of
1769 // other sections.
1770 sect64.addr, // File VM address == addresses as they are
1771 // found in the object file
1772 sect64.size, // VM size in bytes of this section
1773 sect64.offset, // Offset to the data for this section in
1774 // the file
1775 sect64.offset ? sect64.size : 0, // Size in bytes of
1776 // this section as
1777 // found in the file
1778 sect64.align,
1779 load_cmd.flags); // Flags for this section
1780 segment_sp->SetIsFake(true);
1781 segment_sp->SetPermissions(segment_permissions);
1782 m_sections_up->AddSection(segment_sp);
1783 if (add_to_unified)
1784 context.UnifiedList.AddSection(segment_sp);
1785 segment_sp->SetIsEncrypted(segment_is_encrypted);
1786 }
1787 }
1788 assert(segment_sp.get());
1789
1790 lldb::SectionType sect_type = GetSectionType(sect64.flags, section_name);
1791
1792 SectionSP section_sp(new Section(
1793 segment_sp, module_sp, this, ++context.NextSectionIdx, section_name,
1794 sect_type, sect64.addr - segment_sp->GetFileAddress(), sect64.size,
1795 sect64.offset, sect64.offset == 0 ? 0 : sect64.size, sect64.align,
1796 sect64.flags));
1797 // Set the section to be encrypted to match the segment
1798
1799 bool section_is_encrypted = false;
1800 if (!segment_is_encrypted && load_cmd.filesize != 0)
1801 section_is_encrypted = context.EncryptedRanges.FindEntryThatContains(
1802 sect64.offset) != nullptr;
1803
1804 section_sp->SetIsEncrypted(segment_is_encrypted || section_is_encrypted);
1805 section_sp->SetPermissions(segment_permissions);
1806 segment_sp->GetChildren().AddSection(section_sp);
1807
1808 if (segment_sp->IsFake()) {
1809 segment_sp.reset();
1810 const_segname.Clear();
1811 }
1812 }
1813 }
1814 if (segment_sp && is_dsym) {
1815 if (first_segment_sectID <= context.NextSectionIdx) {
1816 lldb::user_id_t sect_uid;
1817 for (sect_uid = first_segment_sectID; sect_uid <= context.NextSectionIdx;
1818 ++sect_uid) {
1819 SectionSP curr_section_sp(
1820 segment_sp->GetChildren().FindSectionByID(sect_uid));
1821 SectionSP next_section_sp;
1822 if (sect_uid + 1 <= context.NextSectionIdx)
1823 next_section_sp =
1824 segment_sp->GetChildren().FindSectionByID(sect_uid + 1);
1825
1826 if (curr_section_sp.get()) {
1827 if (curr_section_sp->GetByteSize() == 0) {
1828 if (next_section_sp.get() != nullptr)
1829 curr_section_sp->SetByteSize(next_section_sp->GetFileAddress() -
1830 curr_section_sp->GetFileAddress());
1831 else
1832 curr_section_sp->SetByteSize(load_cmd.vmsize);
1833 }
1834 }
1835 }
1836 }
1837 }
1838}
1839
1841 const llvm::MachO::load_command &load_cmd, lldb::offset_t offset) {
1842 m_dysymtab.cmd = load_cmd.cmd;
1843 m_dysymtab.cmdsize = load_cmd.cmdsize;
1844 m_data.GetU32(&offset, &m_dysymtab.ilocalsym,
1845 (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2);
1846}
1847
1849 if (m_sections_up)
1850 return;
1851
1852 m_sections_up = std::make_unique<SectionList>();
1853
1855 // bool dump_sections = false;
1856 ModuleSP module_sp(GetModule());
1857
1858 offset = MachHeaderSizeFromMagic(m_header.magic);
1859
1860 SegmentParsingContext context(GetEncryptedFileRanges(), unified_section_list);
1861 llvm::MachO::load_command load_cmd;
1862 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
1863 const lldb::offset_t load_cmd_offset = offset;
1864 if (m_data.GetU32(&offset, &load_cmd, 2) == nullptr)
1865 break;
1866
1867 if (load_cmd.cmd == LC_SEGMENT || load_cmd.cmd == LC_SEGMENT_64)
1868 ProcessSegmentCommand(load_cmd, offset, i, context);
1869 else if (load_cmd.cmd == LC_DYSYMTAB)
1870 ProcessDysymtabCommand(load_cmd, offset);
1871
1872 offset = load_cmd_offset + load_cmd.cmdsize;
1873 }
1874
1875 if (context.FileAddressesChanged && module_sp)
1876 module_sp->SectionFileAddressesChanged();
1877}
1878
1880public:
1882 : m_section_list(section_list), m_section_infos() {
1883 // Get the number of sections down to a depth of 1 to include all segments
1884 // and their sections, but no other sections that may be added for debug
1885 // map or
1886 m_section_infos.resize(section_list->GetNumSections(1));
1887 }
1888
1889 SectionSP GetSection(uint8_t n_sect, addr_t file_addr) {
1890 if (n_sect == 0)
1891 return SectionSP();
1892 if (n_sect < m_section_infos.size()) {
1893 if (!m_section_infos[n_sect].section_sp) {
1894 SectionSP section_sp(m_section_list->FindSectionByID(n_sect));
1895 m_section_infos[n_sect].section_sp = section_sp;
1896 if (section_sp) {
1897 m_section_infos[n_sect].vm_range.SetBaseAddress(
1898 section_sp->GetFileAddress());
1899 m_section_infos[n_sect].vm_range.SetByteSize(
1900 section_sp->GetByteSize());
1901 } else {
1902 std::string filename = "<unknown>";
1903 SectionSP first_section_sp(m_section_list->GetSectionAtIndex(0));
1904 if (first_section_sp)
1905 filename = first_section_sp->GetObjectFile()->GetFileSpec().GetPath();
1906
1908 llvm::formatv("unable to find section {0} for a symbol in "
1909 "{1}, corrupt file?",
1910 n_sect, filename));
1911 }
1912 }
1913 if (m_section_infos[n_sect].vm_range.Contains(file_addr)) {
1914 // Symbol is in section.
1915 return m_section_infos[n_sect].section_sp;
1916 } else if (m_section_infos[n_sect].vm_range.GetByteSize() == 0 &&
1917 m_section_infos[n_sect].vm_range.GetBaseAddress() ==
1918 file_addr) {
1919 // Symbol is in section with zero size, but has the same start address
1920 // as the section. This can happen with linker symbols (symbols that
1921 // start with the letter 'l' or 'L'.
1922 return m_section_infos[n_sect].section_sp;
1923 }
1924 }
1925 return m_section_list->FindSectionContainingFileAddress(file_addr);
1926 }
1927
1928protected:
1936 std::vector<SectionInfo> m_section_infos;
1937};
1938
1939#define TRIE_SYMBOL_IS_THUMB (1ULL << 63)
1941 void Dump() const {
1942 printf("0x%16.16llx 0x%16.16llx 0x%16.16llx \"%s\"",
1943 static_cast<unsigned long long>(address),
1944 static_cast<unsigned long long>(flags),
1945 static_cast<unsigned long long>(other), name.GetCString());
1946 if (import_name)
1947 printf(" -> \"%s\"\n", import_name.GetCString());
1948 else
1949 printf("\n");
1950 }
1953 uint64_t flags =
1954 0; // EXPORT_SYMBOL_FLAGS_REEXPORT, EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER,
1955 // TRIE_SYMBOL_IS_THUMB
1956 uint64_t other = 0;
1958};
1959
1963
1965
1966 void Dump(uint32_t idx) const {
1967 printf("[%3u] 0x%16.16llx: ", idx,
1968 static_cast<unsigned long long>(nodeOffset));
1969 entry.Dump();
1970 }
1971
1972 bool operator<(const TrieEntryWithOffset &other) const {
1973 return (nodeOffset < other.nodeOffset);
1974 }
1975};
1976
1978 const bool is_arm, addr_t text_seg_base_addr,
1979 std::vector<llvm::StringRef> &nameSlices,
1980 std::set<lldb::addr_t> &resolver_addresses,
1981 std::vector<TrieEntryWithOffset> &reexports,
1982 std::vector<TrieEntryWithOffset> &ext_symbols) {
1983 if (!data.ValidOffset(offset))
1984 return true;
1985
1986 // Terminal node -- end of a branch, possibly add this to
1987 // the symbol table or resolver table.
1988 const uint64_t terminalSize = data.GetULEB128(&offset);
1989 lldb::offset_t children_offset = offset + terminalSize;
1990 if (terminalSize != 0) {
1991 TrieEntryWithOffset e(offset);
1992 e.entry.flags = data.GetULEB128(&offset);
1993 const char *import_name = nullptr;
1994 if (e.entry.flags & EXPORT_SYMBOL_FLAGS_REEXPORT) {
1995 e.entry.address = 0;
1996 e.entry.other = data.GetULEB128(&offset); // dylib ordinal
1997 import_name = data.GetCStr(&offset);
1998 } else {
1999 e.entry.address = data.GetULEB128(&offset);
2000 if (text_seg_base_addr != LLDB_INVALID_ADDRESS)
2001 e.entry.address += text_seg_base_addr;
2002 if (e.entry.flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
2003 e.entry.other = data.GetULEB128(&offset);
2004 uint64_t resolver_addr = e.entry.other;
2005 if (text_seg_base_addr != LLDB_INVALID_ADDRESS)
2006 resolver_addr += text_seg_base_addr;
2007 if (is_arm)
2008 resolver_addr &= THUMB_ADDRESS_BIT_MASK;
2009 resolver_addresses.insert(resolver_addr);
2010 } else
2011 e.entry.other = 0;
2012 }
2013 bool add_this_entry = false;
2014 if (Flags(e.entry.flags).Test(EXPORT_SYMBOL_FLAGS_REEXPORT) &&
2015 import_name && import_name[0]) {
2016 // add symbols that are reexport symbols with a valid import name.
2017 add_this_entry = true;
2018 } else if (e.entry.flags == 0 &&
2019 (import_name == nullptr || import_name[0] == '\0')) {
2020 // add externally visible symbols, in case the nlist record has
2021 // been stripped/omitted.
2022 add_this_entry = true;
2023 }
2024 if (add_this_entry) {
2025 std::string name;
2026 if (!nameSlices.empty()) {
2027 for (auto name_slice : nameSlices)
2028 name.append(name_slice.data(), name_slice.size());
2029 }
2030 if (name.size() > 1) {
2031 // Skip the leading '_'
2032 e.entry.name.SetCStringWithLength(name.c_str() + 1, name.size() - 1);
2033 }
2034 if (import_name) {
2035 // Skip the leading '_'
2036 e.entry.import_name.SetCString(import_name + 1);
2037 }
2038 if (Flags(e.entry.flags).Test(EXPORT_SYMBOL_FLAGS_REEXPORT)) {
2039 reexports.push_back(e);
2040 } else {
2041 if (is_arm && (e.entry.address & 1)) {
2044 }
2045 ext_symbols.push_back(e);
2046 }
2047 }
2048 }
2049
2050 const uint8_t childrenCount = data.GetU8(&children_offset);
2051 for (uint8_t i = 0; i < childrenCount; ++i) {
2052 const char *cstr = data.GetCStr(&children_offset);
2053 if (cstr)
2054 nameSlices.push_back(llvm::StringRef(cstr));
2055 else
2056 return false; // Corrupt data
2057 lldb::offset_t childNodeOffset = data.GetULEB128(&children_offset);
2058 if (childNodeOffset) {
2059 if (!ParseTrieEntries(data, childNodeOffset, is_arm, text_seg_base_addr,
2060 nameSlices, resolver_addresses, reexports,
2061 ext_symbols)) {
2062 return false;
2063 }
2064 }
2065 nameSlices.pop_back();
2066 }
2067 return true;
2068}
2069
2070static bool
2071TryParseV2ObjCMetadataSymbol(const char *&symbol_name,
2072 const char *&symbol_name_non_abi_mangled,
2073 SymbolType &type) {
2074 static constexpr llvm::StringLiteral g_objc_v2_prefix_class("_OBJC_CLASS_$_");
2075 static constexpr llvm::StringLiteral g_objc_v2_prefix_metaclass(
2076 "_OBJC_METACLASS_$_");
2077 static constexpr llvm::StringLiteral g_objc_v2_prefix_ivar("_OBJC_IVAR_$_");
2078
2079 llvm::StringRef symbol_name_ref(symbol_name);
2080 if (symbol_name_ref.empty())
2081 return false;
2082
2083 if (symbol_name_ref.starts_with(g_objc_v2_prefix_class)) {
2084 symbol_name_non_abi_mangled = symbol_name + 1;
2085 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
2086 type = eSymbolTypeObjCClass;
2087 return true;
2088 }
2089
2090 if (symbol_name_ref.starts_with(g_objc_v2_prefix_metaclass)) {
2091 symbol_name_non_abi_mangled = symbol_name + 1;
2092 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
2094 return true;
2095 }
2096
2097 if (symbol_name_ref.starts_with(g_objc_v2_prefix_ivar)) {
2098 symbol_name_non_abi_mangled = symbol_name + 1;
2099 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
2100 type = eSymbolTypeObjCIVar;
2101 return true;
2102 }
2103
2104 return false;
2105}
2106
2107static SymbolType GetSymbolType(const char *&symbol_name,
2108 bool &demangled_is_synthesized,
2109 const SectionSP &text_section_sp,
2110 const SectionSP &data_section_sp,
2111 const SectionSP &data_dirty_section_sp,
2112 const SectionSP &data_const_section_sp,
2113 const SectionSP &symbol_section) {
2115
2116 const char *symbol_sect_name = symbol_section->GetName().AsCString();
2117 if (symbol_section->IsDescendant(text_section_sp.get())) {
2118 if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
2119 S_ATTR_SELF_MODIFYING_CODE |
2120 S_ATTR_SOME_INSTRUCTIONS))
2121 type = eSymbolTypeData;
2122 else
2123 type = eSymbolTypeCode;
2124 } else if (symbol_section->IsDescendant(data_section_sp.get()) ||
2125 symbol_section->IsDescendant(data_dirty_section_sp.get()) ||
2126 symbol_section->IsDescendant(data_const_section_sp.get())) {
2127 if (symbol_sect_name &&
2128 ::strstr(symbol_sect_name, "__objc") == symbol_sect_name) {
2129 type = eSymbolTypeRuntime;
2130
2131 if (symbol_name) {
2132 llvm::StringRef symbol_name_ref(symbol_name);
2133 if (symbol_name_ref.starts_with("OBJC_")) {
2134 static const llvm::StringRef g_objc_v2_prefix_class("OBJC_CLASS_$_");
2135 static const llvm::StringRef g_objc_v2_prefix_metaclass(
2136 "OBJC_METACLASS_$_");
2137 static const llvm::StringRef g_objc_v2_prefix_ivar("OBJC_IVAR_$_");
2138 if (symbol_name_ref.starts_with(g_objc_v2_prefix_class)) {
2139 symbol_name = symbol_name + g_objc_v2_prefix_class.size();
2140 type = eSymbolTypeObjCClass;
2141 demangled_is_synthesized = true;
2142 } else if (symbol_name_ref.starts_with(g_objc_v2_prefix_metaclass)) {
2143 symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
2145 demangled_is_synthesized = true;
2146 } else if (symbol_name_ref.starts_with(g_objc_v2_prefix_ivar)) {
2147 symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
2148 type = eSymbolTypeObjCIVar;
2149 demangled_is_synthesized = true;
2150 }
2151 }
2152 }
2153 } else if (symbol_sect_name &&
2154 ::strstr(symbol_sect_name, "__gcc_except_tab") ==
2155 symbol_sect_name) {
2156 type = eSymbolTypeException;
2157 } else {
2158 type = eSymbolTypeData;
2159 }
2160 } else if (symbol_sect_name &&
2161 ::strstr(symbol_sect_name, "__IMPORT") == symbol_sect_name) {
2162 type = eSymbolTypeTrampoline;
2163 }
2164 return type;
2165}
2166
2167static std::optional<struct nlist_64>
2168ParseNList(DataExtractor &nlist_data, lldb::offset_t &nlist_data_offset,
2169 size_t nlist_byte_size) {
2170 struct nlist_64 nlist;
2171 if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset, nlist_byte_size))
2172 return {};
2173 nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset);
2174 nlist.n_type = nlist_data.GetU8_unchecked(&nlist_data_offset);
2175 nlist.n_sect = nlist_data.GetU8_unchecked(&nlist_data_offset);
2176 nlist.n_desc = nlist_data.GetU16_unchecked(&nlist_data_offset);
2177 nlist.n_value = nlist_data.GetAddress_unchecked(&nlist_data_offset);
2178 return nlist;
2179}
2180
2181enum { DebugSymbols = true, NonDebugSymbols = false };
2182
2184 ModuleSP module_sp(GetModule());
2185 if (!module_sp)
2186 return;
2187
2188 Log *log = GetLog(LLDBLog::Symbols);
2189
2190 const FileSpec &file = m_file ? m_file : module_sp->GetFileSpec();
2191 const char *file_name = file.GetFilename().AsCString("<Unknown>");
2192 LLDB_SCOPED_TIMERF("ObjectFileMachO::ParseSymtab () module = %s", file_name);
2193 LLDB_LOG(log, "Parsing symbol table for {0}", file_name);
2194 Progress progress("Parsing symbol table", file_name);
2195
2196 LinkeditDataCommandLargeOffsets function_starts_load_command;
2197 LinkeditDataCommandLargeOffsets exports_trie_load_command;
2200 SymtabCommandLargeOffsets symtab_load_command;
2201 // The data element of type bool indicates that this entry is thumb
2202 // code.
2203 typedef AddressDataArray<lldb::addr_t, bool, 100> FunctionStarts;
2204
2205 // Record the address of every function/data that we add to the symtab.
2206 // We add symbols to the table in the order of most information (nlist
2207 // records) to least (function starts), and avoid duplicating symbols
2208 // via this set.
2209 llvm::DenseSet<addr_t> symbols_added;
2210
2211 // We are using a llvm::DenseSet for "symbols_added" so we must be sure we
2212 // do not add the tombstone or empty keys to the set.
2213 auto add_symbol_addr = [&symbols_added](lldb::addr_t file_addr) {
2214 // Don't add the tombstone or empty keys.
2215 if (file_addr == UINT64_MAX || file_addr == UINT64_MAX - 1)
2216 return;
2217 symbols_added.insert(file_addr);
2218 };
2219 FunctionStarts function_starts;
2221 uint32_t i;
2222 FileSpecList dylib_files;
2223 UUID image_uuid;
2224
2225 for (i = 0; i < m_header.ncmds; ++i) {
2226 const lldb::offset_t cmd_offset = offset;
2227 // Read in the load command and load command size
2228 llvm::MachO::load_command lc;
2229 if (m_data.GetU32(&offset, &lc, 2) == nullptr)
2230 break;
2231 // Watch for the symbol table load command
2232 switch (lc.cmd) {
2233 case LC_SYMTAB: {
2234 llvm::MachO::symtab_command lc_obj;
2235 if (m_data.GetU32(&offset, &lc_obj.symoff, 4)) {
2236 lc_obj.cmd = lc.cmd;
2237 lc_obj.cmdsize = lc.cmdsize;
2238 symtab_load_command = lc_obj;
2239 }
2240 } break;
2241
2242 case LC_DYLD_INFO:
2243 case LC_DYLD_INFO_ONLY: {
2244 llvm::MachO::dyld_info_command lc_obj;
2245 if (m_data.GetU32(&offset, &lc_obj.rebase_off, 10)) {
2246 lc_obj.cmd = lc.cmd;
2247 lc_obj.cmdsize = lc.cmdsize;
2248 dyld_info = lc_obj;
2249 }
2250 } break;
2251
2252 case LC_LOAD_DYLIB:
2253 case LC_LOAD_WEAK_DYLIB:
2254 case LC_REEXPORT_DYLIB:
2255 case LC_LOADFVMLIB:
2256 case LC_LOAD_UPWARD_DYLIB: {
2257 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
2258 const char *path = m_data.PeekCStr(name_offset);
2259 if (path) {
2260 FileSpec file_spec(path);
2261 // Strip the path if there is @rpath, @executable, etc so we just use
2262 // the basename
2263 if (path[0] == '@')
2264 file_spec.ClearDirectory();
2265
2266 if (lc.cmd == LC_REEXPORT_DYLIB) {
2267 m_reexported_dylibs.AppendIfUnique(file_spec);
2268 }
2269
2270 dylib_files.Append(file_spec);
2271 }
2272 } break;
2273
2274 case LC_DYLD_EXPORTS_TRIE: {
2275 llvm::MachO::linkedit_data_command lc_obj;
2276 lc_obj.cmd = lc.cmd;
2277 lc_obj.cmdsize = lc.cmdsize;
2278 if (m_data.GetU32(&offset, &lc_obj.dataoff, 2))
2279 exports_trie_load_command = lc_obj;
2280 } break;
2281 case LC_FUNCTION_STARTS: {
2282 llvm::MachO::linkedit_data_command lc_obj;
2283 lc_obj.cmd = lc.cmd;
2284 lc_obj.cmdsize = lc.cmdsize;
2285 if (m_data.GetU32(&offset, &lc_obj.dataoff, 2))
2286 function_starts_load_command = lc_obj;
2287 } break;
2288
2289 case LC_UUID: {
2290 const uint8_t *uuid_bytes = m_data.PeekData(offset, 16);
2291
2292 if (uuid_bytes)
2293 image_uuid = UUID(uuid_bytes, 16);
2294 break;
2295 }
2296
2297 default:
2298 break;
2299 }
2300 offset = cmd_offset + lc.cmdsize;
2301 }
2302
2303 if (!symtab_load_command.cmd)
2304 return;
2305
2306 SectionList *section_list = GetSectionList();
2307 if (section_list == nullptr)
2308 return;
2309
2310 const uint32_t addr_byte_size = m_data.GetAddressByteSize();
2311 const ByteOrder byte_order = m_data.GetByteOrder();
2312 bool bit_width_32 = addr_byte_size == 4;
2313 const size_t nlist_byte_size =
2314 bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
2315
2316 DataExtractor nlist_data(nullptr, 0, byte_order, addr_byte_size);
2317 DataExtractor strtab_data(nullptr, 0, byte_order, addr_byte_size);
2318 DataExtractor function_starts_data(nullptr, 0, byte_order, addr_byte_size);
2319 DataExtractor indirect_symbol_index_data(nullptr, 0, byte_order,
2320 addr_byte_size);
2321 DataExtractor dyld_trie_data(nullptr, 0, byte_order, addr_byte_size);
2322
2323 const addr_t nlist_data_byte_size =
2324 symtab_load_command.nsyms * nlist_byte_size;
2325 const addr_t strtab_data_byte_size = symtab_load_command.strsize;
2326 addr_t strtab_addr = LLDB_INVALID_ADDRESS;
2327
2328 ProcessSP process_sp(m_process_wp.lock());
2329 Process *process = process_sp.get();
2330
2331 uint32_t memory_module_load_level = eMemoryModuleLoadLevelComplete;
2332 bool is_shared_cache_image = IsSharedCacheBinary();
2333 bool is_local_shared_cache_image = is_shared_cache_image && !IsInMemory();
2334
2335 ConstString g_segment_name_TEXT = GetSegmentNameTEXT();
2336 ConstString g_segment_name_DATA = GetSegmentNameDATA();
2337 ConstString g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
2338 ConstString g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
2339 ConstString g_segment_name_OBJC = GetSegmentNameOBJC();
2340 ConstString g_section_name_eh_frame = GetSectionNameEHFrame();
2341 ConstString g_section_name_lldb_no_nlist = GetSectionNameLLDBNoNlist();
2342 SectionSP text_section_sp(
2343 section_list->FindSectionByName(g_segment_name_TEXT));
2344 SectionSP data_section_sp(
2345 section_list->FindSectionByName(g_segment_name_DATA));
2346 SectionSP linkedit_section_sp(
2347 section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
2348 SectionSP data_dirty_section_sp(
2349 section_list->FindSectionByName(g_segment_name_DATA_DIRTY));
2350 SectionSP data_const_section_sp(
2351 section_list->FindSectionByName(g_segment_name_DATA_CONST));
2352 SectionSP objc_section_sp(
2353 section_list->FindSectionByName(g_segment_name_OBJC));
2354 SectionSP eh_frame_section_sp;
2355 SectionSP lldb_no_nlist_section_sp;
2356 if (text_section_sp.get()) {
2357 eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName(
2358 g_section_name_eh_frame);
2359 lldb_no_nlist_section_sp = text_section_sp->GetChildren().FindSectionByName(
2360 g_section_name_lldb_no_nlist);
2361 } else {
2362 eh_frame_section_sp =
2363 section_list->FindSectionByName(g_section_name_eh_frame);
2364 lldb_no_nlist_section_sp =
2365 section_list->FindSectionByName(g_section_name_lldb_no_nlist);
2366 }
2367
2368 if (process && m_header.filetype != llvm::MachO::MH_OBJECT &&
2369 !is_local_shared_cache_image) {
2370 Target &target = process->GetTarget();
2371
2372 memory_module_load_level = target.GetMemoryModuleLoadLevel();
2373
2374 // If __TEXT,__lldb_no_nlist section is present in this binary,
2375 // and we're reading it out of memory, do not read any of the
2376 // nlist entries. They are not needed in lldb and it may be
2377 // expensive to load these. This is to handle a dylib consisting
2378 // of only metadata, no code, but it has many nlist entries.
2379 if (lldb_no_nlist_section_sp)
2380 memory_module_load_level = eMemoryModuleLoadLevelMinimal;
2381
2382 // Reading mach file from memory in a process or core file...
2383
2384 if (linkedit_section_sp) {
2385 addr_t linkedit_load_addr =
2386 linkedit_section_sp->GetLoadBaseAddress(&target);
2387 if (linkedit_load_addr == LLDB_INVALID_ADDRESS) {
2388 // We might be trying to access the symbol table before the
2389 // __LINKEDIT's load address has been set in the target. We can't
2390 // fail to read the symbol table, so calculate the right address
2391 // manually
2392 linkedit_load_addr = CalculateSectionLoadAddressForMemoryImage(
2393 m_memory_addr, GetMachHeaderSection(), linkedit_section_sp.get());
2394 }
2395
2396 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
2397 const addr_t symoff_addr = linkedit_load_addr +
2398 symtab_load_command.symoff -
2399 linkedit_file_offset;
2400 strtab_addr = linkedit_load_addr + symtab_load_command.stroff -
2401 linkedit_file_offset;
2402
2403 // Always load dyld - the dynamic linker - from memory if we didn't
2404 // find a binary anywhere else. lldb will not register
2405 // dylib/framework/bundle loads/unloads if we don't have the dyld
2406 // symbols, we force dyld to load from memory despite the user's
2407 // target.memory-module-load-level setting.
2408 if (memory_module_load_level == eMemoryModuleLoadLevelComplete ||
2409 m_header.filetype == llvm::MachO::MH_DYLINKER) {
2410 DataBufferSP nlist_data_sp(
2411 ReadMemory(process_sp, symoff_addr, nlist_data_byte_size));
2412 if (nlist_data_sp)
2413 nlist_data.SetData(nlist_data_sp, 0, nlist_data_sp->GetByteSize());
2414 if (dysymtab.nindirectsyms != 0) {
2415 const addr_t indirect_syms_addr = linkedit_load_addr +
2416 dysymtab.indirectsymoff -
2417 linkedit_file_offset;
2418 DataBufferSP indirect_syms_data_sp(ReadMemory(
2419 process_sp, indirect_syms_addr, dysymtab.nindirectsyms * 4));
2420 if (indirect_syms_data_sp)
2421 indirect_symbol_index_data.SetData(
2422 indirect_syms_data_sp, 0, indirect_syms_data_sp->GetByteSize());
2423 // If this binary is outside the shared cache,
2424 // cache the string table.
2425 // Binaries in the shared cache all share a giant string table,
2426 // and we can't share the string tables across multiple
2427 // ObjectFileMachO's, so we'd end up re-reading this mega-strtab
2428 // for every binary in the shared cache - it would be a big perf
2429 // problem. For binaries outside the shared cache, it's faster to
2430 // read the entire strtab at once instead of piece-by-piece as we
2431 // process the nlist records.
2432 if (!is_shared_cache_image) {
2433 DataBufferSP strtab_data_sp(
2434 ReadMemory(process_sp, strtab_addr, strtab_data_byte_size));
2435 if (strtab_data_sp) {
2436 strtab_data.SetData(strtab_data_sp, 0,
2437 strtab_data_sp->GetByteSize());
2438 }
2439 }
2440 }
2441 if (memory_module_load_level >= eMemoryModuleLoadLevelPartial) {
2442 if (function_starts_load_command.cmd) {
2443 const addr_t func_start_addr =
2444 linkedit_load_addr + function_starts_load_command.dataoff -
2445 linkedit_file_offset;
2446 DataBufferSP func_start_data_sp(
2447 ReadMemory(process_sp, func_start_addr,
2448 function_starts_load_command.datasize));
2449 if (func_start_data_sp)
2450 function_starts_data.SetData(func_start_data_sp, 0,
2451 func_start_data_sp->GetByteSize());
2452 }
2453 }
2454 }
2455 }
2456 } else {
2457 if (is_local_shared_cache_image) {
2458 // The load commands in shared cache images are relative to the
2459 // beginning of the shared cache, not the library image. The
2460 // data we get handed when creating the ObjectFileMachO starts
2461 // at the beginning of a specific library and spans to the end
2462 // of the cache to be able to reach the shared LINKEDIT
2463 // segments. We need to convert the load command offsets to be
2464 // relative to the beginning of our specific image.
2465 lldb::addr_t linkedit_offset = linkedit_section_sp->GetFileOffset();
2466 lldb::offset_t linkedit_slide =
2467 linkedit_offset - m_linkedit_original_offset;
2468 symtab_load_command.symoff += linkedit_slide;
2469 symtab_load_command.stroff += linkedit_slide;
2470 dyld_info.export_off += linkedit_slide;
2471 dysymtab.indirectsymoff += linkedit_slide;
2472 function_starts_load_command.dataoff += linkedit_slide;
2473 exports_trie_load_command.dataoff += linkedit_slide;
2474 }
2475
2476 nlist_data.SetData(m_data, symtab_load_command.symoff,
2477 nlist_data_byte_size);
2478 strtab_data.SetData(m_data, symtab_load_command.stroff,
2479 strtab_data_byte_size);
2480
2481 // We shouldn't have exports data from both the LC_DYLD_INFO command
2482 // AND the LC_DYLD_EXPORTS_TRIE command in the same binary:
2483 lldbassert(!((dyld_info.export_size > 0)
2484 && (exports_trie_load_command.datasize > 0)));
2485 if (dyld_info.export_size > 0) {
2486 dyld_trie_data.SetData(m_data, dyld_info.export_off,
2487 dyld_info.export_size);
2488 } else if (exports_trie_load_command.datasize > 0) {
2489 dyld_trie_data.SetData(m_data, exports_trie_load_command.dataoff,
2490 exports_trie_load_command.datasize);
2491 }
2492
2493 if (dysymtab.nindirectsyms != 0) {
2494 indirect_symbol_index_data.SetData(m_data, dysymtab.indirectsymoff,
2495 dysymtab.nindirectsyms * 4);
2496 }
2497 if (function_starts_load_command.cmd) {
2498 function_starts_data.SetData(m_data, function_starts_load_command.dataoff,
2499 function_starts_load_command.datasize);
2500 }
2501 }
2502
2503 const bool have_strtab_data = strtab_data.GetByteSize() > 0;
2504
2505 const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
2506 const bool always_thumb = GetArchitecture().IsAlwaysThumbInstructions();
2507
2508 // lldb works best if it knows the start address of all functions in a
2509 // module. Linker symbols or debug info are normally the best source of
2510 // information for start addr / size but they may be stripped in a released
2511 // binary. Two additional sources of information exist in Mach-O binaries:
2512 // LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each
2513 // function's start address in the
2514 // binary, relative to the text section.
2515 // eh_frame - the eh_frame FDEs have the start addr & size of
2516 // each function
2517 // LC_FUNCTION_STARTS is the fastest source to read in, and is present on
2518 // all modern binaries.
2519 // Binaries built to run on older releases may need to use eh_frame
2520 // information.
2521
2522 if (text_section_sp && function_starts_data.GetByteSize()) {
2523 FunctionStarts::Entry function_start_entry;
2524 function_start_entry.data = false;
2525 lldb::offset_t function_start_offset = 0;
2526 function_start_entry.addr = text_section_sp->GetFileAddress();
2527 uint64_t delta;
2528 while ((delta = function_starts_data.GetULEB128(&function_start_offset)) >
2529 0) {
2530 // Now append the current entry
2531 function_start_entry.addr += delta;
2532 if (is_arm) {
2533 if (function_start_entry.addr & 1) {
2534 function_start_entry.addr &= THUMB_ADDRESS_BIT_MASK;
2535 function_start_entry.data = true;
2536 } else if (always_thumb) {
2537 function_start_entry.data = true;
2538 }
2539 }
2540 function_starts.Append(function_start_entry);
2541 }
2542 } else {
2543 // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the
2544 // load command claiming an eh_frame but it doesn't actually have the
2545 // eh_frame content. And if we have a dSYM, we don't need to do any of
2546 // this fill-in-the-missing-symbols works anyway - the debug info should
2547 // give us all the functions in the module.
2548 if (text_section_sp.get() && eh_frame_section_sp.get() &&
2550 DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp,
2553 eh_frame.GetFunctionAddressAndSizeVector(functions);
2554 addr_t text_base_addr = text_section_sp->GetFileAddress();
2555 size_t count = functions.GetSize();
2556 for (size_t i = 0; i < count; ++i) {
2558 functions.GetEntryAtIndex(i);
2559 if (func) {
2560 FunctionStarts::Entry function_start_entry;
2561 function_start_entry.addr = func->base - text_base_addr;
2562 if (is_arm) {
2563 if (function_start_entry.addr & 1) {
2564 function_start_entry.addr &= THUMB_ADDRESS_BIT_MASK;
2565 function_start_entry.data = true;
2566 } else if (always_thumb) {
2567 function_start_entry.data = true;
2568 }
2569 }
2570 function_starts.Append(function_start_entry);
2571 }
2572 }
2573 }
2574 }
2575
2576 const size_t function_starts_count = function_starts.GetSize();
2577
2578 // For user process binaries (executables, dylibs, frameworks, bundles), if
2579 // we don't have LC_FUNCTION_STARTS/eh_frame section in this binary, we're
2580 // going to assume the binary has been stripped. Don't allow assembly
2581 // language instruction emulation because we don't know proper function
2582 // start boundaries.
2583 //
2584 // For all other types of binaries (kernels, stand-alone bare board
2585 // binaries, kexts), they may not have LC_FUNCTION_STARTS / eh_frame
2586 // sections - we should not make any assumptions about them based on that.
2587 if (function_starts_count == 0 && CalculateStrata() == eStrataUser) {
2589 Log *unwind_or_symbol_log(GetLog(LLDBLog::Symbols | LLDBLog::Unwind));
2590
2591 if (unwind_or_symbol_log)
2592 module_sp->LogMessage(
2593 unwind_or_symbol_log,
2594 "no LC_FUNCTION_STARTS, will not allow assembly profiled unwinds");
2595 }
2596
2597 const user_id_t TEXT_eh_frame_sectID = eh_frame_section_sp.get()
2598 ? eh_frame_section_sp->GetID()
2599 : static_cast<user_id_t>(NO_SECT);
2600
2601 uint32_t N_SO_index = UINT32_MAX;
2602
2603 MachSymtabSectionInfo section_info(section_list);
2604 std::vector<uint32_t> N_FUN_indexes;
2605 std::vector<uint32_t> N_NSYM_indexes;
2606 std::vector<uint32_t> N_INCL_indexes;
2607 std::vector<uint32_t> N_BRAC_indexes;
2608 std::vector<uint32_t> N_COMM_indexes;
2609 typedef std::multimap<uint64_t, uint32_t> ValueToSymbolIndexMap;
2610 typedef llvm::DenseMap<uint32_t, uint32_t> NListIndexToSymbolIndexMap;
2611 typedef llvm::DenseMap<const char *, uint32_t> ConstNameToSymbolIndexMap;
2612 ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
2613 ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
2614 ConstNameToSymbolIndexMap N_GSYM_name_to_sym_idx;
2615 // Any symbols that get merged into another will get an entry in this map
2616 // so we know
2617 NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
2618 uint32_t nlist_idx = 0;
2619 Symbol *symbol_ptr = nullptr;
2620
2621 uint32_t sym_idx = 0;
2622 Symbol *sym = nullptr;
2623 size_t num_syms = 0;
2624 std::string memory_symbol_name;
2625 uint32_t unmapped_local_symbols_found = 0;
2626
2627 std::vector<TrieEntryWithOffset> reexport_trie_entries;
2628 std::vector<TrieEntryWithOffset> external_sym_trie_entries;
2629 std::set<lldb::addr_t> resolver_addresses;
2630
2631 const size_t dyld_trie_data_size = dyld_trie_data.GetByteSize();
2632 if (dyld_trie_data_size > 0) {
2633 LLDB_LOG(log, "Parsing {0} bytes of dyld trie data", dyld_trie_data_size);
2634 SectionSP text_segment_sp =
2636 lldb::addr_t text_segment_file_addr = LLDB_INVALID_ADDRESS;
2637 if (text_segment_sp)
2638 text_segment_file_addr = text_segment_sp->GetFileAddress();
2639 std::vector<llvm::StringRef> nameSlices;
2640 ParseTrieEntries(dyld_trie_data, 0, is_arm, text_segment_file_addr,
2641 nameSlices, resolver_addresses, reexport_trie_entries,
2642 external_sym_trie_entries);
2643 }
2644
2645 typedef std::set<ConstString> IndirectSymbols;
2646 IndirectSymbols indirect_symbol_names;
2647
2648#if TARGET_OS_IPHONE
2649
2650 // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been
2651 // optimized by moving LOCAL symbols out of the memory mapped portion of
2652 // the DSC. The symbol information has all been retained, but it isn't
2653 // available in the normal nlist data. However, there *are* duplicate
2654 // entries of *some*
2655 // LOCAL symbols in the normal nlist data. To handle this situation
2656 // correctly, we must first attempt
2657 // to parse any DSC unmapped symbol information. If we find any, we set a
2658 // flag that tells the normal nlist parser to ignore all LOCAL symbols.
2659
2660 if (IsSharedCacheBinary()) {
2661 // Before we can start mapping the DSC, we need to make certain the
2662 // target process is actually using the cache we can find.
2663
2664 // Next we need to determine the correct path for the dyld shared cache.
2665
2666 ArchSpec header_arch = GetArchitecture();
2667
2668 UUID dsc_uuid;
2669 UUID process_shared_cache_uuid;
2670 addr_t process_shared_cache_base_addr;
2671
2672 if (process) {
2673 GetProcessSharedCacheUUID(process, process_shared_cache_base_addr,
2674 process_shared_cache_uuid);
2675 }
2676
2677 __block bool found_image = false;
2678 __block void *nlist_buffer = nullptr;
2679 __block unsigned nlist_count = 0;
2680 __block char *string_table = nullptr;
2681 __block vm_offset_t vm_nlist_memory = 0;
2682 __block mach_msg_type_number_t vm_nlist_bytes_read = 0;
2683 __block vm_offset_t vm_string_memory = 0;
2684 __block mach_msg_type_number_t vm_string_bytes_read = 0;
2685
2686 auto _ = llvm::make_scope_exit(^{
2687 if (vm_nlist_memory)
2688 vm_deallocate(mach_task_self(), vm_nlist_memory, vm_nlist_bytes_read);
2689 if (vm_string_memory)
2690 vm_deallocate(mach_task_self(), vm_string_memory, vm_string_bytes_read);
2691 });
2692
2693 typedef llvm::DenseMap<ConstString, uint16_t> UndefinedNameToDescMap;
2694 typedef llvm::DenseMap<uint32_t, ConstString> SymbolIndexToName;
2695 UndefinedNameToDescMap undefined_name_to_desc;
2696 SymbolIndexToName reexport_shlib_needs_fixup;
2697
2698 dyld_for_each_installed_shared_cache(^(dyld_shared_cache_t shared_cache) {
2699 uuid_t cache_uuid;
2700 dyld_shared_cache_copy_uuid(shared_cache, &cache_uuid);
2701 if (found_image)
2702 return;
2703
2704 if (process_shared_cache_uuid.IsValid() &&
2705 process_shared_cache_uuid != UUID(&cache_uuid, 16))
2706 return;
2707
2708 dyld_shared_cache_for_each_image(shared_cache, ^(dyld_image_t image) {
2709 uuid_t dsc_image_uuid;
2710 if (found_image)
2711 return;
2712
2713 dyld_image_copy_uuid(image, &dsc_image_uuid);
2714 if (image_uuid != UUID(dsc_image_uuid, 16))
2715 return;
2716
2717 found_image = true;
2718
2719 // Compute the size of the string table. We need to ask dyld for a
2720 // new SPI to avoid this step.
2721 dyld_image_local_nlist_content_4Symbolication(
2722 image, ^(const void *nlistStart, uint64_t nlistCount,
2723 const char *stringTable) {
2724 if (!nlistStart || !nlistCount)
2725 return;
2726
2727 // The buffers passed here are valid only inside the block.
2728 // Use vm_read to make a cheap copy of them available for our
2729 // processing later.
2730 kern_return_t ret =
2731 vm_read(mach_task_self(), (vm_address_t)nlistStart,
2732 nlist_byte_size * nlistCount, &vm_nlist_memory,
2733 &vm_nlist_bytes_read);
2734 if (ret != KERN_SUCCESS)
2735 return;
2736 assert(vm_nlist_bytes_read == nlist_byte_size * nlistCount);
2737
2738 // We don't know the size of the string table. It's cheaper
2739 // to map the whole VM region than to determine the size by
2740 // parsing all the nlist entries.
2741 vm_address_t string_address = (vm_address_t)stringTable;
2742 vm_size_t region_size;
2743 mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT_64;
2744 vm_region_basic_info_data_t info;
2745 memory_object_name_t object;
2746 ret = vm_region_64(mach_task_self(), &string_address,
2747 &region_size, VM_REGION_BASIC_INFO_64,
2748 (vm_region_info_t)&info, &info_count, &object);
2749 if (ret != KERN_SUCCESS)
2750 return;
2751
2752 ret = vm_read(mach_task_self(), (vm_address_t)stringTable,
2753 region_size -
2754 ((vm_address_t)stringTable - string_address),
2755 &vm_string_memory, &vm_string_bytes_read);
2756 if (ret != KERN_SUCCESS)
2757 return;
2758
2759 nlist_buffer = (void *)vm_nlist_memory;
2760 string_table = (char *)vm_string_memory;
2761 nlist_count = nlistCount;
2762 });
2763 });
2764 });
2765 if (nlist_buffer) {
2766 DataExtractor dsc_local_symbols_data(nlist_buffer,
2767 nlist_count * nlist_byte_size,
2768 byte_order, addr_byte_size);
2769 unmapped_local_symbols_found = nlist_count;
2770
2771 // The normal nlist code cannot correctly size the Symbols
2772 // array, we need to allocate it here.
2773 sym = symtab.Resize(
2774 symtab_load_command.nsyms + m_dysymtab.nindirectsyms +
2775 unmapped_local_symbols_found - m_dysymtab.nlocalsym);
2776 num_syms = symtab.GetNumSymbols();
2777
2778 lldb::offset_t nlist_data_offset = 0;
2779
2780 for (uint32_t nlist_index = 0;
2781 nlist_index < nlist_count;
2782 nlist_index++) {
2783 /////////////////////////////
2784 {
2785 std::optional<struct nlist_64> nlist_maybe =
2786 ParseNList(dsc_local_symbols_data, nlist_data_offset,
2787 nlist_byte_size);
2788 if (!nlist_maybe)
2789 break;
2790 struct nlist_64 nlist = *nlist_maybe;
2791
2793 const char *symbol_name = string_table + nlist.n_strx;
2794
2795 if (symbol_name == NULL) {
2796 // No symbol should be NULL, even the symbols with no
2797 // string values should have an offset zero which
2798 // points to an empty C-string
2799 Debugger::ReportError(llvm::formatv(
2800 "DSC unmapped local symbol[{0}] has invalid "
2801 "string table offset {1:x} in {2}, ignoring symbol",
2802 nlist_index, nlist.n_strx,
2803 module_sp->GetFileSpec().GetPath()));
2804 continue;
2805 }
2806 if (symbol_name[0] == '\0')
2807 symbol_name = NULL;
2808
2809 const char *symbol_name_non_abi_mangled = NULL;
2810
2811 SectionSP symbol_section;
2812 bool add_nlist = true;
2813 bool is_debug = ((nlist.n_type & N_STAB) != 0);
2814 bool demangled_is_synthesized = false;
2815 bool is_gsym = false;
2816 bool set_value = true;
2817
2818 assert(sym_idx < num_syms);
2819
2820 sym[sym_idx].SetDebug(is_debug);
2821
2822 if (is_debug) {
2823 switch (nlist.n_type) {
2824 case N_GSYM:
2825 // global symbol: name,,NO_SECT,type,0
2826 // Sometimes the N_GSYM value contains the address.
2827
2828 // FIXME: In the .o files, we have a GSYM and a debug
2829 // symbol for all the ObjC data. They
2830 // have the same address, but we want to ensure that
2831 // we always find only the real symbol, 'cause we
2832 // don't currently correctly attribute the
2833 // GSYM one to the ObjCClass/Ivar/MetaClass
2834 // symbol type. This is a temporary hack to make
2835 // sure the ObjectiveC symbols get treated correctly.
2836 // To do this right, we should coalesce all the GSYM
2837 // & global symbols that have the same address.
2838
2839 is_gsym = true;
2840 sym[sym_idx].SetExternal(true);
2841
2843 symbol_name, symbol_name_non_abi_mangled,
2844 type)) {
2845 demangled_is_synthesized = true;
2846 } else {
2847 if (nlist.n_value != 0)
2848 symbol_section = section_info.GetSection(
2849 nlist.n_sect, nlist.n_value);
2850
2851 type = eSymbolTypeData;
2852 }
2853 break;
2854
2855 case N_FNAME:
2856 // procedure name (f77 kludge): name,,NO_SECT,0,0
2857 type = eSymbolTypeCompiler;
2858 break;
2859
2860 case N_FUN:
2861 // procedure: name,,n_sect,linenumber,address
2862 if (symbol_name) {
2863 type = eSymbolTypeCode;
2864 symbol_section = section_info.GetSection(
2865 nlist.n_sect, nlist.n_value);
2866
2867 N_FUN_addr_to_sym_idx.insert(
2868 std::make_pair(nlist.n_value, sym_idx));
2869 // We use the current number of symbols in the
2870 // symbol table in lieu of using nlist_idx in case
2871 // we ever start trimming entries out
2872 N_FUN_indexes.push_back(sym_idx);
2873 } else {
2874 type = eSymbolTypeCompiler;
2875
2876 if (!N_FUN_indexes.empty()) {
2877 // Copy the size of the function into the
2878 // original
2879 // STAB entry so we don't have
2880 // to hunt for it later
2881 symtab.SymbolAtIndex(N_FUN_indexes.back())
2882 ->SetByteSize(nlist.n_value);
2883 N_FUN_indexes.pop_back();
2884 // We don't really need the end function STAB as
2885 // it contains the size which we already placed
2886 // with the original symbol, so don't add it if
2887 // we want a minimal symbol table
2888 add_nlist = false;
2889 }
2890 }
2891 break;
2892
2893 case N_STSYM:
2894 // static symbol: name,,n_sect,type,address
2895 N_STSYM_addr_to_sym_idx.insert(
2896 std::make_pair(nlist.n_value, sym_idx));
2897 symbol_section = section_info.GetSection(nlist.n_sect,
2898 nlist.n_value);
2899 if (symbol_name && symbol_name[0]) {
2901 symbol_name + 1, eSymbolTypeData);
2902 }
2903 break;
2904
2905 case N_LCSYM:
2906 // .lcomm symbol: name,,n_sect,type,address
2907 symbol_section = section_info.GetSection(nlist.n_sect,
2908 nlist.n_value);
2910 break;
2911
2912 case N_BNSYM:
2913 // We use the current number of symbols in the symbol
2914 // table in lieu of using nlist_idx in case we ever
2915 // start trimming entries out Skip these if we want
2916 // minimal symbol tables
2917 add_nlist = false;
2918 break;
2919
2920 case N_ENSYM:
2921 // Set the size of the N_BNSYM to the terminating
2922 // index of this N_ENSYM so that we can always skip
2923 // the entire symbol if we need to navigate more
2924 // quickly at the source level when parsing STABS
2925 // Skip these if we want minimal symbol tables
2926 add_nlist = false;
2927 break;
2928
2929 case N_OPT:
2930 // emitted with gcc2_compiled and in gcc source
2931 type = eSymbolTypeCompiler;
2932 break;
2933
2934 case N_RSYM:
2935 // register sym: name,,NO_SECT,type,register
2936 type = eSymbolTypeVariable;
2937 break;
2938
2939 case N_SLINE:
2940 // src line: 0,,n_sect,linenumber,address
2941 symbol_section = section_info.GetSection(nlist.n_sect,
2942 nlist.n_value);
2943 type = eSymbolTypeLineEntry;
2944 break;
2945
2946 case N_SSYM:
2947 // structure elt: name,,NO_SECT,type,struct_offset
2949 break;
2950
2951 case N_SO:
2952 // source file name
2953 type = eSymbolTypeSourceFile;
2954 if (symbol_name == NULL) {
2955 add_nlist = false;
2956 if (N_SO_index != UINT32_MAX) {
2957 // Set the size of the N_SO to the terminating
2958 // index of this N_SO so that we can always skip
2959 // the entire N_SO if we need to navigate more
2960 // quickly at the source level when parsing STABS
2961 symbol_ptr = symtab.SymbolAtIndex(N_SO_index);
2962 symbol_ptr->SetByteSize(sym_idx);
2963 symbol_ptr->SetSizeIsSibling(true);
2964 }
2965 N_NSYM_indexes.clear();
2966 N_INCL_indexes.clear();
2967 N_BRAC_indexes.clear();
2968 N_COMM_indexes.clear();
2969 N_FUN_indexes.clear();
2970 N_SO_index = UINT32_MAX;
2971 } else {
2972 // We use the current number of symbols in the
2973 // symbol table in lieu of using nlist_idx in case
2974 // we ever start trimming entries out
2975 const bool N_SO_has_full_path = symbol_name[0] == '/';
2976 if (N_SO_has_full_path) {
2977 if ((N_SO_index == sym_idx - 1) &&
2978 ((sym_idx - 1) < num_syms)) {
2979 // We have two consecutive N_SO entries where
2980 // the first contains a directory and the
2981 // second contains a full path.
2982 sym[sym_idx - 1].GetMangled().SetValue(
2983 ConstString(symbol_name));
2984 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
2985 add_nlist = false;
2986 } else {
2987 // This is the first entry in a N_SO that
2988 // contains a directory or
2989 // a full path to the source file
2990 N_SO_index = sym_idx;
2991 }
2992 } else if ((N_SO_index == sym_idx - 1) &&
2993 ((sym_idx - 1) < num_syms)) {
2994 // This is usually the second N_SO entry that
2995 // contains just the filename, so here we combine
2996 // it with the first one if we are minimizing the
2997 // symbol table
2998 const char *so_path = sym[sym_idx - 1]
2999 .GetMangled()
3001 .AsCString();
3002 if (so_path && so_path[0]) {
3003 std::string full_so_path(so_path);
3004 const size_t double_slash_pos =
3005 full_so_path.find("//");
3006 if (double_slash_pos != std::string::npos) {
3007 // The linker has been generating bad N_SO
3008 // entries with doubled up paths
3009 // in the format "%s%s" where the first
3010 // string in the DW_AT_comp_dir, and the
3011 // second is the directory for the source
3012 // file so you end up with a path that looks
3013 // like "/tmp/src//tmp/src/"
3014 FileSpec so_dir(so_path);
3015 if (!FileSystem::Instance().Exists(so_dir)) {
3016 so_dir.SetFile(
3017 &full_so_path[double_slash_pos + 1],
3018 FileSpec::Style::native);
3019 if (FileSystem::Instance().Exists(so_dir)) {
3020 // Trim off the incorrect path
3021 full_so_path.erase(0, double_slash_pos + 1);
3022 }
3023 }
3024 }
3025 if (*full_so_path.rbegin() != '/')
3026 full_so_path += '/';
3027 full_so_path += symbol_name;
3028 sym[sym_idx - 1].GetMangled().SetValue(
3029 ConstString(full_so_path.c_str()));
3030 add_nlist = false;
3031 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3032 }
3033 } else {
3034 // This could be a relative path to a N_SO
3035 N_SO_index = sym_idx;
3036 }
3037 }
3038 break;
3039
3040 case N_OSO:
3041 // object file name: name,,0,0,st_mtime
3042 type = eSymbolTypeObjectFile;
3043 break;
3044
3045 case N_LSYM:
3046 // local sym: name,,NO_SECT,type,offset
3047 type = eSymbolTypeLocal;
3048 break;
3049
3050 // INCL scopes
3051 case N_BINCL:
3052 // include file beginning: name,,NO_SECT,0,sum We use
3053 // the current number of symbols in the symbol table
3054 // in lieu of using nlist_idx in case we ever start
3055 // trimming entries out
3056 N_INCL_indexes.push_back(sym_idx);
3057 type = eSymbolTypeScopeBegin;
3058 break;
3059
3060 case N_EINCL:
3061 // include file end: name,,NO_SECT,0,0
3062 // Set the size of the N_BINCL to the terminating
3063 // index of this N_EINCL so that we can always skip
3064 // the entire symbol if we need to navigate more
3065 // quickly at the source level when parsing STABS
3066 if (!N_INCL_indexes.empty()) {
3067 symbol_ptr =
3068 symtab.SymbolAtIndex(N_INCL_indexes.back());
3069 symbol_ptr->SetByteSize(sym_idx + 1);
3070 symbol_ptr->SetSizeIsSibling(true);
3071 N_INCL_indexes.pop_back();
3072 }
3073 type = eSymbolTypeScopeEnd;
3074 break;
3075
3076 case N_SOL:
3077 // #included file name: name,,n_sect,0,address
3078 type = eSymbolTypeHeaderFile;
3079
3080 // We currently don't use the header files on darwin
3081 add_nlist = false;
3082 break;
3083
3084 case N_PARAMS:
3085 // compiler parameters: name,,NO_SECT,0,0
3086 type = eSymbolTypeCompiler;
3087 break;
3088
3089 case N_VERSION:
3090 // compiler version: name,,NO_SECT,0,0
3091 type = eSymbolTypeCompiler;
3092 break;
3093
3094 case N_OLEVEL:
3095 // compiler -O level: name,,NO_SECT,0,0
3096 type = eSymbolTypeCompiler;
3097 break;
3098
3099 case N_PSYM:
3100 // parameter: name,,NO_SECT,type,offset
3101 type = eSymbolTypeVariable;
3102 break;
3103
3104 case N_ENTRY:
3105 // alternate entry: name,,n_sect,linenumber,address
3106 symbol_section = section_info.GetSection(nlist.n_sect,
3107 nlist.n_value);
3108 type = eSymbolTypeLineEntry;
3109 break;
3110
3111 // Left and Right Braces
3112 case N_LBRAC:
3113 // left bracket: 0,,NO_SECT,nesting level,address We
3114 // use the current number of symbols in the symbol
3115 // table in lieu of using nlist_idx in case we ever
3116 // start trimming entries out
3117 symbol_section = section_info.GetSection(nlist.n_sect,
3118 nlist.n_value);
3119 N_BRAC_indexes.push_back(sym_idx);
3120 type = eSymbolTypeScopeBegin;
3121 break;
3122
3123 case N_RBRAC:
3124 // right bracket: 0,,NO_SECT,nesting level,address
3125 // Set the size of the N_LBRAC to the terminating
3126 // index of this N_RBRAC so that we can always skip
3127 // the entire symbol if we need to navigate more
3128 // quickly at the source level when parsing STABS
3129 symbol_section = section_info.GetSection(nlist.n_sect,
3130 nlist.n_value);
3131 if (!N_BRAC_indexes.empty()) {
3132 symbol_ptr =
3133 symtab.SymbolAtIndex(N_BRAC_indexes.back());
3134 symbol_ptr->SetByteSize(sym_idx + 1);
3135 symbol_ptr->SetSizeIsSibling(true);
3136 N_BRAC_indexes.pop_back();
3137 }
3138 type = eSymbolTypeScopeEnd;
3139 break;
3140
3141 case N_EXCL:
3142 // deleted include file: name,,NO_SECT,0,sum
3143 type = eSymbolTypeHeaderFile;
3144 break;
3145
3146 // COMM scopes
3147 case N_BCOMM:
3148 // begin common: name,,NO_SECT,0,0
3149 // We use the current number of symbols in the symbol
3150 // table in lieu of using nlist_idx in case we ever
3151 // start trimming entries out
3152 type = eSymbolTypeScopeBegin;
3153 N_COMM_indexes.push_back(sym_idx);
3154 break;
3155
3156 case N_ECOML:
3157 // end common (local name): 0,,n_sect,0,address
3158 symbol_section = section_info.GetSection(nlist.n_sect,
3159 nlist.n_value);
3160 // Fall through
3161
3162 case N_ECOMM:
3163 // end common: name,,n_sect,0,0
3164 // Set the size of the N_BCOMM to the terminating
3165 // index of this N_ECOMM/N_ECOML so that we can
3166 // always skip the entire symbol if we need to
3167 // navigate more quickly at the source level when
3168 // parsing STABS
3169 if (!N_COMM_indexes.empty()) {
3170 symbol_ptr =
3171 symtab.SymbolAtIndex(N_COMM_indexes.back());
3172 symbol_ptr->SetByteSize(sym_idx + 1);
3173 symbol_ptr->SetSizeIsSibling(true);
3174 N_COMM_indexes.pop_back();
3175 }
3176 type = eSymbolTypeScopeEnd;
3177 break;
3178
3179 case N_LENG:
3180 // second stab entry with length information
3181 type = eSymbolTypeAdditional;
3182 break;
3183
3184 default:
3185 break;
3186 }
3187 } else {
3188 // uint8_t n_pext = N_PEXT & nlist.n_type;
3189 uint8_t n_type = N_TYPE & nlist.n_type;
3190 sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
3191
3192 switch (n_type) {
3193 case N_INDR: {
3194 const char *reexport_name_cstr =
3195 strtab_data.PeekCStr(nlist.n_value);
3196 if (reexport_name_cstr && reexport_name_cstr[0]) {
3197 type = eSymbolTypeReExported;
3198 ConstString reexport_name(
3199 reexport_name_cstr +
3200 ((reexport_name_cstr[0] == '_') ? 1 : 0));
3201 sym[sym_idx].SetReExportedSymbolName(reexport_name);
3202 set_value = false;
3203 reexport_shlib_needs_fixup[sym_idx] = reexport_name;
3204 indirect_symbol_names.insert(ConstString(
3205 symbol_name + ((symbol_name[0] == '_') ? 1 : 0)));
3206 } else
3207 type = eSymbolTypeUndefined;
3208 } break;
3209
3210 case N_UNDF:
3211 if (symbol_name && symbol_name[0]) {
3212 ConstString undefined_name(
3213 symbol_name + ((symbol_name[0] == '_') ? 1 : 0));
3214 undefined_name_to_desc[undefined_name] = nlist.n_desc;
3215 }
3216 // Fall through
3217 case N_PBUD:
3218 type = eSymbolTypeUndefined;
3219 break;
3220
3221 case N_ABS:
3222 type = eSymbolTypeAbsolute;
3223 break;
3224
3225 case N_SECT: {
3226 symbol_section = section_info.GetSection(nlist.n_sect,
3227 nlist.n_value);
3228
3229 if (symbol_section == NULL) {
3230 // TODO: warn about this?
3231 add_nlist = false;
3232 break;
3233 }
3234
3235 if (TEXT_eh_frame_sectID == nlist.n_sect) {
3236 type = eSymbolTypeException;
3237 } else {
3238 uint32_t section_type =
3239 symbol_section->Get() & SECTION_TYPE;
3240
3241 switch (section_type) {
3242 case S_CSTRING_LITERALS:
3243 type = eSymbolTypeData;
3244 break; // section with only literal C strings
3245 case S_4BYTE_LITERALS:
3246 type = eSymbolTypeData;
3247 break; // section with only 4 byte literals
3248 case S_8BYTE_LITERALS:
3249 type = eSymbolTypeData;
3250 break; // section with only 8 byte literals
3251 case S_LITERAL_POINTERS:
3252 type = eSymbolTypeTrampoline;
3253 break; // section with only pointers to literals
3254 case S_NON_LAZY_SYMBOL_POINTERS:
3255 type = eSymbolTypeTrampoline;
3256 break; // section with only non-lazy symbol
3257 // pointers
3258 case S_LAZY_SYMBOL_POINTERS:
3259 type = eSymbolTypeTrampoline;
3260 break; // section with only lazy symbol pointers
3261 case S_SYMBOL_STUBS:
3262 type = eSymbolTypeTrampoline;
3263 break; // section with only symbol stubs, byte
3264 // size of stub in the reserved2 field
3265 case S_MOD_INIT_FUNC_POINTERS:
3266 type = eSymbolTypeCode;
3267 break; // section with only function pointers for
3268 // initialization
3269 case S_MOD_TERM_FUNC_POINTERS:
3270 type = eSymbolTypeCode;
3271 break; // section with only function pointers for
3272 // termination
3273 case S_INTERPOSING:
3274 type = eSymbolTypeTrampoline;
3275 break; // section with only pairs of function
3276 // pointers for interposing
3277 case S_16BYTE_LITERALS:
3278 type = eSymbolTypeData;
3279 break; // section with only 16 byte literals
3280 case S_DTRACE_DOF:
3282 break;
3283 case S_LAZY_DYLIB_SYMBOL_POINTERS:
3284 type = eSymbolTypeTrampoline;
3285 break;
3286 default:
3287 switch (symbol_section->GetType()) {
3289 type = eSymbolTypeCode;
3290 break;
3291 case eSectionTypeData:
3292 case eSectionTypeDataCString: // Inlined C string
3293 // data
3294 case eSectionTypeDataCStringPointers: // Pointers
3295 // to C
3296 // string
3297 // data
3298 case eSectionTypeDataSymbolAddress: // Address of
3299 // a symbol in
3300 // the symbol
3301 // table
3302 case eSectionTypeData4:
3303 case eSectionTypeData8:
3304 case eSectionTypeData16:
3305 type = eSymbolTypeData;
3306 break;
3307 default:
3308 break;
3309 }
3310 break;
3311 }
3312
3313 if (type == eSymbolTypeInvalid) {
3314 const char *symbol_sect_name =
3315 symbol_section->GetName().AsCString();
3316 if (symbol_section->IsDescendant(
3317 text_section_sp.get())) {
3318 if (symbol_section->IsClear(
3319 S_ATTR_PURE_INSTRUCTIONS |
3320 S_ATTR_SELF_MODIFYING_CODE |
3321 S_ATTR_SOME_INSTRUCTIONS))
3322 type = eSymbolTypeData;
3323 else
3324 type = eSymbolTypeCode;
3325 } else if (symbol_section->IsDescendant(
3326 data_section_sp.get()) ||
3327 symbol_section->IsDescendant(
3328 data_dirty_section_sp.get()) ||
3329 symbol_section->IsDescendant(
3330 data_const_section_sp.get())) {
3331 if (symbol_sect_name &&
3332 ::strstr(symbol_sect_name, "__objc") ==
3333 symbol_sect_name) {
3334 type = eSymbolTypeRuntime;
3335
3337 symbol_name,
3338 symbol_name_non_abi_mangled, type))
3339 demangled_is_synthesized = true;
3340 } else if (symbol_sect_name &&
3341 ::strstr(symbol_sect_name,
3342 "__gcc_except_tab") ==
3343 symbol_sect_name) {
3344 type = eSymbolTypeException;
3345 } else {
3346 type = eSymbolTypeData;
3347 }
3348 } else if (symbol_sect_name &&
3349 ::strstr(symbol_sect_name, "__IMPORT") ==
3350 symbol_sect_name) {
3351 type = eSymbolTypeTrampoline;
3352 } else if (symbol_section->IsDescendant(
3353 objc_section_sp.get())) {
3354 type = eSymbolTypeRuntime;
3355 if (symbol_name && symbol_name[0] == '.') {
3356 llvm::StringRef symbol_name_ref(symbol_name);
3357 llvm::StringRef
3358 g_objc_v1_prefix_class(".objc_class_name_");
3359 if (symbol_name_ref.starts_with(
3360 g_objc_v1_prefix_class)) {
3361 symbol_name_non_abi_mangled = symbol_name;
3362 symbol_name = symbol_name +
3363 g_objc_v1_prefix_class.size();
3364 type = eSymbolTypeObjCClass;
3365 demangled_is_synthesized = true;
3366 }
3367 }
3368 }
3369 }
3370 }
3371 } break;
3372 }
3373 }
3374
3375 if (add_nlist) {
3376 uint64_t symbol_value = nlist.n_value;
3377 if (symbol_name_non_abi_mangled) {
3378 sym[sym_idx].GetMangled().SetMangledName(
3379 ConstString(symbol_name_non_abi_mangled));
3380 sym[sym_idx].GetMangled().SetDemangledName(
3381 ConstString(symbol_name));
3382 } else {
3383 if (symbol_name && symbol_name[0] == '_') {
3384 symbol_name++; // Skip the leading underscore
3385 }
3386
3387 if (symbol_name) {
3388 ConstString const_symbol_name(symbol_name);
3389 sym[sym_idx].GetMangled().SetValue(const_symbol_name);
3390 if (is_gsym && is_debug) {
3391 const char *gsym_name =
3392 sym[sym_idx]
3393 .GetMangled()
3395 .GetCString();
3396 if (gsym_name)
3397 N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
3398 }
3399 }
3400 }
3401 if (symbol_section) {
3402 const addr_t section_file_addr =
3403 symbol_section->GetFileAddress();
3404 symbol_value -= section_file_addr;
3405 }
3406
3407 if (is_debug == false) {
3408 if (type == eSymbolTypeCode) {
3409 // See if we can find a N_FUN entry for any code
3410 // symbols. If we do find a match, and the name
3411 // matches, then we can merge the two into just the
3412 // function symbol to avoid duplicate entries in
3413 // the symbol table
3414 auto range =
3415 N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
3416 if (range.first != range.second) {
3417 bool found_it = false;
3418 for (auto pos = range.first; pos != range.second;
3419 ++pos) {
3420 if (sym[sym_idx].GetMangled().GetName(
3422 sym[pos->second].GetMangled().GetName(
3424 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3425 // We just need the flags from the linker
3426 // symbol, so put these flags
3427 // into the N_FUN flags to avoid duplicate
3428 // symbols in the symbol table
3429 sym[pos->second].SetExternal(
3430 sym[sym_idx].IsExternal());
3431 sym[pos->second].SetFlags(nlist.n_type << 16 |
3432 nlist.n_desc);
3433 if (resolver_addresses.find(nlist.n_value) !=
3434 resolver_addresses.end())
3435 sym[pos->second].SetType(eSymbolTypeResolver);
3436 sym[sym_idx].Clear();
3437 found_it = true;
3438 break;
3439 }
3440 }
3441 if (found_it)
3442 continue;
3443 } else {
3444 if (resolver_addresses.find(nlist.n_value) !=
3445 resolver_addresses.end())
3446 type = eSymbolTypeResolver;
3447 }
3448 } else if (type == eSymbolTypeData ||
3449 type == eSymbolTypeObjCClass ||
3450 type == eSymbolTypeObjCMetaClass ||
3451 type == eSymbolTypeObjCIVar) {
3452 // See if we can find a N_STSYM entry for any data
3453 // symbols. If we do find a match, and the name
3454 // matches, then we can merge the two into just the
3455 // Static symbol to avoid duplicate entries in the
3456 // symbol table
3457 auto range = N_STSYM_addr_to_sym_idx.equal_range(
3458 nlist.n_value);
3459 if (range.first != range.second) {
3460 bool found_it = false;
3461 for (auto pos = range.first; pos != range.second;
3462 ++pos) {
3463 if (sym[sym_idx].GetMangled().GetName(
3465 sym[pos->second].GetMangled().GetName(
3467 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
3468 // We just need the flags from the linker
3469 // symbol, so put these flags
3470 // into the N_STSYM flags to avoid duplicate
3471 // symbols in the symbol table
3472 sym[pos->second].SetExternal(
3473 sym[sym_idx].IsExternal());
3474 sym[pos->second].SetFlags(nlist.n_type << 16 |
3475 nlist.n_desc);
3476 sym[sym_idx].Clear();
3477 found_it = true;
3478 break;
3479 }
3480 }
3481 if (found_it)
3482 continue;
3483 } else {
3484 const char *gsym_name =
3485 sym[sym_idx]
3486 .GetMangled()
3488 .GetCString();
3489 if (gsym_name) {
3490 // Combine N_GSYM stab entries with the non
3491 // stab symbol
3492 ConstNameToSymbolIndexMap::const_iterator pos =
3493 N_GSYM_name_to_sym_idx.find(gsym_name);
3494 if (pos != N_GSYM_name_to_sym_idx.end()) {
3495 const uint32_t GSYM_sym_idx = pos->second;
3496 m_nlist_idx_to_sym_idx[nlist_idx] =
3497 GSYM_sym_idx;
3498 // Copy the address, because often the N_GSYM
3499 // address has an invalid address of zero
3500 // when the global is a common symbol
3501 sym[GSYM_sym_idx].GetAddressRef().SetSection(
3502 symbol_section);
3503 sym[GSYM_sym_idx].GetAddressRef().SetOffset(
3504 symbol_value);
3505 add_symbol_addr(sym[GSYM_sym_idx]
3506 .GetAddress()
3507 .GetFileAddress());
3508 // We just need the flags from the linker
3509 // symbol, so put these flags
3510 // into the N_GSYM flags to avoid duplicate
3511 // symbols in the symbol table
3512 sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 |
3513 nlist.n_desc);
3514 sym[sym_idx].Clear();
3515 continue;
3516 }
3517 }
3518 }
3519 }
3520 }
3521
3522 sym[sym_idx].SetID(nlist_idx);
3523 sym[sym_idx].SetType(type);
3524 if (set_value) {
3525 sym[sym_idx].GetAddressRef().SetSection(symbol_section);
3526 sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
3527 add_symbol_addr(
3528 sym[sym_idx].GetAddress().GetFileAddress());
3529 }
3530 sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
3531
3532 if (demangled_is_synthesized)
3533 sym[sym_idx].SetDemangledNameIsSynthesized(true);
3534 ++sym_idx;
3535 } else {
3536 sym[sym_idx].Clear();
3537 }
3538 }
3539 /////////////////////////////
3540 }
3541 }
3542
3543 for (const auto &pos : reexport_shlib_needs_fixup) {
3544 const auto undef_pos = undefined_name_to_desc.find(pos.second);
3545 if (undef_pos != undefined_name_to_desc.end()) {
3546 const uint8_t dylib_ordinal =
3547 llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
3548 if (dylib_ordinal > 0 && dylib_ordinal < dylib_files.GetSize())
3549 sym[pos.first].SetReExportedSymbolSharedLibrary(
3550 dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
3551 }
3552 }
3553 }
3554
3555#endif
3556 lldb::offset_t nlist_data_offset = 0;
3557
3558 if (nlist_data.GetByteSize() > 0) {
3559
3560 // If the sym array was not created while parsing the DSC unmapped
3561 // symbols, create it now.
3562 if (sym == nullptr) {
3563 sym =
3564 symtab.Resize(symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
3565 num_syms = symtab.GetNumSymbols();
3566 }
3567
3568 if (unmapped_local_symbols_found) {
3569 assert(m_dysymtab.ilocalsym == 0);
3570 nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
3571 nlist_idx = m_dysymtab.nlocalsym;
3572 } else {
3573 nlist_idx = 0;
3574 }
3575
3576 typedef llvm::DenseMap<ConstString, uint16_t> UndefinedNameToDescMap;
3577 typedef llvm::DenseMap<uint32_t, ConstString> SymbolIndexToName;
3578 UndefinedNameToDescMap undefined_name_to_desc;
3579 SymbolIndexToName reexport_shlib_needs_fixup;
3580
3581 // Symtab parsing is a huge mess. Everything is entangled and the code
3582 // requires access to a ridiculous amount of variables. LLDB depends
3583 // heavily on the proper merging of symbols and to get that right we need
3584 // to make sure we have parsed all the debug symbols first. Therefore we
3585 // invoke the lambda twice, once to parse only the debug symbols and then
3586 // once more to parse the remaining symbols.
3587 auto ParseSymbolLambda = [&](struct nlist_64 &nlist, uint32_t nlist_idx,
3588 bool debug_only) {
3589 const bool is_debug = ((nlist.n_type & N_STAB) != 0);
3590 if (is_debug != debug_only)
3591 return true;
3592
3593 const char *symbol_name_non_abi_mangled = nullptr;
3594 const char *symbol_name = nullptr;
3595
3596 if (have_strtab_data) {
3597 symbol_name = strtab_data.PeekCStr(nlist.n_strx);
3598
3599 if (symbol_name == nullptr) {
3600 // No symbol should be NULL, even the symbols with no string values
3601 // should have an offset zero which points to an empty C-string
3602 Debugger::ReportError(llvm::formatv(
3603 "symbol[{0}] has invalid string table offset {1:x} in {2}, "
3604 "ignoring symbol",
3605 nlist_idx, nlist.n_strx, module_sp->GetFileSpec().GetPath()));
3606 return true;
3607 }
3608 if (symbol_name[0] == '\0')
3609 symbol_name = nullptr;
3610 } else {
3611 const addr_t str_addr = strtab_addr + nlist.n_strx;
3612 Status str_error;
3613 if (process->ReadCStringFromMemory(str_addr, memory_symbol_name,
3614 str_error))
3615 symbol_name = memory_symbol_name.c_str();
3616 }
3617
3619 SectionSP symbol_section;
3620 bool add_nlist = true;
3621 bool is_gsym = false;
3622 bool demangled_is_synthesized = false;
3623 bool set_value = true;
3624
3625 assert(sym_idx < num_syms);
3626 sym[sym_idx].SetDebug(is_debug);
3627
3628 if (is_debug) {
3629 switch (nlist.n_type) {
3630 case N_GSYM: {
3631 // global symbol: name,,NO_SECT,type,0
3632 // Sometimes the N_GSYM value contains the address.
3633
3634 // FIXME: In the .o files, we have a GSYM and a debug symbol for all
3635 // the ObjC data. They
3636 // have the same address, but we want to ensure that we always find
3637 // only the real symbol, 'cause we don't currently correctly
3638 // attribute the GSYM one to the ObjCClass/Ivar/MetaClass symbol
3639 // type. This is a temporary hack to make sure the ObjectiveC
3640 // symbols get treated correctly. To do this right, we should
3641 // coalesce all the GSYM & global symbols that have the same
3642 // address.
3643 is_gsym = true;
3644 sym[sym_idx].SetExternal(true);
3645
3646 if (TryParseV2ObjCMetadataSymbol(symbol_name,
3647 symbol_name_non_abi_mangled, type)) {
3648 demangled_is_synthesized = true;
3649 } else {
3650 if (nlist.n_value != 0)
3651 symbol_section =
3652 section_info.GetSection(nlist.n_sect, nlist.n_value);
3653
3654 type = eSymbolTypeData;
3655 }
3656 } break;
3657
3658 case N_FNAME:
3659 // procedure name (f77 kludge): name,,NO_SECT,0,0
3660 type = eSymbolTypeCompiler;
3661 break;
3662
3663 case N_FUN:
3664 // procedure: name,,n_sect,linenumber,address
3665 if (symbol_name) {
3666 type = eSymbolTypeCode;
3667 symbol_section =
3668 section_info.GetSection(nlist.n_sect, nlist.n_value);
3669
3670 N_FUN_addr_to_sym_idx.insert(
3671 std::make_pair(nlist.n_value, sym_idx));
3672 // We use the current number of symbols in the symbol table in
3673 // lieu of using nlist_idx in case we ever start trimming entries
3674 // out
3675 N_FUN_indexes.push_back(sym_idx);
3676 } else {
3677 type = eSymbolTypeCompiler;
3678
3679 if (!N_FUN_indexes.empty()) {
3680 // Copy the size of the function into the original STAB entry
3681 // so we don't have to hunt for it later
3682 symtab.SymbolAtIndex(N_FUN_indexes.back())
3683 ->SetByteSize(nlist.n_value);
3684 N_FUN_indexes.pop_back();
3685 // We don't really need the end function STAB as it contains
3686 // the size which we already placed with the original symbol,
3687 // so don't add it if we want a minimal symbol table
3688 add_nlist = false;
3689 }
3690 }
3691 break;
3692
3693 case N_STSYM:
3694 // static symbol: name,,n_sect,type,address
3695 N_STSYM_addr_to_sym_idx.insert(
3696 std::make_pair(nlist.n_value, sym_idx));
3697 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3698 if (symbol_name && symbol_name[0]) {
3699 type = ObjectFile::GetSymbolTypeFromName(symbol_name + 1,
3701 }
3702 break;
3703
3704 case N_LCSYM:
3705 // .lcomm symbol: name,,n_sect,type,address
3706 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3708 break;
3709
3710 case N_BNSYM:
3711 // We use the current number of symbols in the symbol table in lieu
3712 // of using nlist_idx in case we ever start trimming entries out
3713 // Skip these if we want minimal symbol tables
3714 add_nlist = false;
3715 break;
3716
3717 case N_ENSYM:
3718 // Set the size of the N_BNSYM to the terminating index of this
3719 // N_ENSYM so that we can always skip the entire symbol if we need
3720 // to navigate more quickly at the source level when parsing STABS
3721 // Skip these if we want minimal symbol tables
3722 add_nlist = false;
3723 break;
3724
3725 case N_OPT:
3726 // emitted with gcc2_compiled and in gcc source
3727 type = eSymbolTypeCompiler;
3728 break;
3729
3730 case N_RSYM:
3731 // register sym: name,,NO_SECT,type,register
3732 type = eSymbolTypeVariable;
3733 break;
3734
3735 case N_SLINE:
3736 // src line: 0,,n_sect,linenumber,address
3737 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3738 type = eSymbolTypeLineEntry;
3739 break;
3740
3741 case N_SSYM:
3742 // structure elt: name,,NO_SECT,type,struct_offset
3744 break;
3745
3746 case N_SO:
3747 // source file name
3748 type = eSymbolTypeSourceFile;
3749 if (symbol_name == nullptr) {
3750 add_nlist = false;
3751 if (N_SO_index != UINT32_MAX) {
3752 // Set the size of the N_SO to the terminating index of this
3753 // N_SO so that we can always skip the entire N_SO if we need
3754 // to navigate more quickly at the source level when parsing
3755 // STABS
3756 symbol_ptr = symtab.SymbolAtIndex(N_SO_index);
3757 symbol_ptr->SetByteSize(sym_idx);
3758 symbol_ptr->SetSizeIsSibling(true);
3759 }
3760 N_NSYM_indexes.clear();
3761 N_INCL_indexes.clear();
3762 N_BRAC_indexes.clear();
3763 N_COMM_indexes.clear();
3764 N_FUN_indexes.clear();
3765 N_SO_index = UINT32_MAX;
3766 } else {
3767 // We use the current number of symbols in the symbol table in
3768 // lieu of using nlist_idx in case we ever start trimming entries
3769 // out
3770 const bool N_SO_has_full_path = symbol_name[0] == '/';
3771 if (N_SO_has_full_path) {
3772 if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms)) {
3773 // We have two consecutive N_SO entries where the first
3774 // contains a directory and the second contains a full path.
3775 sym[sym_idx - 1].GetMangled().SetValue(
3776 ConstString(symbol_name));
3777 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3778 add_nlist = false;
3779 } else {
3780 // This is the first entry in a N_SO that contains a
3781 // directory or a full path to the source file
3782 N_SO_index = sym_idx;
3783 }
3784 } else if ((N_SO_index == sym_idx - 1) &&
3785 ((sym_idx - 1) < num_syms)) {
3786 // This is usually the second N_SO entry that contains just the
3787 // filename, so here we combine it with the first one if we are
3788 // minimizing the symbol table
3789 const char *so_path =
3790 sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
3791 if (so_path && so_path[0]) {
3792 std::string full_so_path(so_path);
3793 const size_t double_slash_pos = full_so_path.find("//");
3794 if (double_slash_pos != std::string::npos) {
3795 // The linker has been generating bad N_SO entries with
3796 // doubled up paths in the format "%s%s" where the first
3797 // string in the DW_AT_comp_dir, and the second is the
3798 // directory for the source file so you end up with a path
3799 // that looks like "/tmp/src//tmp/src/"
3800 FileSpec so_dir(so_path);
3801 if (!FileSystem::Instance().Exists(so_dir)) {
3802 so_dir.SetFile(&full_so_path[double_slash_pos + 1],
3803 FileSpec::Style::native);
3804 if (FileSystem::Instance().Exists(so_dir)) {
3805 // Trim off the incorrect path
3806 full_so_path.erase(0, double_slash_pos + 1);
3807 }
3808 }
3809 }
3810 if (*full_so_path.rbegin() != '/')
3811 full_so_path += '/';
3812 full_so_path += symbol_name;
3813 sym[sym_idx - 1].GetMangled().SetValue(
3814 ConstString(full_so_path.c_str()));
3815 add_nlist = false;
3816 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3817 }
3818 } else {
3819 // This could be a relative path to a N_SO
3820 N_SO_index = sym_idx;
3821 }
3822 }
3823 break;
3824
3825 case N_OSO:
3826 // object file name: name,,0,0,st_mtime
3827 type = eSymbolTypeObjectFile;
3828 break;
3829
3830 case N_LSYM:
3831 // local sym: name,,NO_SECT,type,offset
3832 type = eSymbolTypeLocal;
3833 break;
3834
3835 // INCL scopes
3836 case N_BINCL:
3837 // include file beginning: name,,NO_SECT,0,sum We use the current
3838 // number of symbols in the symbol table in lieu of using nlist_idx
3839 // in case we ever start trimming entries out
3840 N_INCL_indexes.push_back(sym_idx);
3841 type = eSymbolTypeScopeBegin;
3842 break;
3843
3844 case N_EINCL:
3845 // include file end: name,,NO_SECT,0,0
3846 // Set the size of the N_BINCL to the terminating index of this
3847 // N_EINCL so that we can always skip the entire symbol if we need
3848 // to navigate more quickly at the source level when parsing STABS
3849 if (!N_INCL_indexes.empty()) {
3850 symbol_ptr = symtab.SymbolAtIndex(N_INCL_indexes.back());
3851 symbol_ptr->SetByteSize(sym_idx + 1);
3852 symbol_ptr->SetSizeIsSibling(true);
3853 N_INCL_indexes.pop_back();
3854 }
3855 type = eSymbolTypeScopeEnd;
3856 break;
3857
3858 case N_SOL:
3859 // #included file name: name,,n_sect,0,address
3860 type = eSymbolTypeHeaderFile;
3861
3862 // We currently don't use the header files on darwin
3863 add_nlist = false;
3864 break;
3865
3866 case N_PARAMS:
3867 // compiler parameters: name,,NO_SECT,0,0
3868 type = eSymbolTypeCompiler;
3869 break;
3870
3871 case N_VERSION:
3872 // compiler version: name,,NO_SECT,0,0
3873 type = eSymbolTypeCompiler;
3874 break;
3875
3876 case N_OLEVEL:
3877 // compiler -O level: name,,NO_SECT,0,0
3878 type = eSymbolTypeCompiler;
3879 break;
3880
3881 case N_PSYM:
3882 // parameter: name,,NO_SECT,type,offset
3883 type = eSymbolTypeVariable;
3884 break;
3885
3886 case N_ENTRY:
3887 // alternate entry: name,,n_sect,linenumber,address
3888 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3889 type = eSymbolTypeLineEntry;
3890 break;
3891
3892 // Left and Right Braces
3893 case N_LBRAC:
3894 // left bracket: 0,,NO_SECT,nesting level,address We use the
3895 // current number of symbols in the symbol table in lieu of using
3896 // nlist_idx in case we ever start trimming entries out
3897 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3898 N_BRAC_indexes.push_back(sym_idx);
3899 type = eSymbolTypeScopeBegin;
3900 break;
3901
3902 case N_RBRAC:
3903 // right bracket: 0,,NO_SECT,nesting level,address Set the size of
3904 // the N_LBRAC to the terminating index of this N_RBRAC so that we
3905 // can always skip the entire symbol if we need to navigate more
3906 // quickly at the source level when parsing STABS
3907 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3908 if (!N_BRAC_indexes.empty()) {
3909 symbol_ptr = symtab.SymbolAtIndex(N_BRAC_indexes.back());
3910 symbol_ptr->SetByteSize(sym_idx + 1);
3911 symbol_ptr->SetSizeIsSibling(true);
3912 N_BRAC_indexes.pop_back();
3913 }
3914 type = eSymbolTypeScopeEnd;
3915 break;
3916
3917 case N_EXCL:
3918 // deleted include file: name,,NO_SECT,0,sum
3919 type = eSymbolTypeHeaderFile;
3920 break;
3921
3922 // COMM scopes
3923 case N_BCOMM:
3924 // begin common: name,,NO_SECT,0,0
3925 // We use the current number of symbols in the symbol table in lieu
3926 // of using nlist_idx in case we ever start trimming entries out
3927 type = eSymbolTypeScopeBegin;
3928 N_COMM_indexes.push_back(sym_idx);
3929 break;
3930
3931 case N_ECOML:
3932 // end common (local name): 0,,n_sect,0,address
3933 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3934 [[fallthrough]];
3935
3936 case N_ECOMM:
3937 // end common: name,,n_sect,0,0
3938 // Set the size of the N_BCOMM to the terminating index of this
3939 // N_ECOMM/N_ECOML so that we can always skip the entire symbol if
3940 // we need to navigate more quickly at the source level when
3941 // parsing STABS
3942 if (!N_COMM_indexes.empty()) {
3943 symbol_ptr = symtab.SymbolAtIndex(N_COMM_indexes.back());
3944 symbol_ptr->SetByteSize(sym_idx + 1);
3945 symbol_ptr->SetSizeIsSibling(true);
3946 N_COMM_indexes.pop_back();
3947 }
3948 type = eSymbolTypeScopeEnd;
3949 break;
3950
3951 case N_LENG:
3952 // second stab entry with length information
3953 type = eSymbolTypeAdditional;
3954 break;
3955
3956 default:
3957 break;
3958 }
3959 } else {
3960 uint8_t n_type = N_TYPE & nlist.n_type;
3961 sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
3962
3963 switch (n_type) {
3964 case N_INDR: {
3965 const char *reexport_name_cstr = strtab_data.PeekCStr(nlist.n_value);
3966 if (reexport_name_cstr && reexport_name_cstr[0] && symbol_name) {
3967 type = eSymbolTypeReExported;
3968 ConstString reexport_name(reexport_name_cstr +
3969 ((reexport_name_cstr[0] == '_') ? 1 : 0));
3970 sym[sym_idx].SetReExportedSymbolName(reexport_name);
3971 set_value = false;
3972 reexport_shlib_needs_fixup[sym_idx] = reexport_name;
3973 indirect_symbol_names.insert(
3974 ConstString(symbol_name + ((symbol_name[0] == '_') ? 1 : 0)));
3975 } else
3976 type = eSymbolTypeUndefined;
3977 } break;
3978
3979 case N_UNDF:
3980 if (symbol_name && symbol_name[0]) {
3981 ConstString undefined_name(symbol_name +
3982 ((symbol_name[0] == '_') ? 1 : 0));
3983 undefined_name_to_desc[undefined_name] = nlist.n_desc;
3984 }
3985 [[fallthrough]];
3986
3987 case N_PBUD:
3988 type = eSymbolTypeUndefined;
3989 break;
3990
3991 case N_ABS:
3992 type = eSymbolTypeAbsolute;
3993 break;
3994
3995 case N_SECT: {
3996 symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
3997
3998 if (!symbol_section) {
3999 // TODO: warn about this?
4000 add_nlist = false;
4001 break;
4002 }
4003
4004 if (TEXT_eh_frame_sectID == nlist.n_sect) {
4005 type = eSymbolTypeException;
4006 } else {
4007 uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
4008
4009 switch (section_type) {
4010 case S_CSTRING_LITERALS:
4011 type = eSymbolTypeData;
4012 break; // section with only literal C strings
4013 case S_4BYTE_LITERALS:
4014 type = eSymbolTypeData;
4015 break; // section with only 4 byte literals
4016 case S_8BYTE_LITERALS:
4017 type = eSymbolTypeData;
4018 break; // section with only 8 byte literals
4019 case S_LITERAL_POINTERS:
4020 type = eSymbolTypeTrampoline;
4021 break; // section with only pointers to literals
4022 case S_NON_LAZY_SYMBOL_POINTERS:
4023 type = eSymbolTypeTrampoline;
4024 break; // section with only non-lazy symbol pointers
4025 case S_LAZY_SYMBOL_POINTERS:
4026 type = eSymbolTypeTrampoline;
4027 break; // section with only lazy symbol pointers
4028 case S_SYMBOL_STUBS:
4029 type = eSymbolTypeTrampoline;
4030 break; // section with only symbol stubs, byte size of stub in
4031 // the reserved2 field
4032 case S_MOD_INIT_FUNC_POINTERS:
4033 type = eSymbolTypeCode;
4034 break; // section with only function pointers for initialization
4035 case S_MOD_TERM_FUNC_POINTERS:
4036 type = eSymbolTypeCode;
4037 break; // section with only function pointers for termination
4038 case S_INTERPOSING:
4039 type = eSymbolTypeTrampoline;
4040 break; // section with only pairs of function pointers for
4041 // interposing
4042 case S_16BYTE_LITERALS:
4043 type = eSymbolTypeData;
4044 break; // section with only 16 byte literals
4045 case S_DTRACE_DOF:
4047 break;
4048 case S_LAZY_DYLIB_SYMBOL_POINTERS:
4049 type = eSymbolTypeTrampoline;
4050 break;
4051 default:
4052 switch (symbol_section->GetType()) {
4054 type = eSymbolTypeCode;
4055 break;
4056 case eSectionTypeData:
4057 case eSectionTypeDataCString: // Inlined C string data
4058 case eSectionTypeDataCStringPointers: // Pointers to C string
4059 // data
4060 case eSectionTypeDataSymbolAddress: // Address of a symbol in
4061 // the symbol table
4062 case eSectionTypeData4:
4063 case eSectionTypeData8:
4064 case eSectionTypeData16:
4065 type = eSymbolTypeData;
4066 break;
4067 default:
4068 break;
4069 }
4070 break;
4071 }
4072
4073 if (type == eSymbolTypeInvalid) {
4074 const char *symbol_sect_name =
4075 symbol_section->GetName().AsCString();
4076 if (symbol_section->IsDescendant(text_section_sp.get())) {
4077 if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
4078 S_ATTR_SELF_MODIFYING_CODE |
4079 S_ATTR_SOME_INSTRUCTIONS))
4080 type = eSymbolTypeData;
4081 else
4082 type = eSymbolTypeCode;
4083 } else if (symbol_section->IsDescendant(data_section_sp.get()) ||
4084 symbol_section->IsDescendant(
4085 data_dirty_section_sp.get()) ||
4086 symbol_section->IsDescendant(
4087 data_const_section_sp.get())) {
4088 if (symbol_sect_name &&
4089 ::strstr(symbol_sect_name, "__objc") == symbol_sect_name) {
4090 type = eSymbolTypeRuntime;
4091
4093 symbol_name, symbol_name_non_abi_mangled, type))
4094 demangled_is_synthesized = true;
4095 } else if (symbol_sect_name &&
4096 ::strstr(symbol_sect_name, "__gcc_except_tab") ==
4097 symbol_sect_name) {
4098 type = eSymbolTypeException;
4099 } else {
4100 type = eSymbolTypeData;
4101 }
4102 } else if (symbol_sect_name &&
4103 ::strstr(symbol_sect_name, "__IMPORT") ==
4104 symbol_sect_name) {
4105 type = eSymbolTypeTrampoline;
4106 } else if (symbol_section->IsDescendant(objc_section_sp.get())) {
4107 type = eSymbolTypeRuntime;
4108 if (symbol_name && symbol_name[0] == '.') {
4109 llvm::StringRef symbol_name_ref(symbol_name);
4110 llvm::StringRef g_objc_v1_prefix_class(
4111 ".objc_class_name_");
4112 if (symbol_name_ref.starts_with(g_objc_v1_prefix_class)) {
4113 symbol_name_non_abi_mangled = symbol_name;
4114 symbol_name = symbol_name + g_objc_v1_prefix_class.size();
4115 type = eSymbolTypeObjCClass;
4116 demangled_is_synthesized = true;
4117 }
4118 }
4119 }
4120 }
4121 }
4122 } break;
4123 }
4124 }
4125
4126 if (!add_nlist) {
4127 sym[sym_idx].Clear();
4128 return true;
4129 }
4130
4131 uint64_t symbol_value = nlist.n_value;
4132
4133 if (symbol_name_non_abi_mangled) {
4134 sym[sym_idx].GetMangled().SetMangledName(
4135 ConstString(symbol_name_non_abi_mangled));
4136 sym[sym_idx].GetMangled().SetDemangledName(ConstString(symbol_name));
4137 } else {
4138
4139 if (symbol_name && symbol_name[0] == '_') {
4140 symbol_name++; // Skip the leading underscore
4141 }
4142
4143 if (symbol_name) {
4144 ConstString const_symbol_name(symbol_name);
4145 sym[sym_idx].GetMangled().SetValue(const_symbol_name);
4146 }
4147 }
4148
4149 if (is_gsym) {
4150 const char *gsym_name = sym[sym_idx]
4151 .GetMangled()
4153 .GetCString();
4154 if (gsym_name)
4155 N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
4156 }
4157
4158 if (symbol_section) {
4159 const addr_t section_file_addr = symbol_section->GetFileAddress();
4160 symbol_value -= section_file_addr;
4161 }
4162
4163 if (!is_debug) {
4164 if (type == eSymbolTypeCode) {
4165 // See if we can find a N_FUN entry for any code symbols. If we do
4166 // find a match, and the name matches, then we can merge the two into
4167 // just the function symbol to avoid duplicate entries in the symbol
4168 // table.
4169 std::pair<ValueToSymbolIndexMap::const_iterator,
4170 ValueToSymbolIndexMap::const_iterator>
4171 range;
4172 range = N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
4173 if (range.first != range.second) {
4174 for (ValueToSymbolIndexMap::const_iterator pos = range.first;
4175 pos != range.second; ++pos) {
4176 if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) ==
4177 sym[pos->second].GetMangled().GetName(
4179 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4180 // We just need the flags from the linker symbol, so put these
4181 // flags into the N_FUN flags to avoid duplicate symbols in the
4182 // symbol table.
4183 sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
4184 sym[pos->second].SetFlags(nlist.n_type << 16 | nlist.n_desc);
4185 if (resolver_addresses.find(nlist.n_value) !=
4186 resolver_addresses.end())
4187 sym[pos->second].SetType(eSymbolTypeResolver);
4188 sym[sym_idx].Clear();
4189 return true;
4190 }
4191 }
4192 } else {
4193 if (resolver_addresses.find(nlist.n_value) !=
4194 resolver_addresses.end())
4195 type = eSymbolTypeResolver;
4196 }
4197 } else if (type == eSymbolTypeData || type == eSymbolTypeObjCClass ||
4198 type == eSymbolTypeObjCMetaClass ||
4199 type == eSymbolTypeObjCIVar) {
4200 // See if we can find a N_STSYM entry for any data symbols. If we do
4201 // find a match, and the name matches, then we can merge the two into
4202 // just the Static symbol to avoid duplicate entries in the symbol
4203 // table.
4204 std::pair<ValueToSymbolIndexMap::const_iterator,
4205 ValueToSymbolIndexMap::const_iterator>
4206 range;
4207 range = N_STSYM_addr_to_sym_idx.equal_range(nlist.n_value);
4208 if (range.first != range.second) {
4209 for (ValueToSymbolIndexMap::const_iterator pos = range.first;
4210 pos != range.second; ++pos) {
4211 if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) ==
4212 sym[pos->second].GetMangled().GetName(
4214 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4215 // We just need the flags from the linker symbol, so put these
4216 // flags into the N_STSYM flags to avoid duplicate symbols in
4217 // the symbol table.
4218 sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
4219 sym[pos->second].SetFlags(nlist.n_type << 16 | nlist.n_desc);
4220 sym[sym_idx].Clear();
4221 return true;
4222 }
4223 }
4224 } else {
4225 // Combine N_GSYM stab entries with the non stab symbol.
4226 const char *gsym_name = sym[sym_idx]
4227 .GetMangled()
4229 .GetCString();
4230 if (gsym_name) {
4231 ConstNameToSymbolIndexMap::const_iterator pos =
4232 N_GSYM_name_to_sym_idx.find(gsym_name);
4233 if (pos != N_GSYM_name_to_sym_idx.end()) {
4234 const uint32_t GSYM_sym_idx = pos->second;
4235 m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
4236 // Copy the address, because often the N_GSYM address has an
4237 // invalid address of zero when the global is a common symbol.
4238 sym[GSYM_sym_idx].GetAddressRef().SetSection(symbol_section);
4239 sym[GSYM_sym_idx].GetAddressRef().SetOffset(symbol_value);
4240 add_symbol_addr(
4241 sym[GSYM_sym_idx].GetAddress().GetFileAddress());
4242 // We just need the flags from the linker symbol, so put these
4243 // flags into the N_GSYM flags to avoid duplicate symbols in
4244 // the symbol table.
4245 sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
4246 sym[sym_idx].Clear();
4247 return true;
4248 }
4249 }
4250 }
4251 }
4252 }
4253
4254 sym[sym_idx].SetID(nlist_idx);
4255 sym[sym_idx].SetType(type);
4256 if (set_value) {
4257 sym[sym_idx].GetAddressRef().SetSection(symbol_section);
4258 sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
4259 if (symbol_section)
4260 add_symbol_addr(sym[sym_idx].GetAddress().GetFileAddress());
4261 }
4262 sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
4263 if (nlist.n_desc & N_WEAK_REF)
4264 sym[sym_idx].SetIsWeak(true);
4265
4266 if (demangled_is_synthesized)
4267 sym[sym_idx].SetDemangledNameIsSynthesized(true);
4268
4269 ++sym_idx;
4270 return true;
4271 };
4272
4273 // First parse all the nlists but don't process them yet. See the next
4274 // comment for an explanation why.
4275 std::vector<struct nlist_64> nlists;
4276 nlists.reserve(symtab_load_command.nsyms);
4277 for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx) {
4278 if (auto nlist =
4279 ParseNList(nlist_data, nlist_data_offset, nlist_byte_size))
4280 nlists.push_back(*nlist);
4281 else
4282 break;
4283 }
4284
4285 // Now parse all the debug symbols. This is needed to merge non-debug
4286 // symbols in the next step. Non-debug symbols are always coalesced into
4287 // the debug symbol. Doing this in one step would mean that some symbols
4288 // won't be merged.
4289 nlist_idx = 0;
4290 for (auto &nlist : nlists) {
4291 if (!ParseSymbolLambda(nlist, nlist_idx++, DebugSymbols))
4292 break;
4293 }
4294
4295 // Finally parse all the non debug symbols.
4296 nlist_idx = 0;
4297 for (auto &nlist : nlists) {
4298 if (!ParseSymbolLambda(nlist, nlist_idx++, NonDebugSymbols))
4299 break;
4300 }
4301
4302 for (const auto &pos : reexport_shlib_needs_fixup) {
4303 const auto undef_pos = undefined_name_to_desc.find(pos.second);
4304 if (undef_pos != undefined_name_to_desc.end()) {
4305 const uint8_t dylib_ordinal =
4306 llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
4307 if (dylib_ordinal > 0 && dylib_ordinal < dylib_files.GetSize())
4308 sym[pos.first].SetReExportedSymbolSharedLibrary(
4309 dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
4310 }
4311 }
4312 }
4313
4314 // Count how many trie symbols we'll add to the symbol table
4315 int trie_symbol_table_augment_count = 0;
4316 for (auto &e : external_sym_trie_entries) {
4317 if (!symbols_added.contains(e.entry.address))
4318 trie_symbol_table_augment_count++;
4319 }
4320
4321 if (num_syms < sym_idx + trie_symbol_table_augment_count) {
4322 num_syms = sym_idx + trie_symbol_table_augment_count;
4323 sym = symtab.Resize(num_syms);
4324 }
4325 uint32_t synthetic_sym_id = symtab_load_command.nsyms;
4326
4327 // Add symbols from the trie to the symbol table.
4328 for (auto &e : external_sym_trie_entries) {
4329 if (symbols_added.contains(e.entry.address))
4330 continue;
4331
4332 // Find the section that this trie address is in, use that to annotate
4333 // symbol type as we add the trie address and name to the symbol table.
4334 Address symbol_addr;
4335 if (module_sp->ResolveFileAddress(e.entry.address, symbol_addr)) {
4336 SectionSP symbol_section(symbol_addr.GetSection());
4337 const char *symbol_name = e.entry.name.GetCString();
4338 bool demangled_is_synthesized = false;
4339 SymbolType type =
4340 GetSymbolType(symbol_name, demangled_is_synthesized, text_section_sp,
4341 data_section_sp, data_dirty_section_sp,
4342 data_const_section_sp, symbol_section);
4343
4344 sym[sym_idx].SetType(type);
4345 if (symbol_section) {
4346 sym[sym_idx].SetID(synthetic_sym_id++);
4347 sym[sym_idx].GetMangled().SetMangledName(ConstString(symbol_name));
4348 if (demangled_is_synthesized)
4349 sym[sym_idx].SetDemangledNameIsSynthesized(true);
4350 sym[sym_idx].SetIsSynthetic(true);
4351 sym[sym_idx].SetExternal(true);
4352 sym[sym_idx].GetAddressRef() = symbol_addr;
4353 add_symbol_addr(symbol_addr.GetFileAddress());
4354 if (e.entry.flags & TRIE_SYMBOL_IS_THUMB)
4356 ++sym_idx;
4357 }
4358 }
4359 }
4360
4361 if (function_starts_count > 0) {
4362 uint32_t num_synthetic_function_symbols = 0;
4363 for (i = 0; i < function_starts_count; ++i) {
4364 if (!symbols_added.contains(function_starts.GetEntryRef(i).addr))
4365 ++num_synthetic_function_symbols;
4366 }
4367
4368 if (num_synthetic_function_symbols > 0) {
4369 if (num_syms < sym_idx + num_synthetic_function_symbols) {
4370 num_syms = sym_idx + num_synthetic_function_symbols;
4371 sym = symtab.Resize(num_syms);
4372 }
4373 for (i = 0; i < function_starts_count; ++i) {
4374 const FunctionStarts::Entry *func_start_entry =
4375 function_starts.GetEntryAtIndex(i);
4376 if (!symbols_added.contains(func_start_entry->addr)) {
4377 addr_t symbol_file_addr = func_start_entry->addr;
4378 uint32_t symbol_flags = 0;
4379 if (func_start_entry->data)
4380 symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
4381 Address symbol_addr;
4382 if (module_sp->ResolveFileAddress(symbol_file_addr, symbol_addr)) {
4383 SectionSP symbol_section(symbol_addr.GetSection());
4384 if (symbol_section) {
4385 sym[sym_idx].SetID(synthetic_sym_id++);
4386 // Don't set the name for any synthetic symbols, the Symbol
4387 // object will generate one if needed when the name is accessed
4388 // via accessors.
4389 sym[sym_idx].GetMangled().SetDemangledName(ConstString());
4390 sym[sym_idx].SetType(eSymbolTypeCode);
4391 sym[sym_idx].SetIsSynthetic(true);
4392 sym[sym_idx].GetAddressRef() = symbol_addr;
4393 add_symbol_addr(symbol_addr.GetFileAddress());
4394 if (symbol_flags)
4395 sym[sym_idx].SetFlags(symbol_flags);
4396 ++sym_idx;
4397 }
4398 }
4399 }
4400 }
4401 }
4402 }
4403
4404 // Trim our symbols down to just what we ended up with after removing any
4405 // symbols.
4406 if (sym_idx < num_syms) {
4407 num_syms = sym_idx;
4408 sym = symtab.Resize(num_syms);
4409 }
4410
4411 // Now synthesize indirect symbols
4412 if (m_dysymtab.nindirectsyms != 0) {
4413 if (indirect_symbol_index_data.GetByteSize()) {
4414 NListIndexToSymbolIndexMap::const_iterator end_index_pos =
4415 m_nlist_idx_to_sym_idx.end();
4416
4417 for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size();
4418 ++sect_idx) {
4419 if ((m_mach_sections[sect_idx].flags & SECTION_TYPE) ==
4420 S_SYMBOL_STUBS) {
4421 uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2;
4422 if (symbol_stub_byte_size == 0)
4423 continue;
4424
4425 const uint32_t num_symbol_stubs =
4426 m_mach_sections[sect_idx].size / symbol_stub_byte_size;
4427
4428 if (num_symbol_stubs == 0)
4429 continue;
4430
4431 const uint32_t symbol_stub_index_offset =
4432 m_mach_sections[sect_idx].reserved1;
4433 for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx) {
4434 const uint32_t symbol_stub_index =
4435 symbol_stub_index_offset + stub_idx;
4436 const lldb::addr_t symbol_stub_addr =
4437 m_mach_sections[sect_idx].addr +
4438 (stub_idx * symbol_stub_byte_size);
4439 lldb::offset_t symbol_stub_offset = symbol_stub_index * 4;
4440 if (indirect_symbol_index_data.ValidOffsetForDataOfSize(
4441 symbol_stub_offset, 4)) {
4442 const uint32_t stub_sym_id =
4443 indirect_symbol_index_data.GetU32(&symbol_stub_offset);
4444 if (stub_sym_id & (INDIRECT_SYMBOL_ABS | INDIRECT_SYMBOL_LOCAL))
4445 continue;
4446
4447 NListIndexToSymbolIndexMap::const_iterator index_pos =
4448 m_nlist_idx_to_sym_idx.find(stub_sym_id);
4449 Symbol *stub_symbol = nullptr;
4450 if (index_pos != end_index_pos) {
4451 // We have a remapping from the original nlist index to a
4452 // current symbol index, so just look this up by index
4453 stub_symbol = symtab.SymbolAtIndex(index_pos->second);
4454 } else {
4455 // We need to lookup a symbol using the original nlist symbol
4456 // index since this index is coming from the S_SYMBOL_STUBS
4457 stub_symbol = symtab.FindSymbolByID(stub_sym_id);
4458 }
4459
4460 if (stub_symbol) {
4461 Address so_addr(symbol_stub_addr, section_list);
4462
4463 if (stub_symbol->GetType() == eSymbolTypeUndefined) {
4464 // Change the external symbol into a trampoline that makes
4465 // sense These symbols were N_UNDF N_EXT, and are useless
4466 // to us, so we can re-use them so we don't have to make up
4467 // a synthetic symbol for no good reason.
4468 if (resolver_addresses.find(symbol_stub_addr) ==
4469 resolver_addresses.end())
4470 stub_symbol->SetType(eSymbolTypeTrampoline);
4471 else
4472 stub_symbol->SetType(eSymbolTypeResolver);
4473 stub_symbol->SetExternal(false);
4474 stub_symbol->GetAddressRef() = so_addr;
4475 stub_symbol->SetByteSize(symbol_stub_byte_size);
4476 } else {
4477 // Make a synthetic symbol to describe the trampoline stub
4478 Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
4479 if (sym_idx >= num_syms) {
4480 sym = symtab.Resize(++num_syms);
4481 stub_symbol = nullptr; // this pointer no longer valid
4482 }
4483 sym[sym_idx].SetID(synthetic_sym_id++);
4484 sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
4485 if (resolver_addresses.find(symbol_stub_addr) ==
4486 resolver_addresses.end())
4487 sym[sym_idx].SetType(eSymbolTypeTrampoline);
4488 else
4489 sym[sym_idx].SetType(eSymbolTypeResolver);
4490 sym[sym_idx].SetIsSynthetic(true);
4491 sym[sym_idx].GetAddressRef() = so_addr;
4492 add_symbol_addr(so_addr.GetFileAddress());
4493 sym[sym_idx].SetByteSize(symbol_stub_byte_size);
4494 ++sym_idx;
4495 }
4496 } else {
4497 if (log)
4498 log->Warning("symbol stub referencing symbol table symbol "
4499 "%u that isn't in our minimal symbol table, "
4500 "fix this!!!",
4501 stub_sym_id);
4502 }
4503 }
4504 }
4505 }
4506 }
4507 }
4508 }
4509
4510 if (!reexport_trie_entries.empty()) {
4511 for (const auto &e : reexport_trie_entries) {
4512 if (e.entry.import_name) {
4513 // Only add indirect symbols from the Trie entries if we didn't have
4514 // a N_INDR nlist entry for this already
4515 if (indirect_symbol_names.find(e.entry.name) ==
4516 indirect_symbol_names.end()) {
4517 // Make a synthetic symbol to describe re-exported symbol.
4518 if (sym_idx >= num_syms)
4519 sym = symtab.Resize(++num_syms);
4520 sym[sym_idx].SetID(synthetic_sym_id++);
4521 sym[sym_idx].GetMangled() = Mangled(e.entry.name);
4522 sym[sym_idx].SetType(eSymbolTypeReExported);
4523 sym[sym_idx].SetIsSynthetic(true);
4524 sym[sym_idx].SetReExportedSymbolName(e.entry.import_name);
4525 if (e.entry.other > 0 && e.entry.other <= dylib_files.GetSize()) {
4527 dylib_files.GetFileSpecAtIndex(e.entry.other - 1));
4528 }
4529 ++sym_idx;
4530 }
4531 }
4532 }
4533 }
4534}
4535
4537 ModuleSP module_sp(GetModule());
4538 if (module_sp) {
4539 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
4540 s->Printf("%p: ", static_cast<void *>(this));
4541 s->Indent();
4542 if (m_header.magic == MH_MAGIC_64 || m_header.magic == MH_CIGAM_64)
4543 s->PutCString("ObjectFileMachO64");
4544 else
4545 s->PutCString("ObjectFileMachO32");
4546
4547 *s << ", file = '" << m_file;
4548 ModuleSpecList all_specs;
4549 ModuleSpec base_spec;
4551 base_spec, all_specs);
4552 for (unsigned i = 0, e = all_specs.GetSize(); i != e; ++i) {
4553 *s << "', triple";
4554 if (e)
4555 s->Printf("[%d]", i);
4556 *s << " = ";
4557 *s << all_specs.GetModuleSpecRefAtIndex(i)
4559 .GetTriple()
4560 .getTriple();
4561 }
4562 *s << "\n";
4563 SectionList *sections = GetSectionList();
4564 if (sections)
4565 sections->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true,
4566 UINT32_MAX);
4567
4568 if (m_symtab_up)
4569 m_symtab_up->Dump(s, nullptr, eSortOrderNone);
4570 }
4571}
4572
4573UUID ObjectFileMachO::GetUUID(const llvm::MachO::mach_header &header,
4574 const lldb_private::DataExtractor &data,
4575 lldb::offset_t lc_offset) {
4576 uint32_t i;
4577 llvm::MachO::uuid_command load_cmd;
4578
4579 lldb::offset_t offset = lc_offset;
4580 for (i = 0; i < header.ncmds; ++i) {
4581 const lldb::offset_t cmd_offset = offset;
4582 if (data.GetU32(&offset, &load_cmd, 2) == nullptr)
4583 break;
4584
4585 if (load_cmd.cmd == LC_UUID) {
4586 const uint8_t *uuid_bytes = data.PeekData(offset, 16);
4587
4588 if (uuid_bytes) {
4589 // OpenCL on Mac OS X uses the same UUID for each of its object files.
4590 // We pretend these object files have no UUID to prevent crashing.
4591
4592 const uint8_t opencl_uuid[] = {0x8c, 0x8e, 0xb3, 0x9b, 0x3b, 0xa8,
4593 0x4b, 0x16, 0xb6, 0xa4, 0x27, 0x63,
4594 0xbb, 0x14, 0xf0, 0x0d};
4595
4596 if (!memcmp(uuid_bytes, opencl_uuid, 16))
4597 return UUID();
4598
4599 return UUID(uuid_bytes, 16);
4600 }
4601 return UUID();
4602 }
4603 offset = cmd_offset + load_cmd.cmdsize;
4604 }
4605 return UUID();
4606}
4607
4608static llvm::StringRef GetOSName(uint32_t cmd) {
4609 switch (cmd) {
4610 case llvm::MachO::LC_VERSION_MIN_IPHONEOS:
4611 return llvm::Triple::getOSTypeName(llvm::Triple::IOS);
4612 case llvm::MachO::LC_VERSION_MIN_MACOSX:
4613 return llvm::Triple::getOSTypeName(llvm::Triple::MacOSX);
4614 case llvm::MachO::LC_VERSION_MIN_TVOS:
4615 return llvm::Triple::getOSTypeName(llvm::Triple::TvOS);
4616 case llvm::MachO::LC_VERSION_MIN_WATCHOS:
4617 return llvm::Triple::getOSTypeName(llvm::Triple::WatchOS);
4618 default:
4619 llvm_unreachable("unexpected LC_VERSION load command");
4620 }
4621}
4622
4623namespace {
4624struct OSEnv {
4625 llvm::StringRef os_type;
4626 llvm::StringRef environment;
4627 OSEnv(uint32_t cmd) {
4628 switch (cmd) {
4629 case llvm::MachO::PLATFORM_MACOS:
4630 os_type = llvm::Triple::getOSTypeName(llvm::Triple::MacOSX);
4631 return;
4632 case llvm::MachO::PLATFORM_IOS:
4633 os_type = llvm::Triple::getOSTypeName(llvm::Triple::IOS);
4634 return;
4635 case llvm::MachO::PLATFORM_TVOS:
4636 os_type = llvm::Triple::getOSTypeName(llvm::Triple::TvOS);
4637 return;
4638 case llvm::MachO::PLATFORM_WATCHOS:
4639 os_type = llvm::Triple::getOSTypeName(llvm::Triple::WatchOS);
4640 return;
4641 case llvm::MachO::PLATFORM_BRIDGEOS:
4642 os_type = llvm::Triple::getOSTypeName(llvm::Triple::BridgeOS);
4643 return;
4644 case llvm::MachO::PLATFORM_DRIVERKIT:
4645 os_type = llvm::Triple::getOSTypeName(llvm::Triple::DriverKit);
4646 return;
4647 case llvm::MachO::PLATFORM_MACCATALYST:
4648 os_type = llvm::Triple::getOSTypeName(llvm::Triple::IOS);
4649 environment = llvm::Triple::getEnvironmentTypeName(llvm::Triple::MacABI);
4650 return;
4651 case llvm::MachO::PLATFORM_IOSSIMULATOR:
4652 os_type = llvm::Triple::getOSTypeName(llvm::Triple::IOS);
4653 environment =
4654 llvm::Triple::getEnvironmentTypeName(llvm::Triple::Simulator);
4655 return;
4656 case llvm::MachO::PLATFORM_TVOSSIMULATOR:
4657 os_type = llvm::Triple::getOSTypeName(llvm::Triple::TvOS);
4658 environment =
4659 llvm::Triple::getEnvironmentTypeName(llvm::Triple::Simulator);
4660 return;
4661 case llvm::MachO::PLATFORM_WATCHOSSIMULATOR:
4662 os_type = llvm::Triple::getOSTypeName(llvm::Triple::WatchOS);
4663 environment =
4664 llvm::Triple::getEnvironmentTypeName(llvm::Triple::Simulator);
4665 return;
4666 case llvm::MachO::PLATFORM_XROS:
4667 os_type = llvm::Triple::getOSTypeName(llvm::Triple::XROS);
4668 return;
4669 case llvm::MachO::PLATFORM_XROS_SIMULATOR:
4670 os_type = llvm::Triple::getOSTypeName(llvm::Triple::XROS);
4671 environment =
4672 llvm::Triple::getEnvironmentTypeName(llvm::Triple::Simulator);
4673 return;
4674 default: {
4675 Log *log(GetLog(LLDBLog::Symbols | LLDBLog::Process));
4676 LLDB_LOGF(log, "unsupported platform in LC_BUILD_VERSION");
4677 }
4678 }
4679 }
4680};
4681
4682struct MinOS {
4683 uint32_t major_version, minor_version, patch_version;
4684 MinOS(uint32_t version)
4685 : major_version(version >> 16), minor_version((version >> 8) & 0xffu),
4686 patch_version(version & 0xffu) {}
4687};
4688} // namespace
4689
4690void ObjectFileMachO::GetAllArchSpecs(const llvm::MachO::mach_header &header,
4691 const lldb_private::DataExtractor &data,
4692 lldb::offset_t lc_offset,
4693 ModuleSpec &base_spec,
4694 lldb_private::ModuleSpecList &all_specs) {
4695 auto &base_arch = base_spec.GetArchitecture();
4696 base_arch.SetArchitecture(eArchTypeMachO, header.cputype, header.cpusubtype);
4697 if (!base_arch.IsValid())
4698 return;
4699
4700 bool found_any = false;
4701 auto add_triple = [&](const llvm::Triple &triple) {
4702 auto spec = base_spec;
4703 spec.GetArchitecture().GetTriple() = triple;
4704 if (spec.GetArchitecture().IsValid()) {
4705 spec.GetUUID() = ObjectFileMachO::GetUUID(header, data, lc_offset);
4706 all_specs.Append(spec);
4707 found_any = true;
4708 }
4709 };
4710
4711 // Set OS to an unspecified unknown or a "*" so it can match any OS
4712 llvm::Triple base_triple = base_arch.GetTriple();
4713 base_triple.setOS(llvm::Triple::UnknownOS);
4714 base_triple.setOSName(llvm::StringRef());
4715
4716 if (header.filetype == MH_PRELOAD) {
4717 if (header.cputype == CPU_TYPE_ARM) {
4718 // If this is a 32-bit arm binary, and it's a standalone binary, force
4719 // the Vendor to Apple so we don't accidentally pick up the generic
4720 // armv7 ABI at runtime. Apple's armv7 ABI always uses r7 for the
4721 // frame pointer register; most other armv7 ABIs use a combination of
4722 // r7 and r11.
4723 base_triple.setVendor(llvm::Triple::Apple);
4724 } else {
4725 // Set vendor to an unspecified unknown or a "*" so it can match any
4726 // vendor This is required for correct behavior of EFI debugging on
4727 // x86_64
4728 base_triple.setVendor(llvm::Triple::UnknownVendor);
4729 base_triple.setVendorName(llvm::StringRef());
4730 }
4731 return add_triple(base_triple);
4732 }
4733
4734 llvm::MachO::load_command load_cmd;
4735
4736 // See if there is an LC_VERSION_MIN_* load command that can give
4737 // us the OS type.
4738 lldb::offset_t offset = lc_offset;
4739 for (uint32_t i = 0; i < header.ncmds; ++i) {
4740 const lldb::offset_t cmd_offset = offset;
4741 if (data.GetU32(&offset, &load_cmd, 2) == nullptr)
4742 break;
4743
4744 llvm::MachO::version_min_command version_min;
4745 switch (load_cmd.cmd) {
4746 case llvm::MachO::LC_VERSION_MIN_MACOSX:
4747 case llvm::MachO::LC_VERSION_MIN_IPHONEOS:
4748 case llvm::MachO::LC_VERSION_MIN_TVOS:
4749 case llvm::MachO::LC_VERSION_MIN_WATCHOS: {
4750 if (load_cmd.cmdsize != sizeof(version_min))
4751 break;
4752 if (data.ExtractBytes(cmd_offset, sizeof(version_min),
4753 data.GetByteOrder(), &version_min) == 0)
4754 break;
4755 MinOS min_os(version_min.version);
4756 llvm::SmallString<32> os_name;
4757 llvm::raw_svector_ostream os(os_name);
4758 os << GetOSName(load_cmd.cmd) << min_os.major_version << '.'
4759 << min_os.minor_version << '.' << min_os.patch_version;
4760
4761 auto triple = base_triple;
4762 triple.setOSName(os.str());
4763
4764 // Disambiguate legacy simulator platforms.
4765 if (load_cmd.cmd != llvm::MachO::LC_VERSION_MIN_MACOSX &&
4766 (base_triple.getArch() == llvm::Triple::x86_64 ||
4767 base_triple.getArch() == llvm::Triple::x86)) {
4768 // The combination of legacy LC_VERSION_MIN load command and
4769 // x86 architecture always indicates a simulator environment.
4770 // The combination of LC_VERSION_MIN and arm architecture only
4771 // appears for native binaries. Back-deploying simulator
4772 // binaries on Apple Silicon Macs use the modern unambigous
4773 // LC_BUILD_VERSION load commands; no special handling required.
4774 triple.setEnvironment(llvm::Triple::Simulator);
4775 }
4776 add_triple(triple);
4777 break;
4778 }
4779 default:
4780 break;
4781 }
4782
4783 offset = cmd_offset + load_cmd.cmdsize;
4784 }
4785
4786 // See if there are LC_BUILD_VERSION load commands that can give
4787 // us the OS type.
4788 offset = lc_offset;
4789 for (uint32_t i = 0; i < header.ncmds; ++i) {
4790 const lldb::offset_t cmd_offset = offset;
4791 if (data.GetU32(&offset, &load_cmd, 2) == nullptr)
4792 break;
4793
4794 do {
4795 if (load_cmd.cmd == llvm::MachO::LC_BUILD_VERSION) {
4796 llvm::MachO::build_version_command build_version;
4797 if (load_cmd.cmdsize < sizeof(build_version)) {
4798 // Malformed load command.
4799 break;
4800 }
4801 if (data.ExtractBytes(cmd_offset, sizeof(build_version),
4802 data.GetByteOrder(), &build_version) == 0)
4803 break;
4804 MinOS min_os(build_version.minos);
4805 OSEnv os_env(build_version.platform);
4806 llvm::SmallString<16> os_name;
4807 llvm::raw_svector_ostream os(os_name);
4808 os << os_env.os_type << min_os.major_version << '.'
4809 << min_os.minor_version << '.' << min_os.patch_version;
4810 auto triple = base_triple;
4811 triple.setOSName(os.str());
4812 os_name.clear();
4813 if (!os_env.environment.empty())
4814 triple.setEnvironmentName(os_env.environment);
4815 add_triple(triple);
4816 }
4817 } while (false);
4818 offset = cmd_offset + load_cmd.cmdsize;
4819 }
4820
4821 if (!found_any) {
4822 add_triple(base_triple);
4823 }
4824}
4825
4827 ModuleSP module_sp, const llvm::MachO::mach_header &header,
4828 const lldb_private::DataExtractor &data, lldb::offset_t lc_offset) {
4829 ModuleSpecList all_specs;
4830 ModuleSpec base_spec;
4831 GetAllArchSpecs(header, data, MachHeaderSizeFromMagic(header.magic),
4832 base_spec, all_specs);
4833
4834 // If the object file offers multiple alternative load commands,
4835 // pick the one that matches the module.
4836 if (module_sp) {
4837 const ArchSpec &module_arch = module_sp->GetArchitecture();
4838 for (unsigned i = 0, e = all_specs.GetSize(); i != e; ++i) {
4839 ArchSpec mach_arch =
4841 if (module_arch.IsCompatibleMatch(mach_arch))
4842 return mach_arch;
4843 }
4844 }
4845
4846 // Return the first arch we found.
4847 if (all_specs.GetSize() == 0)
4848 return {};
4849 return all_specs.GetModuleSpecRefAtIndex(0).GetArchitecture();
4850}
4851
4853 ModuleSP module_sp(GetModule());
4854 if (module_sp) {
4855 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
4857 return GetUUID(m_header, m_data, offset);
4858 }
4859 return UUID();
4860}
4861
4863 ModuleSP module_sp = GetModule();
4864 if (!module_sp)
4865 return 0;
4866
4867 uint32_t count = 0;
4868 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
4869 llvm::MachO::load_command load_cmd;
4871 std::vector<std::string> rpath_paths;
4872 std::vector<std::string> rpath_relative_paths;
4873 std::vector<std::string> at_exec_relative_paths;
4874 uint32_t i;
4875 for (i = 0; i < m_header.ncmds; ++i) {
4876 const uint32_t cmd_offset = offset;
4877 if (m_data.GetU32(&offset, &load_cmd, 2) == nullptr)
4878 break;
4879
4880 switch (load_cmd.cmd) {
4881 case LC_RPATH:
4882 case LC_LOAD_DYLIB:
4883 case LC_LOAD_WEAK_DYLIB:
4884 case LC_REEXPORT_DYLIB:
4885 case LC_LOAD_DYLINKER:
4886 case LC_LOADFVMLIB:
4887 case LC_LOAD_UPWARD_DYLIB: {
4888 uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
4889 // For LC_LOAD_DYLIB there is an alternate encoding
4890 // which adds a uint32_t `flags` field for `DYLD_USE_*`
4891 // flags. This can be detected by a timestamp field with
4892 // the `DYLIB_USE_MARKER` constant value.
4893 bool is_delayed_init = false;
4894 uint32_t use_command_marker = m_data.GetU32(&offset);
4895 if (use_command_marker == 0x1a741800 /* DYLIB_USE_MARKER */) {
4896 offset += 4; /* uint32_t current_version */
4897 offset += 4; /* uint32_t compat_version */
4898 uint32_t flags = m_data.GetU32(&offset);
4899 // If this LC_LOAD_DYLIB is marked delay-init,
4900 // don't report it as a dependent library -- it
4901 // may be loaded in the process at some point,
4902 // but will most likely not be load at launch.
4903 if (flags & 0x08 /* DYLIB_USE_DELAYED_INIT */)
4904 is_delayed_init = true;
4905 }
4906 const char *path = m_data.PeekCStr(name_offset);
4907 if (path && !is_delayed_init) {
4908 if (load_cmd.cmd == LC_RPATH)
4909 rpath_paths.push_back(path);
4910 else {
4911 if (path[0] == '@') {
4912 if (strncmp(path, "@rpath", strlen("@rpath")) == 0)
4913 rpath_relative_paths.push_back(path + strlen("@rpath"));
4914 else if (strncmp(path, "@executable_path",
4915 strlen("@executable_path")) == 0)
4916 at_exec_relative_paths.push_back(path +
4917 strlen("@executable_path"));
4918 } else {
4919 FileSpec file_spec(path);
4920 if (files.AppendIfUnique(file_spec))
4921 count++;
4922 }
4923 }
4924 }
4925 } break;
4926
4927 default:
4928 break;
4929 }
4930 offset = cmd_offset + load_cmd.cmdsize;
4931 }
4932
4933 FileSpec this_file_spec(m_file);
4934 FileSystem::Instance().Resolve(this_file_spec);
4935
4936 if (!rpath_paths.empty()) {
4937 // Fixup all LC_RPATH values to be absolute paths.
4938 const std::string this_directory =
4939 this_file_spec.GetDirectory().GetString();
4940 for (auto &rpath : rpath_paths) {
4941 if (llvm::StringRef(rpath).starts_with(g_loader_path))
4942 rpath = this_directory + rpath.substr(g_loader_path.size());
4943 else if (llvm::StringRef(rpath).starts_with(g_executable_path))
4944 rpath = this_directory + rpath.substr(g_executable_path.size());
4945 }
4946
4947 for (const auto &rpath_relative_path : rpath_relative_paths) {
4948 for (const auto &rpath : rpath_paths) {
4949 std::string path = rpath;
4950 path += rpath_relative_path;
4951 // It is OK to resolve this path because we must find a file on disk
4952 // for us to accept it anyway if it is rpath relative.
4953 FileSpec file_spec(path);
4954 FileSystem::Instance().Resolve(file_spec);
4955 if (FileSystem::Instance().Exists(file_spec) &&
4956 files.AppendIfUnique(file_spec)) {
4957 count++;
4958 break;
4959 }
4960 }
4961 }
4962 }
4963
4964 // We may have @executable_paths but no RPATHS. Figure those out here.
4965 // Only do this if this object file is the executable. We have no way to
4966 // get back to the actual executable otherwise, so we won't get the right
4967 // path.
4968 if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
4969 FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
4970 for (const auto &at_exec_relative_path : at_exec_relative_paths) {
4971 FileSpec file_spec =
4972 exec_dir.CopyByAppendingPathComponent(at_exec_relative_path);
4973 if (FileSystem::Instance().Exists(file_spec) &&
4974 files.AppendIfUnique(file_spec))
4975 count++;
4976 }
4977 }
4978 return count;
4979}
4980
4982 // If the object file is not an executable it can't hold the entry point.
4983 // m_entry_point_address is initialized to an invalid address, so we can just
4984 // return that. If m_entry_point_address is valid it means we've found it
4985 // already, so return the cached value.
4986
4987 if ((!IsExecutable() && !IsDynamicLoader()) ||
4988 m_entry_point_address.IsValid()) {
4989 return m_entry_point_address;
4990 }
4991
4992 // Otherwise, look for the UnixThread or Thread command. The data for the
4993 // Thread command is given in /usr/include/mach-o.h, but it is basically:
4994 //
4995 // uint32_t flavor - this is the flavor argument you would pass to
4996 // thread_get_state
4997 // uint32_t count - this is the count of longs in the thread state data
4998 // struct XXX_thread_state state - this is the structure from
4999 // <machine/thread_status.h> corresponding to the flavor.
5000 // <repeat this trio>
5001 //
5002 // So we just keep reading the various register flavors till we find the GPR
5003 // one, then read the PC out of there.
5004 // FIXME: We will need to have a "RegisterContext data provider" class at some
5005 // point that can get all the registers
5006 // out of data in this form & attach them to a given thread. That should
5007 // underlie the MacOS X User process plugin, and we'll also need it for the
5008 // MacOS X Core File process plugin. When we have that we can also use it
5009 // here.
5010 //
5011 // For now we hard-code the offsets and flavors we need:
5012 //
5013 //
5014
5015 ModuleSP module_sp(GetModule());
5016 if (module_sp) {
5017 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5018 llvm::MachO::load_command load_cmd;
5020 uint32_t i;
5021 lldb::addr_t start_address = LLDB_INVALID_ADDRESS;
5022 bool done = false;
5023
5024 for (i = 0; i < m_header.ncmds; ++i) {
5025 const lldb::offset_t cmd_offset = offset;
5026 if (m_data.GetU32(&offset, &load_cmd, 2) == nullptr)
5027 break;
5028
5029 switch (load_cmd.cmd) {
5030 case LC_UNIXTHREAD:
5031 case LC_THREAD: {
5032 while (offset < cmd_offset + load_cmd.cmdsize) {
5033 uint32_t flavor = m_data.GetU32(&offset);
5034 uint32_t count = m_data.GetU32(&offset);
5035 if (count == 0) {
5036 // We've gotten off somehow, log and exit;
5037 return m_entry_point_address;
5038 }
5039
5040 switch (m_header.cputype) {
5041 case llvm::MachO::CPU_TYPE_ARM:
5042 if (flavor == 1 ||
5043 flavor == 9) // ARM_THREAD_STATE/ARM_THREAD_STATE32
5044 // from mach/arm/thread_status.h
5045 {
5046 offset += 60; // This is the offset of pc in the GPR thread state
5047 // data structure.
5048 start_address = m_data.GetU32(&offset);
5049 done = true;
5050 }
5051 break;
5052 case llvm::MachO::CPU_TYPE_ARM64:
5053 case llvm::MachO::CPU_TYPE_ARM64_32:
5054 if (flavor == 6) // ARM_THREAD_STATE64 from mach/arm/thread_status.h
5055 {
5056 offset += 256; // This is the offset of pc in the GPR thread state
5057 // data structure.
5058 start_address = m_data.GetU64(&offset);
5059 done = true;
5060 }
5061 break;
5062 case llvm::MachO::CPU_TYPE_X86_64:
5063 if (flavor ==
5064 4) // x86_THREAD_STATE64 from mach/i386/thread_status.h
5065 {
5066 offset += 16 * 8; // This is the offset of rip in the GPR thread
5067 // state data structure.
5068 start_address = m_data.GetU64(&offset);
5069 done = true;
5070 }
5071 break;
5072 default:
5073 return m_entry_point_address;
5074 }
5075 // Haven't found the GPR flavor yet, skip over the data for this
5076 // flavor:
5077 if (done)
5078 break;
5079 offset += count * 4;
5080 }
5081 } break;
5082 case LC_MAIN: {
5083 uint64_t entryoffset = m_data.GetU64(&offset);
5084 SectionSP text_segment_sp =
5086 if (text_segment_sp) {
5087 done = true;
5088 start_address = text_segment_sp->GetFileAddress() + entryoffset;
5089 }
5090 } break;
5091
5092 default:
5093 break;
5094 }
5095 if (done)
5096 break;
5097
5098 // Go to the next load command:
5099 offset = cmd_offset + load_cmd.cmdsize;
5100 }
5101
5102 if (start_address == LLDB_INVALID_ADDRESS && IsDynamicLoader()) {
5103 if (GetSymtab()) {
5104 Symbol *dyld_start_sym = GetSymtab()->FindFirstSymbolWithNameAndType(
5107 if (dyld_start_sym && dyld_start_sym->GetAddress().IsValid()) {
5108 start_address = dyld_start_sym->GetAddress().GetFileAddress();
5109 }
5110 }
5111 }
5112
5113 if (start_address != LLDB_INVALID_ADDRESS) {
5114 // We got the start address from the load commands, so now resolve that
5115 // address in the sections of this ObjectFile:
5116 if (!m_entry_point_address.ResolveAddressUsingFileSections(
5117 start_address, GetSectionList())) {
5118 m_entry_point_address.Clear();
5119 }
5120 } else {
5121 // We couldn't read the UnixThread load command - maybe it wasn't there.
5122 // As a fallback look for the "start" symbol in the main executable.
5123
5124 ModuleSP module_sp(GetModule());
5125
5126 if (module_sp) {
5127 SymbolContextList contexts;
5128 SymbolContext context;
5129 module_sp->FindSymbolsWithNameAndType(ConstString("start"),
5130 eSymbolTypeCode, contexts);
5131 if (contexts.GetSize()) {
5132 if (contexts.GetContextAtIndex(0, context))
5134 }
5135 }
5136 }
5137 }
5138
5139 return m_entry_point_address;
5140}
5141
5143 lldb_private::Address header_addr;
5144 SectionList *section_list = GetSectionList();
5145 if (section_list) {
5146 SectionSP text_segment_sp(
5147 section_list->FindSectionByName(GetSegmentNameTEXT()));
5148 if (text_segment_sp) {
5149 header_addr.SetSection(text_segment_sp);
5150 header_addr.SetOffset(0);
5151 }
5152 }
5153 return header_addr;
5154}
5155
5157 ModuleSP module_sp(GetModule());
5158 if (module_sp) {
5159 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5163 FileRangeArray::Entry file_range;
5164 llvm::MachO::thread_command thread_cmd;
5165 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
5166 const uint32_t cmd_offset = offset;
5167 if (m_data.GetU32(&offset, &thread_cmd, 2) == nullptr)
5168 break;
5169
5170 if (thread_cmd.cmd == LC_THREAD) {
5171 file_range.SetRangeBase(offset);
5172 file_range.SetByteSize(thread_cmd.cmdsize - 8);
5173 m_thread_context_offsets.Append(file_range);
5174 }
5175 offset = cmd_offset + thread_cmd.cmdsize;
5176 }
5177 }
5178 }
5179 return m_thread_context_offsets.GetSize();
5180}
5181
5182std::vector<std::tuple<offset_t, offset_t>>
5184 std::vector<std::tuple<offset_t, offset_t>> results;
5185 ModuleSP module_sp(GetModule());
5186 if (module_sp) {
5187 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5188
5190 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
5191 const uint32_t cmd_offset = offset;
5192 llvm::MachO::load_command lc = {};
5193 if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
5194 break;
5195 if (lc.cmd == LC_NOTE) {
5196 char data_owner[17];
5197 m_data.CopyData(offset, 16, data_owner);
5198 data_owner[16] = '\0';
5199 offset += 16;
5200
5201 if (name == data_owner) {
5202 offset_t payload_offset = m_data.GetU64_unchecked(&offset);
5203 offset_t payload_size = m_data.GetU64_unchecked(&offset);
5204 results.push_back({payload_offset, payload_size});
5205 }
5206 }
5207 offset = cmd_offset + lc.cmdsize;
5208 }
5209 }
5210 return results;
5211}
5212
5214 Log *log(
5216 ModuleSP module_sp(GetModule());
5217 if (module_sp) {
5218 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5219
5220 auto lc_notes = FindLC_NOTEByName("kern ver str");
5221 for (auto lc_note : lc_notes) {
5222 offset_t payload_offset = std::get<0>(lc_note);
5223 offset_t payload_size = std::get<1>(lc_note);
5224 uint32_t version;
5225 if (m_data.GetU32(&payload_offset, &version, 1) != nullptr) {
5226 if (version == 1) {
5227 uint32_t strsize = payload_size - sizeof(uint32_t);
5228 std::string result(strsize, '\0');
5229 m_data.CopyData(payload_offset, strsize, result.data());
5230 LLDB_LOGF(log, "LC_NOTE 'kern ver str' found with text '%s'",
5231 result.c_str());
5232 return result;
5233 }
5234 }
5235 }
5236
5237 // Second, make a pass over the load commands looking for an obsolete
5238 // LC_IDENT load command.
5240 for (uint32_t i = 0; i < m_header.ncmds; ++i) {
5241 const uint32_t cmd_offset = offset;
5242 llvm::MachO::ident_command ident_command;
5243 if (m_data.GetU32(&offset, &ident_command, 2) == nullptr)
5244 break;
5245 if (ident_command.cmd == LC_IDENT && ident_command.cmdsize != 0) {
5246 std::string result(ident_command.cmdsize, '\0');
5247 if (m_data.CopyData(offset, ident_command.cmdsize, result.data()) ==
5248 ident_command.cmdsize) {
5249 LLDB_LOGF(log, "LC_IDENT found with text '%s'", result.c_str());
5250 return result;
5251 }
5252 }
5253 offset = cmd_offset + ident_command.cmdsize;
5254 }
5255 }
5256 return {};
5257}
5258
5260 AddressableBits addressable_bits;
5261
5263 ModuleSP module_sp(GetModule());
5264 if (module_sp) {
5265 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5266 auto lc_notes = FindLC_NOTEByName("addrable bits");
5267 for (auto lc_note : lc_notes) {
5268 offset_t payload_offset = std::get<0>(lc_note);
5269 uint32_t version;
5270 if (m_data.GetU32(&payload_offset, &version, 1) != nullptr) {
5271 if (version == 3) {
5272 uint32_t num_addr_bits = m_data.GetU32_unchecked(&payload_offset);
5273 addressable_bits.SetAddressableBits(num_addr_bits);
5274 LLDB_LOGF(log,
5275 "LC_NOTE 'addrable bits' v3 found, value %d "
5276 "bits",
5277 num_addr_bits);
5278 }
5279 if (version == 4) {
5280 uint32_t lo_addr_bits = m_data.GetU32_unchecked(&payload_offset);
5281 uint32_t hi_addr_bits = m_data.GetU32_unchecked(&payload_offset);
5282
5283 if (lo_addr_bits == hi_addr_bits)
5284 addressable_bits.SetAddressableBits(lo_addr_bits);
5285 else
5286 addressable_bits.SetAddressableBits(lo_addr_bits, hi_addr_bits);
5287 LLDB_LOGF(log, "LC_NOTE 'addrable bits' v4 found, value %d & %d bits",
5288 lo_addr_bits, hi_addr_bits);
5289 }
5290 }
5291 }
5292 }
5293 return addressable_bits;
5294}
5295
5297 bool &value_is_offset,
5298 UUID &uuid,
5299 ObjectFile::BinaryType &type) {
5300 Log *log(
5302 value = LLDB_INVALID_ADDRESS;
5303 value_is_offset = false;
5304 uuid.Clear();
5305 uint32_t log2_pagesize = 0; // not currently passed up to caller
5306 uint32_t platform = 0; // not currently passed up to caller
5307 ModuleSP module_sp(GetModule());
5308 if (module_sp) {
5309 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5310
5311 auto lc_notes = FindLC_NOTEByName("main bin spec");
5312 for (auto lc_note : lc_notes) {
5313 offset_t payload_offset = std::get<0>(lc_note);
5314
5315 // struct main_bin_spec
5316 // {
5317 // uint32_t version; // currently 2
5318 // uint32_t type; // 0 == unspecified,
5319 // // 1 == kernel
5320 // // 2 == user process,
5321 // dyld mach-o binary addr
5322 // // 3 == standalone binary
5323 // // 4 == user process,
5324 // // dyld_all_image_infos addr
5325 // uint64_t address; // UINT64_MAX if address not specified
5326 // uint64_t slide; // slide, UINT64_MAX if unspecified
5327 // // 0 if no slide needs to be applied to
5328 // // file address
5329 // uuid_t uuid; // all zero's if uuid not specified
5330 // uint32_t log2_pagesize; // process page size in log base 2,
5331 // // e.g. 4k pages are 12.
5332 // // 0 for unspecified
5333 // uint32_t platform; // The Mach-O platform for this corefile.
5334 // // 0 for unspecified.
5335 // // The values are defined in
5336 // // <mach-o/loader.h>, PLATFORM_*.
5337 // } __attribute((packed));
5338
5339 // "main bin spec" (main binary specification) data payload is
5340 // formatted:
5341 // uint32_t version [currently 1]
5342 // uint32_t type [0 == unspecified, 1 == kernel,
5343 // 2 == user process, 3 == firmware ]
5344 // uint64_t address [ UINT64_MAX if address not specified ]
5345 // uuid_t uuid [ all zero's if uuid not specified ]
5346 // uint32_t log2_pagesize [ process page size in log base
5347 // 2, e.g. 4k pages are 12.
5348 // 0 for unspecified ]
5349 // uint32_t unused [ for alignment ]
5350
5351 uint32_t version;
5352 if (m_data.GetU32(&payload_offset, &version, 1) != nullptr &&
5353 version <= 2) {
5354 uint32_t binspec_type = 0;
5355 uuid_t raw_uuid;
5356 memset(raw_uuid, 0, sizeof(uuid_t));
5357
5358 if (!m_data.GetU32(&payload_offset, &binspec_type, 1))
5359 return false;
5360 if (!m_data.GetU64(&payload_offset, &value, 1))
5361 return false;
5362 uint64_t slide = LLDB_INVALID_ADDRESS;
5363 if (version > 1 && !m_data.GetU64(&payload_offset, &slide, 1))
5364 return false;
5365 if (value == LLDB_INVALID_ADDRESS && slide != LLDB_INVALID_ADDRESS) {
5366 value = slide;
5367 value_is_offset = true;
5368 }
5369
5370 if (m_data.CopyData(payload_offset, sizeof(uuid_t), raw_uuid) != 0) {
5371 uuid = UUID(raw_uuid, sizeof(uuid_t));
5372 // convert the "main bin spec" type into our
5373 // ObjectFile::BinaryType enum
5374 const char *typestr = "unrecognized type";
5375 type = eBinaryTypeInvalid;
5376 switch (binspec_type) {
5377 case 0:
5378 type = eBinaryTypeUnknown;
5379 typestr = "uknown";
5380 break;
5381 case 1:
5382 type = eBinaryTypeKernel;
5383 typestr = "xnu kernel";
5384 break;
5385 case 2:
5386 type = eBinaryTypeUser;
5387 typestr = "userland dyld";
5388 break;
5389 case 3:
5390 type = eBinaryTypeStandalone;
5391 typestr = "standalone";
5392 break;
5393 case 4:
5395 typestr = "userland dyld_all_image_infos";
5396 break;
5397 }
5398 LLDB_LOGF(log,
5399 "LC_NOTE 'main bin spec' found, version %d type %d "
5400 "(%s), value 0x%" PRIx64 " value-is-slide==%s uuid %s",
5401 version, type, typestr, value,
5402 value_is_offset ? "true" : "false",
5403 uuid.GetAsString().c_str());
5404 if (!m_data.GetU32(&payload_offset, &log2_pagesize, 1))
5405 return false;
5406 if (version > 1 && !m_data.GetU32(&payload_offset, &platform, 1))
5407 return false;
5408 return true;
5409 }
5410 }
5411 }
5412 }
5413 return false;
5414}
5415
5417 std::vector<lldb::tid_t> &tids) {
5418 tids.clear();
5419 ModuleSP module_sp(GetModule());
5420 if (module_sp) {
5421 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5422
5425 StructuredData::Dictionary *dict = object_sp->GetAsDictionary();
5426 StructuredData::Array *threads;
5427 if (!dict->GetValueForKeyAsArray("threads", threads) || !threads) {
5428 LLDB_LOGF(log,
5429 "'process metadata' LC_NOTE does not have a 'threads' key");
5430 return false;
5431 }
5432 if (threads->GetSize() != GetNumThreadContexts()) {
5433 LLDB_LOGF(log, "Unable to read 'process metadata' LC_NOTE, number of "
5434 "threads does not match number of LC_THREADS.");
5435 return false;
5436 }
5437 const size_t num_threads = threads->GetSize();
5438 for (size_t i = 0; i < num_threads; i++) {
5439 std::optional<StructuredData::Dictionary *> maybe_thread =
5440 threads->GetItemAtIndexAsDictionary(i);
5441 if (!maybe_thread) {
5442 LLDB_LOGF(log,
5443 "Unable to read 'process metadata' LC_NOTE, threads "
5444 "array does not have a dictionary at index %zu.",
5445 i);
5446 return false;
5447 }
5448 StructuredData::Dictionary *thread = *maybe_thread;
5450 if (thread->GetValueForKeyAsInteger<lldb::tid_t>("thread_id", tid))
5451 if (tid == 0)
5453 tids.push_back(tid);
5454 }
5455
5456 if (log) {
5457 StreamString logmsg;
5458 logmsg.Printf("LC_NOTE 'process metadata' found: ");
5459 dict->Dump(logmsg, /* pretty_print */ false);
5460 LLDB_LOGF(log, "%s", logmsg.GetData());
5461 }
5462 return true;
5463 }
5464 }
5465 return false;
5466}
5467
5469 ModuleSP module_sp(GetModule());
5470 if (!module_sp)
5471 return {};
5472
5474 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5475 auto lc_notes = FindLC_NOTEByName("process metadata");
5476 if (lc_notes.size() == 0)
5477 return {};
5478
5479 if (lc_notes.size() > 1)
5480 LLDB_LOGF(
5481 log,
5482 "Multiple 'process metadata' LC_NOTEs found, only using the first.");
5483
5484 auto [payload_offset, strsize] = lc_notes[0];
5485 std::string buf(strsize, '\0');
5486 if (m_data.CopyData(payload_offset, strsize, buf.data()) != strsize) {
5487 LLDB_LOGF(log,
5488 "Unable to read %" PRIu64
5489 " bytes of 'process metadata' LC_NOTE JSON contents",
5490 strsize);
5491 return {};
5492 }
5493 while (buf.back() == '\0')
5494 buf.resize(buf.size() - 1);
5496 if (!object_sp) {
5497 LLDB_LOGF(log, "Unable to read 'process metadata' LC_NOTE, did not "
5498 "parse as valid JSON.");
5499 return {};
5500 }
5501 StructuredData::Dictionary *dict = object_sp->GetAsDictionary();
5502 if (!dict) {
5503 LLDB_LOGF(log, "Unable to read 'process metadata' LC_NOTE, did not "
5504 "get a dictionary.");
5505 return {};
5506 }
5507
5508 return object_sp;
5509}
5510
5513 lldb_private::Thread &thread) {
5514 lldb::RegisterContextSP reg_ctx_sp;
5515
5516 ModuleSP module_sp(GetModule());
5517 if (module_sp) {
5518 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5521
5522 const FileRangeArray::Entry *thread_context_file_range =
5523 m_thread_context_offsets.GetEntryAtIndex(idx);
5524 if (thread_context_file_range) {
5525
5526 DataExtractor data(m_data, thread_context_file_range->GetRangeBase(),
5527 thread_context_file_range->GetByteSize());
5528
5529 switch (m_header.cputype) {
5530 case llvm::MachO::CPU_TYPE_ARM64:
5531 case llvm::MachO::CPU_TYPE_ARM64_32:
5532 reg_ctx_sp =
5533 std::make_shared<RegisterContextDarwin_arm64_Mach>(thread, data);
5534 break;
5535
5536 case llvm::MachO::CPU_TYPE_ARM:
5537 reg_ctx_sp =
5538 std::make_shared<RegisterContextDarwin_arm_Mach>(thread, data);
5539 break;
5540
5541 case llvm::MachO::CPU_TYPE_X86_64:
5542 reg_ctx_sp =
5543 std::make_shared<RegisterContextDarwin_x86_64_Mach>(thread, data);
5544 break;
5545
5546 case llvm::MachO::CPU_TYPE_RISCV:
5547 reg_ctx_sp =
5548 std::make_shared<RegisterContextDarwin_riscv32_Mach>(thread, data);
5549 break;
5550 }
5551 }
5552 }
5553 return reg_ctx_sp;
5554}
5555
5557 switch (m_header.filetype) {
5558 case MH_OBJECT: // 0x1u
5559 if (GetAddressByteSize() == 4) {
5560 // 32 bit kexts are just object files, but they do have a valid
5561 // UUID load command.
5562 if (GetUUID()) {
5563 // this checking for the UUID load command is not enough we could
5564 // eventually look for the symbol named "OSKextGetCurrentIdentifier" as
5565 // this is required of kexts
5566 if (m_strata == eStrataInvalid)
5568 return eTypeSharedLibrary;
5569 }
5570 }
5571 return eTypeObjectFile;
5572
5573 case MH_EXECUTE:
5574 return eTypeExecutable; // 0x2u
5575 case MH_FVMLIB:
5576 return eTypeSharedLibrary; // 0x3u
5577 case MH_CORE:
5578 return eTypeCoreFile; // 0x4u
5579 case MH_PRELOAD:
5580 return eTypeSharedLibrary; // 0x5u
5581 case MH_DYLIB:
5582 return eTypeSharedLibrary; // 0x6u
5583 case MH_DYLINKER:
5584 return eTypeDynamicLinker; // 0x7u
5585 case MH_BUNDLE:
5586 return eTypeSharedLibrary; // 0x8u
5587 case MH_DYLIB_STUB:
5588 return eTypeStubLibrary; // 0x9u
5589 case MH_DSYM:
5590 return eTypeDebugInfo; // 0xAu
5591 case MH_KEXT_BUNDLE:
5592 return eTypeSharedLibrary; // 0xBu
5593 default:
5594 break;
5595 }
5596 return eTypeUnknown;
5597}
5598
5600 switch (m_header.filetype) {
5601 case MH_OBJECT: // 0x1u
5602 {
5603 // 32 bit kexts are just object files, but they do have a valid
5604 // UUID load command.
5605 if (GetUUID()) {
5606 // this checking for the UUID load command is not enough we could
5607 // eventually look for the symbol named "OSKextGetCurrentIdentifier" as
5608 // this is required of kexts
5609 if (m_type == eTypeInvalid)
5611
5612 return eStrataKernel;
5613 }
5614 }
5615 return eStrataUnknown;
5616
5617 case MH_EXECUTE: // 0x2u
5618 // Check for the MH_DYLDLINK bit in the flags
5619 if (m_header.flags & MH_DYLDLINK) {
5620 return eStrataUser;
5621 } else {
5622 SectionList *section_list = GetSectionList();
5623 if (section_list) {
5624 static ConstString g_kld_section_name("__KLD");
5625 if (section_list->FindSectionByName(g_kld_section_name))
5626 return eStrataKernel;
5627 }
5628 }
5629 return eStrataRawImage;
5630
5631 case MH_FVMLIB:
5632 return eStrataUser; // 0x3u
5633 case MH_CORE:
5634 return eStrataUnknown; // 0x4u
5635 case MH_PRELOAD:
5636 return eStrataRawImage; // 0x5u
5637 case MH_DYLIB:
5638 return eStrataUser; // 0x6u
5639 case MH_DYLINKER:
5640 return eStrataUser; // 0x7u
5641 case MH_BUNDLE:
5642 return eStrataUser; // 0x8u
5643 case MH_DYLIB_STUB:
5644 return eStrataUser; // 0x9u
5645 case MH_DSYM:
5646 return eStrataUnknown; // 0xAu
5647 case MH_KEXT_BUNDLE:
5648 return eStrataKernel; // 0xBu
5649 default:
5650 break;
5651 }
5652 return eStrataUnknown;
5653}
5654
5655llvm::VersionTuple ObjectFileMachO::GetVersion() {
5656 ModuleSP module_sp(GetModule());
5657 if (module_sp) {
5658 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5659 llvm::MachO::dylib_command load_cmd;
5661 uint32_t version_cmd = 0;
5662 uint64_t version = 0;
5663 uint32_t i;
5664 for (i = 0; i < m_header.ncmds; ++i) {
5665 const lldb::offset_t cmd_offset = offset;
5666 if (m_data.GetU32(&offset, &load_cmd, 2) == nullptr)
5667 break;
5668
5669 if (load_cmd.cmd == LC_ID_DYLIB) {
5670 if (version_cmd == 0) {
5671 version_cmd = load_cmd.cmd;
5672 if (m_data.GetU32(&offset, &load_cmd.dylib, 4) == nullptr)
5673 break;
5674 version = load_cmd.dylib.current_version;
5675 }
5676 break; // Break for now unless there is another more complete version
5677 // number load command in the future.
5678 }
5679 offset = cmd_offset + load_cmd.cmdsize;
5680 }
5681
5682 if (version_cmd == LC_ID_DYLIB) {
5683 unsigned major = (version & 0xFFFF0000ull) >> 16;
5684 unsigned minor = (version & 0x0000FF00ull) >> 8;
5685 unsigned subminor = (version & 0x000000FFull);
5686 return llvm::VersionTuple(major, minor, subminor);
5687 }
5688 }
5689 return llvm::VersionTuple();
5690}
5691
5693 ModuleSP module_sp(GetModule());
5694 ArchSpec arch;
5695 if (module_sp) {
5696 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
5697
5698 return GetArchitecture(module_sp, m_header, m_data,
5700 }
5701 return arch;
5702}
5703
5705 addr_t &base_addr, UUID &uuid) {
5706 uuid.Clear();
5707 base_addr = LLDB_INVALID_ADDRESS;
5708 if (process && process->GetDynamicLoader()) {
5709 DynamicLoader *dl = process->GetDynamicLoader();
5710 LazyBool using_shared_cache;
5711 LazyBool private_shared_cache;
5712 dl->GetSharedCacheInformation(base_addr, uuid, using_shared_cache,
5713 private_shared_cache);
5714 }
5716 LLDB_LOGF(
5717 log,
5718 "inferior process shared cache has a UUID of %s, base address 0x%" PRIx64,
5719 uuid.GetAsString().c_str(), base_addr);
5720}
5721
5722// From dyld SPI header dyld_process_info.h
5723typedef void *dyld_process_info;
5725 uuid_t cacheUUID; // UUID of cache used by process
5726 uint64_t cacheBaseAddress; // load address of dyld shared cache
5727 bool noCache; // process is running without a dyld cache
5728 bool privateCache; // process is using a private copy of its dyld cache
5729};
5730
5731// #including mach/mach.h pulls in machine.h & CPU_TYPE_ARM etc conflicts with
5732// llvm enum definitions llvm::MachO::CPU_TYPE_ARM turning them into compile
5733// errors. So we need to use the actual underlying types of task_t and
5734// kern_return_t below.
5735extern "C" unsigned int /*task_t*/ mach_task_self();
5736
5738 uuid.Clear();
5739 base_addr = LLDB_INVALID_ADDRESS;
5740
5741#if defined(__APPLE__)
5742 uint8_t *(*dyld_get_all_image_infos)(void);
5743 dyld_get_all_image_infos =
5744 (uint8_t * (*)()) dlsym(RTLD_DEFAULT, "_dyld_get_all_image_infos");
5745 if (dyld_get_all_image_infos) {
5746 uint8_t *dyld_all_image_infos_address = dyld_get_all_image_infos();
5747 if (dyld_all_image_infos_address) {
5748 uint32_t *version = (uint32_t *)
5749 dyld_all_image_infos_address; // version <mach-o/dyld_images.h>
5750 if (*version >= 13) {
5751 uuid_t *sharedCacheUUID_address = 0;
5752 int wordsize = sizeof(uint8_t *);
5753 if (wordsize == 8) {
5754 sharedCacheUUID_address =
5755 (uuid_t *)((uint8_t *)dyld_all_image_infos_address +
5756 160); // sharedCacheUUID <mach-o/dyld_images.h>
5757 if (*version >= 15)
5758 base_addr =
5759 *(uint64_t
5760 *)((uint8_t *)dyld_all_image_infos_address +
5761 176); // sharedCacheBaseAddress <mach-o/dyld_images.h>
5762 } else {
5763 sharedCacheUUID_address =
5764 (uuid_t *)((uint8_t *)dyld_all_image_infos_address +
5765 84); // sharedCacheUUID <mach-o/dyld_images.h>
5766 if (*version >= 15) {
5767 base_addr = 0;
5768 base_addr =
5769 *(uint32_t
5770 *)((uint8_t *)dyld_all_image_infos_address +
5771 100); // sharedCacheBaseAddress <mach-o/dyld_images.h>
5772 }
5773 }
5774 uuid = UUID(sharedCacheUUID_address, sizeof(uuid_t));
5775 }
5776 }
5777 } else {
5778 // Exists in macOS 10.12 and later, iOS 10.0 and later - dyld SPI
5779 dyld_process_info (*dyld_process_info_create)(
5780 unsigned int /* task_t */ task, uint64_t timestamp,
5781 unsigned int /*kern_return_t*/ *kernelError);
5782 void (*dyld_process_info_get_cache)(void *info, void *cacheInfo);
5783 void (*dyld_process_info_release)(dyld_process_info info);
5784
5785 dyld_process_info_create = (void *(*)(unsigned int /* task_t */, uint64_t,
5786 unsigned int /*kern_return_t*/ *))
5787 dlsym(RTLD_DEFAULT, "_dyld_process_info_create");
5788 dyld_process_info_get_cache = (void (*)(void *, void *))dlsym(
5789 RTLD_DEFAULT, "_dyld_process_info_get_cache");
5790 dyld_process_info_release =
5791 (void (*)(void *))dlsym(RTLD_DEFAULT, "_dyld_process_info_release");
5792
5793 if (dyld_process_info_create && dyld_process_info_get_cache) {
5794 unsigned int /*kern_return_t */ kern_ret;
5795 dyld_process_info process_info =
5796 dyld_process_info_create(::mach_task_self(), 0, &kern_ret);
5797 if (process_info) {
5799 memset(&sc_info, 0, sizeof(struct lldb_copy__dyld_process_cache_info));
5800 dyld_process_info_get_cache(process_info, &sc_info);
5801 if (sc_info.cacheBaseAddress != 0) {
5802 base_addr = sc_info.cacheBaseAddress;
5803 uuid = UUID(sc_info.cacheUUID, sizeof(uuid_t));
5804 }
5805 dyld_process_info_release(process_info);
5806 }
5807 }
5808 }
5810 if (log && uuid.IsValid())
5811 LLDB_LOGF(log,
5812 "lldb's in-memory shared cache has a UUID of %s base address of "
5813 "0x%" PRIx64,
5814 uuid.GetAsString().c_str(), base_addr);
5815#endif
5816}
5817
5818static llvm::VersionTuple FindMinimumVersionInfo(DataExtractor &data,
5819 lldb::offset_t offset,
5820 size_t ncmds) {
5821 for (size_t i = 0; i < ncmds; i++) {
5822 const lldb::offset_t load_cmd_offset = offset;
5823 llvm::MachO::load_command lc = {};
5824 if (data.GetU32(&offset, &lc.cmd, 2) == nullptr)
5825 break;
5826
5827 uint32_t version = 0;
5828 if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
5829 lc.cmd == llvm::MachO::LC_VERSION_MIN_IPHONEOS ||
5830 lc.cmd == llvm::MachO::LC_VERSION_MIN_TVOS ||
5831 lc.cmd == llvm::MachO::LC_VERSION_MIN_WATCHOS) {
5832 // struct version_min_command {
5833 // uint32_t cmd; // LC_VERSION_MIN_*
5834 // uint32_t cmdsize;
5835 // uint32_t version; // X.Y.Z encoded in nibbles xxxx.yy.zz
5836 // uint32_t sdk;
5837 // };
5838 // We want to read version.
5839 version = data.GetU32(&offset);
5840 } else if (lc.cmd == llvm::MachO::LC_BUILD_VERSION) {
5841 // struct build_version_command {
5842 // uint32_t cmd; // LC_BUILD_VERSION
5843 // uint32_t cmdsize;
5844 // uint32_t platform;
5845 // uint32_t minos; // X.Y.Z encoded in nibbles xxxx.yy.zz
5846 // uint32_t sdk;
5847 // uint32_t ntools;
5848 // };
5849 // We want to read minos.
5850 offset += sizeof(uint32_t); // Skip over platform
5851 version = data.GetU32(&offset); // Extract minos
5852 }
5853
5854 if (version) {
5855 const uint32_t xxxx = version >> 16;
5856 const uint32_t yy = (version >> 8) & 0xffu;
5857 const uint32_t zz = version & 0xffu;
5858 if (xxxx)
5859 return llvm::VersionTuple(xxxx, yy, zz);
5860 }
5861 offset = load_cmd_offset + lc.cmdsize;
5862 }
5863 return llvm::VersionTuple();
5864}
5865
5872
5879
5881 return m_header.filetype == llvm::MachO::MH_DYLINKER;
5882}
5883
5885 // Dsymutil guarantees that the .debug_aranges accelerator is complete and can
5886 // be trusted by LLDB.
5887 return m_header.filetype == llvm::MachO::MH_DSYM;
5888}
5889
5893
5895 // Find the first address of the mach header which is the first non-zero file
5896 // sized section whose file offset is zero. This is the base file address of
5897 // the mach-o file which can be subtracted from the vmaddr of the other
5898 // segments found in memory and added to the load address
5899 ModuleSP module_sp = GetModule();
5900 if (!module_sp)
5901 return nullptr;
5902 SectionList *section_list = GetSectionList();
5903 if (!section_list)
5904 return nullptr;
5905
5906 // Some binaries can have a TEXT segment with a non-zero file offset.
5907 // Binaries in the shared cache are one example. Some hand-generated
5908 // binaries may not be laid out in the normal TEXT,DATA,LC_SYMTAB order
5909 // in the file, even though they're laid out correctly in vmaddr terms.
5910 SectionSP text_segment_sp =
5911 section_list->FindSectionByName(GetSegmentNameTEXT());
5912 if (text_segment_sp.get() && SectionIsLoadable(text_segment_sp.get()))
5913 return text_segment_sp.get();
5914
5915 const size_t num_sections = section_list->GetSize();
5916 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
5917 Section *section = section_list->GetSectionAtIndex(sect_idx).get();
5918 if (section->GetFileOffset() == 0 && SectionIsLoadable(section))
5919 return section;
5920 }
5921
5922 return nullptr;
5923}
5924
5926 if (!section)
5927 return false;
5928 if (section->IsThreadSpecific())
5929 return false;
5930 if (GetModule().get() != section->GetModule().get())
5931 return false;
5932 // firmware style binaries with llvm gcov segment do
5933 // not have that segment mapped into memory.
5934 if (section->GetName() == GetSegmentNameLLVM_COV()) {
5935 const Strata strata = GetStrata();
5936 if (strata == eStrataKernel || strata == eStrataRawImage)
5937 return false;
5938 }
5939 // Be careful with __LINKEDIT and __DWARF segments
5940 if (section->GetName() == GetSegmentNameLINKEDIT() ||
5941 section->GetName() == GetSegmentNameDWARF()) {
5942 // Only map __LINKEDIT and __DWARF if we have an in memory image and
5943 // this isn't a kernel binary like a kext or mach_kernel.
5944 const bool is_memory_image = (bool)m_process_wp.lock();
5945 const Strata strata = GetStrata();
5946 if (is_memory_image == false || strata == eStrataKernel)
5947 return false;
5948 }
5949 return true;
5950}
5951
5953 lldb::addr_t header_load_address, const Section *header_section,
5954 const Section *section) {
5955 ModuleSP module_sp = GetModule();
5956 if (module_sp && header_section && section &&
5957 header_load_address != LLDB_INVALID_ADDRESS) {
5958 lldb::addr_t file_addr = header_section->GetFileAddress();
5959 if (file_addr != LLDB_INVALID_ADDRESS && SectionIsLoadable(section))
5960 return section->GetFileAddress() - file_addr + header_load_address;
5961 }
5962 return LLDB_INVALID_ADDRESS;
5963}
5964
5966 bool value_is_offset) {
5968 ModuleSP module_sp = GetModule();
5969 if (!module_sp)
5970 return false;
5971
5972 SectionList *section_list = GetSectionList();
5973 if (!section_list)
5974 return false;
5975
5976 size_t num_loaded_sections = 0;
5977 const size_t num_sections = section_list->GetSize();
5978
5979 // Warn if some top-level segments map to the same address. The binary may be
5980 // malformed.
5981 const bool warn_multiple = true;
5982
5983 if (log) {
5984 StreamString logmsg;
5985 logmsg << "ObjectFileMachO::SetLoadAddress ";
5986 if (GetFileSpec())
5987 logmsg << "path='" << GetFileSpec().GetPath() << "' ";
5988 if (GetUUID()) {
5989 logmsg << "uuid=" << GetUUID().GetAsString();
5990 }
5991 LLDB_LOGF(log, "%s", logmsg.GetData());
5992 }
5993 if (value_is_offset) {
5994 // "value" is an offset to apply to each top level segment
5995 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
5996 // Iterate through the object file sections to find all of the
5997 // sections that size on disk (to avoid __PAGEZERO) and load them
5998 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
5999 if (SectionIsLoadable(section_sp.get())) {
6000 LLDB_LOGF(log,
6001 "ObjectFileMachO::SetLoadAddress segment '%s' load addr is "
6002 "0x%" PRIx64,
6003 section_sp->GetName().AsCString(),
6004 section_sp->GetFileAddress() + value);
6005 if (target.SetSectionLoadAddress(section_sp,
6006 section_sp->GetFileAddress() + value,
6007 warn_multiple))
6008 ++num_loaded_sections;
6009 }
6010 }
6011 } else {
6012 // "value" is the new base address of the mach_header, adjust each
6013 // section accordingly
6014
6015 Section *mach_header_section = GetMachHeaderSection();
6016 if (mach_header_section) {
6017 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
6018 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
6019
6020 lldb::addr_t section_load_addr =
6022 value, mach_header_section, section_sp.get());
6023 if (section_load_addr != LLDB_INVALID_ADDRESS) {
6024 LLDB_LOGF(log,
6025 "ObjectFileMachO::SetLoadAddress segment '%s' load addr is "
6026 "0x%" PRIx64,
6027 section_sp->GetName().AsCString(), section_load_addr);
6028 if (target.SetSectionLoadAddress(section_sp, section_load_addr,
6029 warn_multiple))
6030 ++num_loaded_sections;
6031 }
6032 }
6033 }
6034 }
6035 return num_loaded_sections > 0;
6036}
6037
6039 uint32_t version; // currently 1
6040 uint32_t imgcount; // number of binary images
6041 uint64_t entries_fileoff; // file offset in the corefile of where the array of
6042 // struct entry's begin.
6043 uint32_t entries_size; // size of 'struct entry'.
6044 uint32_t unused;
6045};
6046
6048 uint64_t filepath_offset; // offset in corefile to c-string of the file path,
6049 // UINT64_MAX if unavailable.
6050 uuid_t uuid; // uint8_t[16]. should be set to all zeroes if
6051 // uuid is unknown.
6052 uint64_t load_address; // UINT64_MAX if unknown.
6053 uint64_t seg_addrs_offset; // offset to the array of struct segment_vmaddr's.
6054 uint32_t segment_count; // The number of segments for this binary.
6055 uint32_t unused;
6056
6059 memset(&uuid, 0, sizeof(uuid_t));
6060 segment_count = 0;
6063 unused = 0;
6064 }
6067 memcpy(&uuid, &rhs.uuid, sizeof(uuid_t));
6071 unused = rhs.unused;
6072 }
6073};
6074
6076 char segname[16];
6077 uint64_t vmaddr;
6078 uint64_t unused;
6079
6081 memset(&segname, 0, 16);
6083 unused = 0;
6084 }
6086 memcpy(&segname, &rhs.segname, 16);
6087 vmaddr = rhs.vmaddr;
6088 unused = rhs.unused;
6089 }
6090};
6091
6092// Write the payload for the "all image infos" LC_NOTE into
6093// the supplied all_image_infos_payload, assuming that this
6094// will be written into the corefile starting at
6095// initial_file_offset.
6096//
6097// The placement of this payload is a little tricky. We're
6098// laying this out as
6099//
6100// 1. header (struct all_image_info_header)
6101// 2. Array of fixed-size (struct image_entry)'s, one
6102// per binary image present in the process.
6103// 3. Arrays of (struct segment_vmaddr)'s, a varying number
6104// for each binary image.
6105// 4. Variable length c-strings of binary image filepaths,
6106// one per binary.
6107//
6108// To compute where everything will be laid out in the
6109// payload, we need to iterate over the images and calculate
6110// how many segment_vmaddr structures each image will need,
6111// and how long each image's filepath c-string is. There
6112// are some multiple passes over the image list while calculating
6113// everything.
6114
6115static offset_t
6117 offset_t initial_file_offset,
6118 StreamString &all_image_infos_payload,
6120 Target &target = process_sp->GetTarget();
6121 ModuleList modules = target.GetImages();
6122
6123 // stack-only corefiles have no reason to include binaries that
6124 // are not executing; we're trying to make the smallest corefile
6125 // we can, so leave the rest out.
6127 modules.Clear();
6128
6129 std::set<std::string> executing_uuids;
6130 std::vector<ThreadSP> thread_list =
6131 process_sp->CalculateCoreFileThreadList(options);
6132 for (const ThreadSP &thread_sp : thread_list) {
6133 uint32_t stack_frame_count = thread_sp->GetStackFrameCount();
6134 for (uint32_t j = 0; j < stack_frame_count; j++) {
6135 StackFrameSP stack_frame_sp = thread_sp->GetStackFrameAtIndex(j);
6136 Address pc = stack_frame_sp->GetFrameCodeAddress();
6137 ModuleSP module_sp = pc.GetModule();
6138 if (module_sp) {
6139 UUID uuid = module_sp->GetUUID();
6140 if (uuid.IsValid()) {
6141 executing_uuids.insert(uuid.GetAsString());
6142 modules.AppendIfNeeded(module_sp);
6143 }
6144 }
6145 }
6146 }
6147 size_t modules_count = modules.GetSize();
6148
6149 struct all_image_infos_header infos;
6150 infos.version = 1;
6151 infos.imgcount = modules_count;
6152 infos.entries_size = sizeof(image_entry);
6153 infos.entries_fileoff = initial_file_offset + sizeof(all_image_infos_header);
6154 infos.unused = 0;
6155
6156 all_image_infos_payload.PutHex32(infos.version);
6157 all_image_infos_payload.PutHex32(infos.imgcount);
6158 all_image_infos_payload.PutHex64(infos.entries_fileoff);
6159 all_image_infos_payload.PutHex32(infos.entries_size);
6160 all_image_infos_payload.PutHex32(infos.unused);
6161
6162 // First create the structures for all of the segment name+vmaddr vectors
6163 // for each module, so we will know the size of them as we add the
6164 // module entries.
6165 std::vector<std::vector<segment_vmaddr>> modules_segment_vmaddrs;
6166 for (size_t i = 0; i < modules_count; i++) {
6167 ModuleSP module = modules.GetModuleAtIndex(i);
6168
6169 SectionList *sections = module->GetSectionList();
6170 size_t sections_count = sections->GetSize();
6171 std::vector<segment_vmaddr> segment_vmaddrs;
6172 for (size_t j = 0; j < sections_count; j++) {
6173 SectionSP section = sections->GetSectionAtIndex(j);
6174 if (!section->GetParent().get()) {
6175 addr_t vmaddr = section->GetLoadBaseAddress(&target);
6176 if (vmaddr == LLDB_INVALID_ADDRESS)
6177 continue;
6178 ConstString name = section->GetName();
6179 segment_vmaddr seg_vmaddr;
6180 // This is the uncommon case where strncpy is exactly
6181 // the right one, doesn't need to be nul terminated.
6182 // The segment name in a Mach-O LC_SEGMENT/LC_SEGMENT_64 is char[16] and
6183 // is not guaranteed to be nul-terminated if all 16 characters are
6184 // used.
6185 // coverity[buffer_size_warning]
6186 strncpy(seg_vmaddr.segname, name.AsCString(),
6187 sizeof(seg_vmaddr.segname));
6188 seg_vmaddr.vmaddr = vmaddr;
6189 seg_vmaddr.unused = 0;
6190 segment_vmaddrs.push_back(seg_vmaddr);
6191 }
6192 }
6193 modules_segment_vmaddrs.push_back(segment_vmaddrs);
6194 }
6195
6196 offset_t size_of_vmaddr_structs = 0;
6197 for (size_t i = 0; i < modules_segment_vmaddrs.size(); i++) {
6198 size_of_vmaddr_structs +=
6199 modules_segment_vmaddrs[i].size() * sizeof(segment_vmaddr);
6200 }
6201
6202 offset_t size_of_filepath_cstrings = 0;
6203 for (size_t i = 0; i < modules_count; i++) {
6204 ModuleSP module_sp = modules.GetModuleAtIndex(i);
6205 size_of_filepath_cstrings += module_sp->GetFileSpec().GetPath().size() + 1;
6206 }
6207
6208 // Calculate the file offsets of our "all image infos" payload in the
6209 // corefile. initial_file_offset the original value passed in to this method.
6210
6211 offset_t start_of_entries =
6212 initial_file_offset + sizeof(all_image_infos_header);
6213 offset_t start_of_seg_vmaddrs =
6214 start_of_entries + sizeof(image_entry) * modules_count;
6215 offset_t start_of_filenames = start_of_seg_vmaddrs + size_of_vmaddr_structs;
6216
6217 offset_t final_file_offset = start_of_filenames + size_of_filepath_cstrings;
6218
6219 // Now write the one-per-module 'struct image_entry' into the
6220 // StringStream; keep track of where the struct segment_vmaddr
6221 // entries for each module will end up in the corefile.
6222
6223 offset_t current_string_offset = start_of_filenames;
6224 offset_t current_segaddrs_offset = start_of_seg_vmaddrs;
6225 for (size_t i = 0; i < modules_count; i++) {
6226 ModuleSP module_sp = modules.GetModuleAtIndex(i);
6227
6228 struct image_entry ent;
6229 memcpy(&ent.uuid, module_sp->GetUUID().GetBytes().data(), sizeof(ent.uuid));
6230 if (modules_segment_vmaddrs[i].size() > 0) {
6231 ent.segment_count = modules_segment_vmaddrs[i].size();
6232 ent.seg_addrs_offset = current_segaddrs_offset;
6233 }
6234 ent.filepath_offset = current_string_offset;
6235 ObjectFile *objfile = module_sp->GetObjectFile();
6236 if (objfile) {
6237 Address base_addr(objfile->GetBaseAddress());
6238 if (base_addr.IsValid()) {
6239 ent.load_address = base_addr.GetLoadAddress(&target);
6240 }
6241 }
6242
6243 all_image_infos_payload.PutHex64(ent.filepath_offset);
6244 all_image_infos_payload.PutRawBytes(ent.uuid, sizeof(ent.uuid));
6245 all_image_infos_payload.PutHex64(ent.load_address);
6246 all_image_infos_payload.PutHex64(ent.seg_addrs_offset);
6247 all_image_infos_payload.PutHex32(ent.segment_count);
6248
6249 if (executing_uuids.find(module_sp->GetUUID().GetAsString()) !=
6250 executing_uuids.end())
6251 all_image_infos_payload.PutHex32(1);
6252 else
6253 all_image_infos_payload.PutHex32(0);
6254
6255 current_segaddrs_offset += ent.segment_count * sizeof(segment_vmaddr);
6256 current_string_offset += module_sp->GetFileSpec().GetPath().size() + 1;
6257 }
6258
6259 // Now write the struct segment_vmaddr entries into the StringStream.
6260
6261 for (size_t i = 0; i < modules_segment_vmaddrs.size(); i++) {
6262 if (modules_segment_vmaddrs[i].size() == 0)
6263 continue;
6264 for (struct segment_vmaddr segvm : modules_segment_vmaddrs[i]) {
6265 all_image_infos_payload.PutRawBytes(segvm.segname, sizeof(segvm.segname));
6266 all_image_infos_payload.PutHex64(segvm.vmaddr);
6267 all_image_infos_payload.PutHex64(segvm.unused);
6268 }
6269 }
6270
6271 for (size_t i = 0; i < modules_count; i++) {
6272 ModuleSP module_sp = modules.GetModuleAtIndex(i);
6273 std::string filepath = module_sp->GetFileSpec().GetPath();
6274 all_image_infos_payload.PutRawBytes(filepath.data(), filepath.size() + 1);
6275 }
6276
6277 return final_file_offset;
6278}
6279
6280// Temp struct used to combine contiguous memory regions with
6281// identical permissions.
6287
6290 Status &error) {
6291 // The FileSpec and Process are already checked in PluginManager::SaveCore.
6292 assert(options.GetOutputFile().has_value());
6293 assert(process_sp);
6294 const FileSpec outfile = options.GetOutputFile().value();
6295
6296 // MachO defaults to dirty pages
6299
6300 Target &target = process_sp->GetTarget();
6301 const ArchSpec target_arch = target.GetArchitecture();
6302 const llvm::Triple &target_triple = target_arch.GetTriple();
6303 if (target_triple.getVendor() == llvm::Triple::Apple &&
6304 (target_triple.getOS() == llvm::Triple::MacOSX ||
6305 target_triple.getOS() == llvm::Triple::IOS ||
6306 target_triple.getOS() == llvm::Triple::WatchOS ||
6307 target_triple.getOS() == llvm::Triple::TvOS ||
6308 target_triple.getOS() == llvm::Triple::BridgeOS ||
6309 target_triple.getOS() == llvm::Triple::XROS)) {
6310 bool make_core = false;
6311 switch (target_arch.GetMachine()) {
6312 case llvm::Triple::aarch64:
6313 case llvm::Triple::aarch64_32:
6314 case llvm::Triple::arm:
6315 case llvm::Triple::thumb:
6316 case llvm::Triple::x86:
6317 case llvm::Triple::x86_64:
6318 make_core = true;
6319 break;
6320 default:
6322 "unsupported core architecture: %s", target_triple.str().c_str());
6323 break;
6324 }
6325
6326 if (make_core) {
6327 CoreFileMemoryRanges core_ranges;
6328 error = process_sp->CalculateCoreFileSaveRanges(options, core_ranges);
6329 if (error.Success()) {
6330 const uint32_t addr_byte_size = target_arch.GetAddressByteSize();
6331 const ByteOrder byte_order = target_arch.GetByteOrder();
6332 std::vector<llvm::MachO::segment_command_64> segment_load_commands;
6333 for (const auto &core_range_info : core_ranges) {
6334 // TODO: Refactor RangeDataVector to have a data iterator.
6335 const auto &core_range = core_range_info.data;
6336 uint32_t cmd_type = LC_SEGMENT_64;
6337 uint32_t segment_size = sizeof(llvm::MachO::segment_command_64);
6338 if (addr_byte_size == 4) {
6339 cmd_type = LC_SEGMENT;
6340 segment_size = sizeof(llvm::MachO::segment_command);
6341 }
6342 // Skip any ranges with no read/write/execute permissions and empty
6343 // ranges.
6344 if (core_range.lldb_permissions == 0 || core_range.range.size() == 0)
6345 continue;
6346 uint32_t vm_prot = 0;
6347 if (core_range.lldb_permissions & ePermissionsReadable)
6348 vm_prot |= VM_PROT_READ;
6349 if (core_range.lldb_permissions & ePermissionsWritable)
6350 vm_prot |= VM_PROT_WRITE;
6351 if (core_range.lldb_permissions & ePermissionsExecutable)
6352 vm_prot |= VM_PROT_EXECUTE;
6353 const addr_t vm_addr = core_range.range.start();
6354 const addr_t vm_size = core_range.range.size();
6355 llvm::MachO::segment_command_64 segment = {
6356 cmd_type, // uint32_t cmd;
6357 segment_size, // uint32_t cmdsize;
6358 {0}, // char segname[16];
6359 vm_addr, // uint64_t vmaddr; // uint32_t for 32-bit Mach-O
6360 vm_size, // uint64_t vmsize; // uint32_t for 32-bit Mach-O
6361 0, // uint64_t fileoff; // uint32_t for 32-bit Mach-O
6362 vm_size, // uint64_t filesize; // uint32_t for 32-bit Mach-O
6363 vm_prot, // uint32_t maxprot;
6364 vm_prot, // uint32_t initprot;
6365 0, // uint32_t nsects;
6366 0}; // uint32_t flags;
6367 segment_load_commands.push_back(segment);
6368 }
6369
6370 StreamString buffer(Stream::eBinary, addr_byte_size, byte_order);
6371
6372 llvm::MachO::mach_header_64 mach_header;
6373 mach_header.magic = addr_byte_size == 8 ? MH_MAGIC_64 : MH_MAGIC;
6374 mach_header.cputype = target_arch.GetMachOCPUType();
6375 mach_header.cpusubtype = target_arch.GetMachOCPUSubType();
6376 mach_header.filetype = MH_CORE;
6377 mach_header.ncmds = segment_load_commands.size();
6378 mach_header.flags = 0;
6379 mach_header.reserved = 0;
6380 ThreadList &thread_list = process_sp->GetThreadList();
6381 const uint32_t num_threads = thread_list.GetSize();
6382
6383 // Make an array of LC_THREAD data items. Each one contains the
6384 // contents of the LC_THREAD load command. The data doesn't contain
6385 // the load command + load command size, we will add the load command
6386 // and load command size as we emit the data.
6387 std::vector<StreamString> LC_THREAD_datas(num_threads);
6388 for (auto &LC_THREAD_data : LC_THREAD_datas) {
6389 LC_THREAD_data.GetFlags().Set(Stream::eBinary);
6390 LC_THREAD_data.SetAddressByteSize(addr_byte_size);
6391 LC_THREAD_data.SetByteOrder(byte_order);
6392 }
6393 for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
6394 ThreadSP thread_sp(thread_list.GetThreadAtIndex(thread_idx));
6395 if (thread_sp) {
6396 switch (mach_header.cputype) {
6397 case llvm::MachO::CPU_TYPE_ARM64:
6398 case llvm::MachO::CPU_TYPE_ARM64_32:
6400 thread_sp.get(), LC_THREAD_datas[thread_idx]);
6401 break;
6402
6403 case llvm::MachO::CPU_TYPE_ARM:
6405 thread_sp.get(), LC_THREAD_datas[thread_idx]);
6406 break;
6407
6408 case llvm::MachO::CPU_TYPE_X86_64:
6410 thread_sp.get(), LC_THREAD_datas[thread_idx]);
6411 break;
6412
6413 case llvm::MachO::CPU_TYPE_RISCV:
6415 thread_sp.get(), LC_THREAD_datas[thread_idx]);
6416 break;
6417 }
6418 }
6419 }
6420
6421 // The size of the load command is the size of the segments...
6422 if (addr_byte_size == 8) {
6423 mach_header.sizeofcmds = segment_load_commands.size() *
6424 sizeof(llvm::MachO::segment_command_64);
6425 } else {
6426 mach_header.sizeofcmds = segment_load_commands.size() *
6427 sizeof(llvm::MachO::segment_command);
6428 }
6429
6430 // and the size of all LC_THREAD load command
6431 for (const auto &LC_THREAD_data : LC_THREAD_datas) {
6432 ++mach_header.ncmds;
6433 mach_header.sizeofcmds += 8 + LC_THREAD_data.GetSize();
6434 }
6435
6436 // Bits will be set to indicate which bits are NOT used in
6437 // addressing in this process or 0 for unknown.
6438 uint64_t address_mask = process_sp->GetCodeAddressMask();
6439 if (address_mask != LLDB_INVALID_ADDRESS_MASK) {
6440 // LC_NOTE "addrable bits"
6441 mach_header.ncmds++;
6442 mach_header.sizeofcmds += sizeof(llvm::MachO::note_command);
6443 }
6444
6445 // LC_NOTE "process metadata"
6446 mach_header.ncmds++;
6447 mach_header.sizeofcmds += sizeof(llvm::MachO::note_command);
6448
6449 // LC_NOTE "all image infos"
6450 mach_header.ncmds++;
6451 mach_header.sizeofcmds += sizeof(llvm::MachO::note_command);
6452
6453 // Write the mach header
6454 buffer.PutHex32(mach_header.magic);
6455 buffer.PutHex32(mach_header.cputype);
6456 buffer.PutHex32(mach_header.cpusubtype);
6457 buffer.PutHex32(mach_header.filetype);
6458 buffer.PutHex32(mach_header.ncmds);
6459 buffer.PutHex32(mach_header.sizeofcmds);
6460 buffer.PutHex32(mach_header.flags);
6461 if (addr_byte_size == 8) {
6462 buffer.PutHex32(mach_header.reserved);
6463 }
6464
6465 // Skip the mach header and all load commands and align to the next
6466 // 0x1000 byte boundary
6467 addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
6468
6469 file_offset = llvm::alignTo(file_offset, 16);
6470 std::vector<std::unique_ptr<LCNoteEntry>> lc_notes;
6471
6472 // Add "addrable bits" LC_NOTE when an address mask is available
6473 if (address_mask != LLDB_INVALID_ADDRESS_MASK) {
6474 std::unique_ptr<LCNoteEntry> addrable_bits_lcnote_up(
6475 new LCNoteEntry(addr_byte_size, byte_order));
6476 addrable_bits_lcnote_up->name = "addrable bits";
6477 addrable_bits_lcnote_up->payload_file_offset = file_offset;
6478 int bits = std::bitset<64>(~address_mask).count();
6479 addrable_bits_lcnote_up->payload.PutHex32(4); // version
6480 addrable_bits_lcnote_up->payload.PutHex32(
6481 bits); // # of bits used for low addresses
6482 addrable_bits_lcnote_up->payload.PutHex32(
6483 bits); // # of bits used for high addresses
6484 addrable_bits_lcnote_up->payload.PutHex32(0); // reserved
6485
6486 file_offset += addrable_bits_lcnote_up->payload.GetSize();
6487
6488 lc_notes.push_back(std::move(addrable_bits_lcnote_up));
6489 }
6490
6491 // Add "process metadata" LC_NOTE
6492 std::unique_ptr<LCNoteEntry> thread_extrainfo_lcnote_up(
6493 new LCNoteEntry(addr_byte_size, byte_order));
6494 thread_extrainfo_lcnote_up->name = "process metadata";
6495 thread_extrainfo_lcnote_up->payload_file_offset = file_offset;
6496
6498 std::make_shared<StructuredData::Dictionary>());
6500 std::make_shared<StructuredData::Array>());
6501 for (const ThreadSP &thread_sp :
6502 process_sp->CalculateCoreFileThreadList(options)) {
6504 std::make_shared<StructuredData::Dictionary>());
6505 thread->AddIntegerItem("thread_id", thread_sp->GetID());
6506 threads->AddItem(thread);
6507 }
6508 dict->AddItem("threads", threads);
6509 StreamString strm;
6510 dict->Dump(strm, /* pretty */ false);
6511 thread_extrainfo_lcnote_up->payload.PutRawBytes(strm.GetData(),
6512 strm.GetSize());
6513
6514 file_offset += thread_extrainfo_lcnote_up->payload.GetSize();
6515 file_offset = llvm::alignTo(file_offset, 16);
6516 lc_notes.push_back(std::move(thread_extrainfo_lcnote_up));
6517
6518 // Add "all image infos" LC_NOTE
6519 std::unique_ptr<LCNoteEntry> all_image_infos_lcnote_up(
6520 new LCNoteEntry(addr_byte_size, byte_order));
6521 all_image_infos_lcnote_up->name = "all image infos";
6522 all_image_infos_lcnote_up->payload_file_offset = file_offset;
6523 file_offset = CreateAllImageInfosPayload(
6524 process_sp, file_offset, all_image_infos_lcnote_up->payload,
6525 options);
6526 lc_notes.push_back(std::move(all_image_infos_lcnote_up));
6527
6528 // Add LC_NOTE load commands
6529 for (auto &lcnote : lc_notes) {
6530 // Add the LC_NOTE load command to the file.
6531 buffer.PutHex32(LC_NOTE);
6532 buffer.PutHex32(sizeof(llvm::MachO::note_command));
6533 char namebuf[16];
6534 memset(namebuf, 0, sizeof(namebuf));
6535 // This is the uncommon case where strncpy is exactly
6536 // the right one, doesn't need to be nul terminated.
6537 // LC_NOTE name field is char[16] and is not guaranteed to be
6538 // nul-terminated.
6539 // coverity[buffer_size_warning]
6540 strncpy(namebuf, lcnote->name.c_str(), sizeof(namebuf));
6541 buffer.PutRawBytes(namebuf, sizeof(namebuf));
6542 buffer.PutHex64(lcnote->payload_file_offset);
6543 buffer.PutHex64(lcnote->payload.GetSize());
6544 }
6545
6546 // Align to 4096-byte page boundary for the LC_SEGMENTs.
6547 file_offset = llvm::alignTo(file_offset, 4096);
6548
6549 for (auto &segment : segment_load_commands) {
6550 segment.fileoff = file_offset;
6551 file_offset += segment.filesize;
6552 }
6553
6554 // Write out all of the LC_THREAD load commands
6555 for (const auto &LC_THREAD_data : LC_THREAD_datas) {
6556 const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
6557 buffer.PutHex32(LC_THREAD);
6558 buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
6559 buffer.Write(LC_THREAD_data.GetString().data(), LC_THREAD_data_size);
6560 }
6561
6562 // Write out all of the segment load commands
6563 for (const auto &segment : segment_load_commands) {
6564 buffer.PutHex32(segment.cmd);
6565 buffer.PutHex32(segment.cmdsize);
6566 buffer.PutRawBytes(segment.segname, sizeof(segment.segname));
6567 if (addr_byte_size == 8) {
6568 buffer.PutHex64(segment.vmaddr);
6569 buffer.PutHex64(segment.vmsize);
6570 buffer.PutHex64(segment.fileoff);
6571 buffer.PutHex64(segment.filesize);
6572 } else {
6573 buffer.PutHex32(static_cast<uint32_t>(segment.vmaddr));
6574 buffer.PutHex32(static_cast<uint32_t>(segment.vmsize));
6575 buffer.PutHex32(static_cast<uint32_t>(segment.fileoff));
6576 buffer.PutHex32(static_cast<uint32_t>(segment.filesize));
6577 }
6578 buffer.PutHex32(segment.maxprot);
6579 buffer.PutHex32(segment.initprot);
6580 buffer.PutHex32(segment.nsects);
6581 buffer.PutHex32(segment.flags);
6582 }
6583
6584 std::string core_file_path(outfile.GetPath());
6585 auto core_file = FileSystem::Instance().Open(
6588 if (!core_file) {
6589 error = Status::FromError(core_file.takeError());
6590 } else {
6591 // Read 1 page at a time
6592 uint8_t bytes[0x1000];
6593 // Write the mach header and load commands out to the core file
6594 size_t bytes_written = buffer.GetString().size();
6595 error =
6596 core_file.get()->Write(buffer.GetString().data(), bytes_written);
6597 if (error.Success()) {
6598
6599 for (auto &lcnote : lc_notes) {
6600 if (core_file.get()->SeekFromStart(lcnote->payload_file_offset) ==
6601 -1) {
6603 "Unable to seek to corefile pos "
6604 "to write '%s' LC_NOTE payload",
6605 lcnote->name.c_str());
6606 return false;
6607 }
6608 bytes_written = lcnote->payload.GetSize();
6609 error = core_file.get()->Write(lcnote->payload.GetData(),
6610 bytes_written);
6611 if (!error.Success())
6612 return false;
6613 }
6614
6615 // Now write the file data for all memory segments in the process
6616 for (const auto &segment : segment_load_commands) {
6617 if (core_file.get()->SeekFromStart(segment.fileoff) == -1) {
6619 "unable to seek to offset 0x%" PRIx64 " in '%s'",
6620 segment.fileoff, core_file_path.c_str());
6621 break;
6622 }
6623
6624 target.GetDebugger().GetAsyncOutputStream()->Printf(
6625 "Saving %" PRId64
6626 " bytes of data for memory region at 0x%" PRIx64 "\n",
6627 segment.vmsize, segment.vmaddr);
6628 addr_t bytes_left = segment.vmsize;
6629 addr_t addr = segment.vmaddr;
6631 while (bytes_left > 0 && error.Success()) {
6632 const size_t bytes_to_read =
6633 bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
6634
6635 // In a savecore setting, we don't really care about caching,
6636 // as the data is dumped and very likely never read again,
6637 // so we call ReadMemoryFromInferior to bypass it.
6638 const size_t bytes_read = process_sp->ReadMemoryFromInferior(
6639 addr, bytes, bytes_to_read, memory_read_error);
6640
6641 if (bytes_read == bytes_to_read) {
6642 size_t bytes_written = bytes_read;
6643 error = core_file.get()->Write(bytes, bytes_written);
6644 bytes_left -= bytes_read;
6645 addr += bytes_read;
6646 } else {
6647 // Some pages within regions are not readable, those should
6648 // be zero filled
6649 memset(bytes, 0, bytes_to_read);
6650 size_t bytes_written = bytes_to_read;
6651 error = core_file.get()->Write(bytes, bytes_written);
6652 bytes_left -= bytes_to_read;
6653 addr += bytes_to_read;
6654 }
6655 }
6656 }
6657 }
6658 }
6659 }
6660 }
6661 return true; // This is the right plug to handle saving core files for
6662 // this process
6663 }
6664 return false;
6665}
6666
6669 MachOCorefileAllImageInfos image_infos;
6672
6673 auto lc_notes = FindLC_NOTEByName("all image infos");
6674 for (auto lc_note : lc_notes) {
6675 offset_t payload_offset = std::get<0>(lc_note);
6676 // Read the struct all_image_infos_header.
6677 uint32_t version = m_data.GetU32(&payload_offset);
6678 if (version != 1) {
6679 return image_infos;
6680 }
6681 uint32_t imgcount = m_data.GetU32(&payload_offset);
6682 uint64_t entries_fileoff = m_data.GetU64(&payload_offset);
6683 // 'entries_size' is not used, nor is the 'unused' entry.
6684 // offset += 4; // uint32_t entries_size;
6685 // offset += 4; // uint32_t unused;
6686
6687 LLDB_LOGF(log, "LC_NOTE 'all image infos' found version %d with %d images",
6688 version, imgcount);
6689 payload_offset = entries_fileoff;
6690 for (uint32_t i = 0; i < imgcount; i++) {
6691 // Read the struct image_entry.
6692 offset_t filepath_offset = m_data.GetU64(&payload_offset);
6693 uuid_t uuid;
6694 memcpy(&uuid, m_data.GetData(&payload_offset, sizeof(uuid_t)),
6695 sizeof(uuid_t));
6696 uint64_t load_address = m_data.GetU64(&payload_offset);
6697 offset_t seg_addrs_offset = m_data.GetU64(&payload_offset);
6698 uint32_t segment_count = m_data.GetU32(&payload_offset);
6699 uint32_t currently_executing = m_data.GetU32(&payload_offset);
6700
6702 image_entry.filename = (const char *)m_data.GetCStr(&filepath_offset);
6703 image_entry.uuid = UUID(uuid, sizeof(uuid_t));
6704 image_entry.load_address = load_address;
6705 image_entry.currently_executing = currently_executing;
6706
6707 offset_t seg_vmaddrs_offset = seg_addrs_offset;
6708 for (uint32_t j = 0; j < segment_count; j++) {
6709 char segname[17];
6710 m_data.CopyData(seg_vmaddrs_offset, 16, segname);
6711 segname[16] = '\0';
6712 seg_vmaddrs_offset += 16;
6713 uint64_t vmaddr = m_data.GetU64(&seg_vmaddrs_offset);
6714 seg_vmaddrs_offset += 8; /* unused */
6715
6716 std::tuple<ConstString, addr_t> new_seg{ConstString(segname), vmaddr};
6717 image_entry.segment_load_addresses.push_back(new_seg);
6718 }
6719 LLDB_LOGF(log, " image entry: %s %s 0x%" PRIx64 " %s",
6720 image_entry.filename.c_str(),
6721 image_entry.uuid.GetAsString().c_str(),
6723 image_entry.currently_executing ? "currently executing"
6724 : "not currently executing");
6725 image_infos.all_image_infos.push_back(image_entry);
6726 }
6727 }
6728
6729 lc_notes = FindLC_NOTEByName("load binary");
6730 for (auto lc_note : lc_notes) {
6731 offset_t payload_offset = std::get<0>(lc_note);
6732 uint32_t version = m_data.GetU32(&payload_offset);
6733 if (version == 1) {
6734 uuid_t uuid;
6735 memcpy(&uuid, m_data.GetData(&payload_offset, sizeof(uuid_t)),
6736 sizeof(uuid_t));
6737 uint64_t load_address = m_data.GetU64(&payload_offset);
6738 uint64_t slide = m_data.GetU64(&payload_offset);
6739 std::string filename = m_data.GetCStr(&payload_offset);
6740
6742 image_entry.filename = filename;
6743 image_entry.uuid = UUID(uuid, sizeof(uuid_t));
6744 image_entry.load_address = load_address;
6745 image_entry.slide = slide;
6746 image_entry.currently_executing = true;
6747 image_infos.all_image_infos.push_back(image_entry);
6748 LLDB_LOGF(log,
6749 "LC_NOTE 'load binary' found, filename %s uuid %s load "
6750 "address 0x%" PRIx64 " slide 0x%" PRIx64,
6751 filename.c_str(),
6752 image_entry.uuid.IsValid()
6753 ? image_entry.uuid.GetAsString().c_str()
6754 : "00000000-0000-0000-0000-000000000000",
6755 load_address, slide);
6756 }
6757 }
6758
6759 return image_infos;
6760}
6761
6765 Status error;
6766
6767 bool found_platform_binary = false;
6768 ModuleList added_modules;
6769 for (MachOCorefileImageEntry &image : image_infos.all_image_infos) {
6770 ModuleSP module_sp, local_filesystem_module_sp;
6771
6772 // If this is a platform binary, it has been loaded (or registered with
6773 // the DynamicLoader to be loaded), we don't need to do any further
6774 // processing. We're not going to call ModulesDidLoad on this in this
6775 // method, so notify==true.
6776 if (process.GetTarget()
6777 .GetDebugger()
6780 true /* notify */)) {
6781 LLDB_LOGF(log,
6782 "ObjectFileMachO::%s binary at 0x%" PRIx64
6783 " is a platform binary, has been handled by a Platform plugin.",
6784 __FUNCTION__, image.load_address);
6785 continue;
6786 }
6787
6788 bool value_is_offset = image.load_address == LLDB_INVALID_ADDRESS;
6789 uint64_t value = value_is_offset ? image.slide : image.load_address;
6790 if (value_is_offset && value == LLDB_INVALID_ADDRESS) {
6791 // We have neither address nor slide; so we will find the binary
6792 // by UUID and load it at slide/offset 0.
6793 value = 0;
6794 }
6795
6796 // We have either a UUID, or we have a load address which
6797 // and can try to read load commands and find a UUID.
6798 if (image.uuid.IsValid() ||
6799 (!value_is_offset && value != LLDB_INVALID_ADDRESS)) {
6800 const bool set_load_address = image.segment_load_addresses.size() == 0;
6801 const bool notify = false;
6802 // Userland Darwin binaries will have segment load addresses via
6803 // the `all image infos` LC_NOTE.
6804 const bool allow_memory_image_last_resort =
6805 image.segment_load_addresses.size();
6807 &process, image.filename, image.uuid, value, value_is_offset,
6808 image.currently_executing, notify, set_load_address,
6809 allow_memory_image_last_resort);
6810 }
6811
6812 // We have a ModuleSP to load in the Target. Load it at the
6813 // correct address/slide and notify/load scripting resources.
6814 if (module_sp) {
6815 added_modules.Append(module_sp, false /* notify */);
6816
6817 // We have a list of segment load address
6818 if (image.segment_load_addresses.size() > 0) {
6819 if (log) {
6820 std::string uuidstr = image.uuid.GetAsString();
6821 log->Printf("ObjectFileMachO::LoadCoreFileImages adding binary '%s' "
6822 "UUID %s with section load addresses",
6823 module_sp->GetFileSpec().GetPath().c_str(),
6824 uuidstr.c_str());
6825 }
6826 for (auto name_vmaddr_tuple : image.segment_load_addresses) {
6827 SectionList *sectlist = module_sp->GetObjectFile()->GetSectionList();
6828 if (sectlist) {
6829 SectionSP sect_sp =
6830 sectlist->FindSectionByName(std::get<0>(name_vmaddr_tuple));
6831 if (sect_sp) {
6833 sect_sp, std::get<1>(name_vmaddr_tuple));
6834 }
6835 }
6836 }
6837 } else {
6838 if (log) {
6839 std::string uuidstr = image.uuid.GetAsString();
6840 log->Printf("ObjectFileMachO::LoadCoreFileImages adding binary '%s' "
6841 "UUID %s with %s 0x%" PRIx64,
6842 module_sp->GetFileSpec().GetPath().c_str(),
6843 uuidstr.c_str(),
6844 value_is_offset ? "slide" : "load address", value);
6845 }
6846 bool changed;
6847 module_sp->SetLoadAddress(process.GetTarget(), value, value_is_offset,
6848 changed);
6849 }
6850 }
6851 }
6852 if (added_modules.GetSize() > 0) {
6853 process.GetTarget().ModulesDidLoad(added_modules);
6854 process.Flush();
6855 return true;
6856 }
6857 // Return true if the only binary we found was the platform binary,
6858 // and it was loaded outside the scope of this method.
6859 if (found_platform_binary)
6860 return true;
6861
6862 // No binaries.
6863 return false;
6864}
unsigned char uuid_t[16]
static llvm::raw_ostream & error(Stream &strm)
static const char * memory_read_error
#define lldbassert(x)
Definition LLDBAssert.h:16
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition Log.h:369
#define LLDB_LOGF(log,...)
Definition Log.h:376
static uint32_t MachHeaderSizeFromMagic(uint32_t magic)
static uint32_t GetSegmentPermissions(const llvm::MachO::segment_command_64 &seg_cmd)
static constexpr llvm::StringLiteral g_loader_path
static std::optional< struct nlist_64 > ParseNList(DataExtractor &nlist_data, lldb::offset_t &nlist_data_offset, size_t nlist_byte_size)
static constexpr llvm::StringLiteral g_executable_path
static void PrintRegisterValue(RegisterContext *reg_ctx, const char *name, const char *alt_name, size_t reg_byte_size, Stream &data)
static llvm::StringRef GetOSName(uint32_t cmd)
static llvm::VersionTuple FindMinimumVersionInfo(DataExtractor &data, lldb::offset_t offset, size_t ncmds)
unsigned int mach_task_self()
static lldb::SectionType GetSectionType(uint32_t flags, ConstString section_name)
@ NonDebugSymbols
@ DebugSymbols
#define MACHO_NLIST_ARM_SYMBOL_IS_THUMB
void * dyld_process_info
static uint32_t MachHeaderSizeFromMagic(uint32_t magic)
static offset_t CreateAllImageInfosPayload(const lldb::ProcessSP &process_sp, offset_t initial_file_offset, StreamString &all_image_infos_payload, lldb_private::SaveCoreOptions &options)
static bool TryParseV2ObjCMetadataSymbol(const char *&symbol_name, const char *&symbol_name_non_abi_mangled, SymbolType &type)
#define TRIE_SYMBOL_IS_THUMB
static bool ParseTrieEntries(DataExtractor &data, lldb::offset_t offset, const bool is_arm, addr_t text_seg_base_addr, std::vector< llvm::StringRef > &nameSlices, std::set< lldb::addr_t > &resolver_addresses, std::vector< TrieEntryWithOffset > &reexports, std::vector< TrieEntryWithOffset > &ext_symbols)
#define THUMB_ADDRESS_BIT_MASK
static SymbolType GetSymbolType(const char *&symbol_name, bool &demangled_is_synthesized, const SectionSP &text_section_sp, const SectionSP &data_section_sp, const SectionSP &data_dirty_section_sp, const SectionSP &data_const_section_sp, const SectionSP &symbol_section)
#define LLDB_PLUGIN_DEFINE(PluginName)
#define KERN_SUCCESS
Constants returned by various RegisterContextDarwin_*** functions.
#define LLDB_SCOPED_TIMERF(...)
Definition Timer.h:86
static llvm::StringRef GetName(XcodeSDK::Type type)
Definition XcodeSDK.cpp:21
std::vector< SectionInfo > m_section_infos
SectionSP GetSection(uint8_t n_sect, addr_t file_addr)
MachSymtabSectionInfo(SectionList *section_list)
bool SectionIsLoadable(const lldb_private::Section *section)
llvm::MachO::mach_header m_header
bool m_allow_assembly_emulation_unwind_plans
std::optional< llvm::VersionTuple > m_min_os_version
lldb_private::AddressableBits GetAddressableBits() override
Some object files may have the number of bits used for addressing embedded in them,...
uint32_t GetDependentModules(lldb_private::FileSpecList &files) override
Extract the dependent modules from an object file.
static lldb_private::ObjectFile * CreateMemoryInstance(const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
FileRangeArray m_thread_context_offsets
ObjectFile::Type CalculateType() override
The object file should be able to calculate its type by looking at its file header and possibly the s...
lldb_private::RangeVector< uint32_t, uint32_t, 8 > EncryptedFileRanges
static lldb_private::ConstString GetSegmentNameLINKEDIT()
static lldb_private::ObjectFile * CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t file_offset, lldb::offset_t length)
std::vector< std::tuple< lldb::offset_t, lldb::offset_t > > FindLC_NOTEByName(std::string name)
void Dump(lldb_private::Stream *s) override
Dump a description of this object to a Stream.
bool AllowAssemblyEmulationUnwindPlans() override
Returns if the function bounds for symbols in this symbol file are likely accurate.
std::string GetIdentifierString() override
Some object files may have an identifier string embedded in them, e.g.
void ProcessSegmentCommand(const llvm::MachO::load_command &load_cmd, lldb::offset_t offset, uint32_t cmd_idx, SegmentParsingContext &context)
std::vector< llvm::MachO::section_64 > m_mach_sections
bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value, bool value_is_offset) override
Sets the load address for an entire module, assuming a rigid slide of sections, if possible in the im...
void GetProcessSharedCacheUUID(lldb_private::Process *, lldb::addr_t &base_addr, lldb_private::UUID &uuid)
Intended for same-host arm device debugging where lldb needs to detect libraries in the shared cache ...
bool GetIsDynamicLinkEditor() override
Return true if this file is a dynamic link editor (dyld)
lldb::ByteOrder GetByteOrder() const override
Gets whether endian swapping should occur when extracting data from this object file.
bool ParseHeader() override
Attempts to parse the object header.
static lldb_private::ConstString GetSegmentNameDATA_DIRTY()
bool IsStripped() override
Detect if this object file has been stripped of local symbols.
static lldb_private::ConstString GetSegmentNameTEXT()
lldb_private::UUID GetUUID() override
Gets the UUID for this object file.
llvm::VersionTuple GetMinimumOSVersion() override
Get the minimum OS version this object file can run on.
static llvm::StringRef GetPluginDescriptionStatic()
static lldb_private::ConstString GetSegmentNameOBJC()
static llvm::StringRef GetPluginNameStatic()
lldb::RegisterContextSP GetThreadContextAtIndex(uint32_t idx, lldb_private::Thread &thread) override
static bool MagicBytesMatch(lldb::DataBufferSP data_sp, lldb::addr_t offset, lldb::addr_t length)
lldb_private::FileSpecList m_reexported_dylibs
static void GetAllArchSpecs(const llvm::MachO::mach_header &header, const lldb_private::DataExtractor &data, lldb::offset_t lc_offset, lldb_private::ModuleSpec &base_spec, lldb_private::ModuleSpecList &all_specs)
Enumerate all ArchSpecs supported by this Mach-O file.
bool GetCorefileThreadExtraInfos(std::vector< lldb::tid_t > &tids) override
Get metadata about thread ids from the corefile.
bool IsDynamicLoader() const
static lldb_private::ConstString GetSegmentNameDWARF()
static void Terminate()
bool IsExecutable() const override
Tells whether this object file is capable of being the main executable for a process.
lldb_private::Address GetEntryPointAddress() override
Returns the address of the Entry Point in this object file - if the object file doesn't have an entry...
lldb_private::Address m_entry_point_address
static void Initialize()
bool LoadCoreFileImages(lldb_private::Process &process) override
Load binaries listed in a corefile.
bool CanTrustAddressRanges() override
Can we trust the address ranges accelerator associated with this object file to be complete.
void SanitizeSegmentCommand(llvm::MachO::segment_command_64 &seg_cmd, uint32_t cmd_idx)
bool IsSharedCacheBinary() const
llvm::VersionTuple GetSDKVersion() override
Get the SDK OS version this object file was built with.
lldb_private::ArchSpec GetArchitecture() override
Get the ArchSpec for this object file.
static lldb_private::ConstString GetSegmentNameDATA()
ObjectFileMachO(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t offset, lldb::offset_t length)
lldb_private::Address GetBaseAddress() override
Returns base address of this object file.
size_t ParseSymtab()
static size_t GetModuleSpecifications(const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, lldb_private::ModuleSpecList &specs)
lldb::addr_t m_text_address
uint32_t GetAddressByteSize() const override
Gets the address size in bytes for the current object file.
llvm::MachO::dysymtab_command m_dysymtab
bool GetCorefileMainBinaryInfo(lldb::addr_t &value, bool &value_is_offset, lldb_private::UUID &uuid, ObjectFile::BinaryType &type) override
static bool SaveCore(const lldb::ProcessSP &process_sp, lldb_private::SaveCoreOptions &options, lldb_private::Status &error)
void ProcessDysymtabCommand(const llvm::MachO::load_command &load_cmd, lldb::offset_t offset)
MachOCorefileAllImageInfos GetCorefileAllImageInfos()
Get the list of binary images that were present in the process when the corefile was produced.
lldb::addr_t CalculateSectionLoadAddressForMemoryImage(lldb::addr_t mach_header_load_address, const lldb_private::Section *mach_header_section, const lldb_private::Section *section)
static lldb_private::ConstString GetSegmentNameLLVM_COV()
bool m_thread_context_offsets_valid
ObjectFile::Strata CalculateStrata() override
The object file should be able to calculate the strata of the object file.
void CreateSections(lldb_private::SectionList &unified_section_list) override
static lldb_private::ConstString GetSegmentNameDATA_CONST()
lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override
Get the address type given a file address in an object file.
lldb_private::StructuredData::ObjectSP GetCorefileProcessMetadata() override
Get process metadata from the corefile in a StructuredData dictionary.
std::optional< llvm::VersionTuple > m_sdk_versions
static lldb_private::ConstString GetSectionNameLLDBNoNlist()
void GetLLDBSharedCacheUUID(lldb::addr_t &base_addir, lldb_private::UUID &uuid)
Intended for same-host arm device debugging where lldb will read shared cache libraries out of its ow...
llvm::VersionTuple GetVersion() override
Get the object file version numbers.
EncryptedFileRanges GetEncryptedFileRanges()
uint32_t GetNumThreadContexts() override
static lldb_private::ConstString GetSectionNameEHFrame()
lldb::offset_t m_linkedit_original_offset
lldb_private::Section * GetMachHeaderSection()
int DoWriteDBG(lldb::tid_t tid, int flavor, const DBG &dbg) override
int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override
int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override
int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override
int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override
RegisterContextDarwin_arm64_Mach(lldb_private::Thread &thread, const DataExtractor &data)
int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override
void SetRegisterDataFrom_LC_THREAD(const DataExtractor &data)
int DoReadDBG(lldb::tid_t tid, int flavor, DBG &dbg) override
int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override
static bool Create_LC_THREAD(Thread *thread, Stream &data)
bool SetError(int flavor, uint32_t err_idx, int err)
RegisterContextDarwin_arm64(lldb_private::Thread &thread, uint32_t concrete_frame_idx)
RegisterContextDarwin_arm_Mach(lldb_private::Thread &thread, const DataExtractor &data)
int DoWriteDBG(lldb::tid_t tid, int flavor, const DBG &dbg) override
int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override
int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override
int DoReadDBG(lldb::tid_t tid, int flavor, DBG &dbg) override
int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override
int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override
void SetRegisterDataFrom_LC_THREAD(const DataExtractor &data)
int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override
int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override
static bool Create_LC_THREAD(Thread *thread, Stream &data)
RegisterContextDarwin_arm(lldb_private::Thread &thread, uint32_t concrete_frame_idx)
bool SetError(int flavor, uint32_t err_idx, int err)
int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override
int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override
int DoWriteCSR(lldb::tid_t tid, int flavor, const CSR &csr) override
RegisterContextDarwin_riscv32_Mach(lldb_private::Thread &thread, const DataExtractor &data)
int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override
int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override
int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override
int DoReadCSR(lldb::tid_t tid, int flavor, CSR &csr) override
static bool Create_LC_THREAD(Thread *thread, Stream &data)
void SetRegisterDataFrom_LC_THREAD(const DataExtractor &data)
int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override
RegisterContextDarwin_riscv32(lldb_private::Thread &thread, uint32_t concrete_frame_idx)
bool SetError(int flavor, uint32_t err_idx, int err)
RegisterContextDarwin_x86_64_Mach(lldb_private::Thread &thread, const DataExtractor &data)
int DoWriteFPU(lldb::tid_t tid, int flavor, const FPU &fpu) override
static bool Create_LC_THREAD(Thread *thread, Stream &data)
void SetRegisterDataFrom_LC_THREAD(const DataExtractor &data)
int DoWriteEXC(lldb::tid_t tid, int flavor, const EXC &exc) override
int DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) override
int DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) override
int DoWriteGPR(lldb::tid_t tid, int flavor, const GPR &gpr) override
int DoReadEXC(lldb::tid_t tid, int flavor, EXC &exc) override
RegisterContextDarwin_x86_64(lldb_private::Thread &thread, uint32_t concrete_frame_idx)
bool SetError(int flavor, uint32_t err_idx, int err)
A section + offset based address class.
Definition Address.h:62
void SetSection(const lldb::SectionSP &section_sp)
Set accessor for the section.
Definition Address.h:466
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition Address.cpp:301
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition Address.h:432
lldb::addr_t GetFileAddress() const
Get the file address.
Definition Address.cpp:281
bool IsValid() const
Check if the object state is valid.
Definition Address.h:355
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition Address.h:441
A class which holds the metadata from a remote stub/corefile note about how many bits are used for ad...
void SetAddressableBits(uint32_t addressing_bits)
When a single value is available for the number of bits.
An architecture specification class.
Definition ArchSpec.h:31
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition ArchSpec.cpp:685
bool IsValid() const
Tests if this ArchSpec is valid.
Definition ArchSpec.h:366
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition ArchSpec.h:468
bool IsAlwaysThumbInstructions() const
Detect whether this architecture uses thumb code exclusively.
bool SetArchitecture(ArchitectureType arch_type, uint32_t cpu, uint32_t sub, uint32_t os=0)
Change the architecture object type, CPU type and OS type.
Definition ArchSpec.cpp:845
uint32_t GetMachOCPUSubType() const
Definition ArchSpec.cpp:661
bool IsCompatibleMatch(const ArchSpec &rhs) const
Shorthand for IsMatch(rhs, CompatibleMatch).
Definition ArchSpec.h:520
uint32_t GetMachOCPUType() const
Definition ArchSpec.cpp:649
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition ArchSpec.cpp:732
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition ArchSpec.cpp:677
A uniqued constant string class.
Definition ConstString.h:40
std::string GetString() const
Get the string value as a std::string.
void SetCStringWithLength(const char *cstr, size_t cstr_len)
Set the C string value with length.
void SetCString(const char *cstr)
Set the C string value.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
void SetTrimmedCStringWithLength(const char *cstr, size_t fixed_cstr_len)
Set the C string value with the minimum length between fixed_cstr_len and the actual length of the C ...
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
void Clear()
Clear this object's state.
const char * GetCString() const
Get the string value as a C string.
void GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info)
RangeVector< lldb::addr_t, uint32_t > FunctionAddressAndSizeVector
An data extractor class.
uint64_t GetULEB128(lldb::offset_t *offset_ptr) const
Extract a unsigned LEB128 value from *offset_ptr.
uint32_t GetU32_unchecked(lldb::offset_t *offset_ptr) const
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
const uint8_t * PeekData(lldb::offset_t offset, lldb::offset_t length) const
Peek at a bytes at offset.
bool ValidOffsetForDataOfSize(lldb::offset_t offset, lldb::offset_t length) const
Test the availability of length bytes of data from offset.
uint64_t GetAddress_unchecked(lldb::offset_t *offset_ptr) const
void SetByteOrder(lldb::ByteOrder byte_order)
Set the byte_order value.
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
uint8_t GetU8_unchecked(lldb::offset_t *offset_ptr) const
bool ValidOffset(lldb::offset_t offset) const
Test the validity of offset.
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
lldb::ByteOrder GetByteOrder() const
Get the current byte order value.
void SetAddressByteSize(uint32_t addr_size)
Set the address byte size.
uint16_t GetU16_unchecked(lldb::offset_t *offset_ptr) const
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
size_t ExtractBytes(lldb::offset_t offset, lldb::offset_t length, lldb::ByteOrder dst_byte_order, void *dst) const
Extract an arbitrary number of bytes in the specified byte order.
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
PlatformList & GetPlatformList()
Definition Debugger.h:203
lldb::StreamUP GetAsyncOutputStream()
A plug-in interface definition class for dynamic loaders.
virtual bool GetSharedCacheInformation(lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache, LazyBool &private_shared_cache)
Get information about the shared cache for a process, if possible.
static lldb::ModuleSP LoadBinaryWithUUIDAndAddress(Process *process, llvm::StringRef name, UUID uuid, lldb::addr_t value, bool value_is_offset, bool force_symbol_search, bool notify, bool set_address_in_target, bool allow_memory_image_last_resort)
Find/load a binary into lldb given a UUID and the address where it is loaded in memory,...
A file collection class.
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
void Append(const FileSpec &file)
Append a FileSpec object to the list.
size_t GetSize() const
Get the number of files in the file list.
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
A file utility class.
Definition FileSpec.h:57
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition FileSpec.cpp:174
FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const
Definition FileSpec.cpp:425
const ConstString & GetFilename() const
Filename string const get accessor.
Definition FileSpec.h:251
void ClearDirectory()
Clear the directory in this object.
Definition FileSpec.cpp:367
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition FileSpec.h:234
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition FileSpec.cpp:374
FileSpec CopyByRemovingLastPathComponent() const
Definition FileSpec.cpp:431
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
int Open(const char *path, int flags, int mode=0600)
Wraps open in a platform-independent way.
static FileSystem & Instance()
@ eOpenOptionWriteOnly
Definition File.h:52
@ eOpenOptionCanCreate
Definition File.h:56
@ eOpenOptionTruncate
Definition File.h:57
A class to manage flags.
Definition Flags.h:22
bool Test(ValueType bit) const
Test a single flag bit.
Definition Flags.h:96
void void void void void Warning(const char *fmt,...) __attribute__((format(printf
Definition Log.cpp:211
void void Printf(const char *format,...) __attribute__((format(printf
Prefer using LLDB_LOGF whenever possible.
Definition Log.cpp:156
A class that handles mangled names.
Definition Mangled.h:34
void SetDemangledName(ConstString name)
Definition Mangled.h:138
ConstString GetDemangledName() const
Demangled name get accessor.
Definition Mangled.cpp:284
void SetMangledName(ConstString name)
Definition Mangled.h:143
void SetValue(ConstString name)
Set the string value in this object.
Definition Mangled.cpp:124
ConstString GetName(NamePreference preference=ePreferDemangled) const
Best name get accessor.
Definition Mangled.cpp:369
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
A collection class for Module objects.
Definition ModuleList.h:104
void Clear()
Clear the object's state.
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
size_t GetSize() const
Gets the size of the module list.
void Append(const ModuleSpec &spec)
Definition ModuleSpec.h:308
ModuleSpec & GetModuleSpecRefAtIndex(size_t i)
Definition ModuleSpec.h:321
void SetObjectSize(uint64_t object_size)
Definition ModuleSpec.h:115
FileSpec & GetFileSpec()
Definition ModuleSpec.h:53
ArchSpec & GetArchitecture()
Definition ModuleSpec.h:89
void SetObjectOffset(uint64_t object_offset)
Definition ModuleSpec.h:109
A plug-in interface definition class for object file parsers.
Definition ObjectFile.h:45
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition ObjectFile.h:784
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition ObjectFile.h:788
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
ObjectFile(const lldb::ModuleSP &module_sp, const FileSpec *file_spec_ptr, lldb::offset_t file_offset, lldb::offset_t length, lldb::DataBufferSP data_sp, lldb::offset_t data_offset)
Construct with a parent module, offset, and header data.
std::unique_ptr< lldb_private::Symtab > m_symtab_up
Definition ObjectFile.h:789
const lldb::addr_t m_memory_addr
Set if the object file only exists in memory.
Definition ObjectFile.h:787
static lldb::SectionType GetDWARFSectionTypeFromName(llvm::StringRef name)
Parses the section type from a section name for DWARF sections.
Symtab * GetSymtab(bool can_create=true)
Gets the symbol table for the currently selected architecture (and object for archives).
static lldb::WritableDataBufferSP ReadMemory(const lldb::ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size)
@ eTypeExecutable
A normal executable.
Definition ObjectFile.h:54
@ eTypeDebugInfo
An object file that contains only debug information.
Definition ObjectFile.h:56
@ eTypeStubLibrary
A library that can be linked against but not used for execution.
Definition ObjectFile.h:64
@ eTypeObjectFile
An intermediate object file.
Definition ObjectFile.h:60
@ eTypeDynamicLinker
The platform's dynamic linker executable.
Definition ObjectFile.h:58
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
Definition ObjectFile.h:52
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition ObjectFile.h:62
lldb::addr_t m_file_offset
The offset in bytes into the file, or the address in memory.
Definition ObjectFile.h:778
static lldb::SymbolType GetSymbolTypeFromName(llvm::StringRef name, lldb::SymbolType symbol_type_hint=lldb::eSymbolTypeUndefined)
bool SetModulesArchitecture(const ArchSpec &new_arch)
Sets the architecture for a module.
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition ObjectFile.h:281
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
bool IsInMemory() const
Returns true if the object file exists only in memory.
Definition ObjectFile.h:709
lldb::ProcessWP m_process_wp
Definition ObjectFile.h:785
lldb::addr_t m_length
The length of this object file if it is known (can be zero if length is unknown or can't be determine...
Definition ObjectFile.h:780
BinaryType
If we have a corefile binary hint, this enum specifies the binary type which we can use to select the...
Definition ObjectFile.h:82
@ eBinaryTypeKernel
kernel binary
Definition ObjectFile.h:86
@ eBinaryTypeUser
user process binary, dyld addr
Definition ObjectFile.h:88
@ eBinaryTypeUserAllImageInfos
user process binary, dyld_all_image_infos addr
Definition ObjectFile.h:90
@ eBinaryTypeStandalone
standalone binary / firmware
Definition ObjectFile.h:92
virtual lldb_private::Address GetBaseAddress()
Returns base address of this object file.
Definition ObjectFile.h:486
bool LoadPlatformBinaryAndSetup(Process *process, lldb::addr_t addr, bool notify)
Detect a binary in memory that will determine which Platform and DynamicLoader should be used in this...
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A plug-in interface definition class for debugging a process.
Definition Process.h:357
void Flush()
Flush all data in the process.
Definition Process.cpp:5890
virtual DynamicLoader * GetDynamicLoader()
Get the dynamic loader plug-in for this process.
Definition Process.cpp:2824
Target & GetTarget()
Get the target object pointer for this module.
Definition Process.h:1270
A Progress indicator helper class.
Definition Progress.h:60
const Entry * FindEntryThatContains(B addr) const
Definition RangeMap.h:338
const Entry * GetEntryAtIndex(size_t i) const
Definition RangeMap.h:297
void Append(const Entry &entry)
Definition RangeMap.h:179
size_t GetSize() const
Definition RangeMap.h:295
const void * GetBytes() const
const std::optional< lldb_private::FileSpec > GetOutputFile() const
lldb::SaveCoreStyle GetStyle() const
void SetStyle(lldb::SaveCoreStyle style)
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition Section.cpp:558
size_t GetNumSections(uint32_t depth) const
Definition Section.cpp:540
size_t Slide(lldb::addr_t slide_amount, bool slide_children)
Definition Section.cpp:664
size_t GetSize() const
Definition Section.h:75
size_t AddSection(const lldb::SectionSP &section_sp)
Definition Section.cpp:482
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition Section.cpp:644
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition Section.cpp:551
bool IsThreadSpecific() const
Definition Section.h:210
ConstString GetName() const
Definition Section.h:200
void SetByteSize(lldb::addr_t byte_size)
Definition Section.h:188
void SetFileOffset(lldb::offset_t file_offset)
Definition Section.h:172
lldb::offset_t GetFileOffset() const
Definition Section.h:170
lldb::addr_t GetFileAddress() const
Definition Section.cpp:198
SectionList & GetChildren()
Definition Section.h:156
void SetFileSize(lldb::offset_t file_size)
Definition Section.h:178
bool Slide(lldb::addr_t slide_amount, bool slide_children)
Definition Section.cpp:347
lldb::addr_t GetByteSize() const
Definition Section.h:186
lldb::offset_t GetFileSize() const
Definition Section.h:176
An error handling class.
Definition Status.h:118
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition Status.cpp:106
static Status FromError(llvm::Error error)
Avoid using this in new code. Migrate APIs to llvm::Expected instead.
Definition Status.cpp:137
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition Stream.h:28
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition Stream.h:112
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition Stream.h:392
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition Stream.cpp:157
size_t PutHex64(uint64_t uvalue, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition Stream.cpp:299
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition Stream.cpp:65
size_t PutHex32(uint32_t uvalue, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition Stream.cpp:283
@ eBinary
Get and put data as binary instead of as the default string mode.
Definition Stream.h:32
size_t PutRawBytes(const void *s, size_t src_len, lldb::ByteOrder src_byte_order=lldb::eByteOrderInvalid, lldb::ByteOrder dst_byte_order=lldb::eByteOrderInvalid)
Definition Stream.cpp:356
unsigned GetIndentLevel() const
Get the current indentation level.
Definition Stream.cpp:187
std::optional< Dictionary * > GetItemAtIndexAsDictionary(size_t idx) const
Retrieves the element at index idx from a StructuredData::Array if it is a Dictionary.
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const
void Dump(lldb_private::Stream &s, bool pretty_print=true) const
std::shared_ptr< Dictionary > DictionarySP
std::shared_ptr< Object > ObjectSP
static ObjectSP ParseJSON(llvm::StringRef json_text)
std::shared_ptr< Array > ArraySP
Defines a list of symbol context objects.
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
uint32_t GetSize() const
Get accessor for a symbol context list size.
Defines a symbol context baton that can be handed other debug core functions.
Symbol * symbol
The Symbol for a given query.
bool ValueIsAddress() const
Definition Symbol.cpp:165
void SetReExportedSymbolName(ConstString name)
Definition Symbol.cpp:199
void SetType(lldb::SymbolType type)
Definition Symbol.h:171
void SetSizeIsSibling(bool b)
Definition Symbol.h:220
Mangled & GetMangled()
Definition Symbol.h:147
Address & GetAddressRef()
Definition Symbol.h:73
void SetIsWeak(bool b)
Definition Symbol.h:207
uint32_t GetFlags() const
Definition Symbol.h:175
bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec)
Definition Symbol.cpp:206
lldb::addr_t GetByteSize() const
Definition Symbol.cpp:431
lldb::SymbolType GetType() const
Definition Symbol.h:169
void SetFlags(uint32_t flags)
Definition Symbol.h:177
Address GetAddress() const
Definition Symbol.h:89
void SetIsSynthetic(bool b)
Definition Symbol.h:187
void SetByteSize(lldb::addr_t size)
Definition Symbol.h:213
void SetDemangledNameIsSynthesized(bool b)
Definition Symbol.h:230
void SetExternal(bool b)
Definition Symbol.h:199
void SetDebug(bool b)
Definition Symbol.h:195
void SetID(uint32_t uid)
Definition Symbol.h:145
Symbol * FindSymbolByID(lldb::user_id_t uid) const
Definition Symtab.cpp:219
Symbol * SymbolAtIndex(size_t idx)
Definition Symtab.cpp:228
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
Definition Symtab.cpp:874
Symbol * Resize(size_t count)
Definition Symtab.cpp:57
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition Symtab.cpp:1045
size_t GetNumSymbols() const
Definition Symtab.cpp:77
MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const
Definition Target.cpp:5013
void ModulesDidLoad(ModuleList &module_list)
Definition Target.cpp:1854
Debugger & GetDebugger() const
Definition Target.h:1108
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition Target.h:1025
const ArchSpec & GetArchitecture() const
Definition Target.h:1067
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition Target.cpp:3299
uint32_t GetSize(bool can_update=true)
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Represents UUID's of various sizes.
Definition UUID.h:27
void Clear()
Definition UUID.h:62
std::string GetAsString(llvm::StringRef separator="-") const
Definition UUID.cpp:54
bool IsValid() const
Definition UUID.h:69
#define UINT64_MAX
#define LLDB_INVALID_ADDRESS_MASK
Address Mask Bits not used for addressing are set to 1 in the mask; all mask bits set is an invalid v...
#define LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_ADDRESS
#define UINT32_MAX
lldb::ByteOrder InlHostByteOrder()
Definition Endian.h:25
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition Log.h:332
static uint32_t bits(const uint32_t val, const uint32_t msbit, const uint32_t lsbit)
Definition ARMUtils.h:265
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::Thread > ThreadSP
uint64_t offset_t
Definition lldb-types.h:85
std::shared_ptr< lldb_private::Process > ProcessSP
SymbolType
Symbol types.
@ eSymbolTypeUndefined
@ eSymbolTypeVariableType
@ eSymbolTypeObjCMetaClass
@ eSymbolTypeReExported
@ eSymbolTypeObjCClass
@ eSymbolTypeObjectFile
@ eSymbolTypeTrampoline
@ eSymbolTypeResolver
@ eSymbolTypeSourceFile
@ eSymbolTypeException
@ eSymbolTypeVariable
@ eSymbolTypeAbsolute
@ eSymbolTypeAdditional
When symbols take more than one entry, the extra entries get this type.
@ eSymbolTypeInstrumentation
@ eSymbolTypeHeaderFile
@ eSymbolTypeCommonBlock
@ eSymbolTypeCompiler
@ eSymbolTypeLineHeader
@ eSymbolTypeObjCIVar
@ eSymbolTypeLineEntry
@ eSymbolTypeScopeBegin
@ eSymbolTypeScopeEnd
ByteOrder
Byte ordering definitions.
uint64_t user_id_t
Definition lldb-types.h:82
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
uint64_t addr_t
Definition lldb-types.h:80
@ eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
@ eSectionTypeInvalid
@ eSectionTypeDWARFDebugPubNames
@ eSectionTypeDataObjCCFStrings
Objective-C const CFString/NSString objects.
@ eSectionTypeZeroFill
@ eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugFrame
@ eSectionTypeARMextab
@ eSectionTypeContainer
The section contains child sections.
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
@ eSectionTypeDataSymbolAddress
Address of a symbol in the symbol table.
@ eSectionTypeELFDynamicLinkInfo
Elf SHT_DYNAMIC section.
@ eSectionTypeDWARFDebugMacInfo
@ eSectionTypeAbsoluteAddress
Dummy section for symbols with absolute address.
@ eSectionTypeCompactUnwind
compact unwind section in Mach-O, __TEXT,__unwind_info
@ eSectionTypeELFRelocationEntries
Elf SHT_REL or SHT_REL section.
@ eSectionTypeDWARFAppleNamespaces
@ eSectionTypeLLDBFormatters
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
@ eSectionTypeEHFrame
@ eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeLLDBTypeSummaries
@ eSectionTypeGoSymtab
@ eSectionTypeARMexidx
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDataObjCMessageRefs
Pointer to function pointer + selector.
@ eSectionTypeDWARFDebugTuIndex
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
@ eSectionTypeDWARFDebugLoc
@ eSectionTypeDWARFAppleNames
@ eSectionTypeDataCStringPointers
Pointers to C string data.
@ eSectionTypeDWARFAppleObjC
@ eSectionTypeSwiftModules
@ eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDataPointers
@ eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugAddr
@ eSectionTypeWasmName
@ eSectionTypeDataCString
Inlined C string data.
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
uint64_t tid_t
Definition lldb-types.h:84
std::shared_ptr< lldb_private::Module > ModuleSP
The LC_DYSYMTAB's dysymtab_command has 32-bit file offsets that we will use as virtual address offset...
std::vector< MachOCorefileImageEntry > all_image_infos
A corefile may include metadata about all of the binaries that were present in the process when the c...
std::vector< std::tuple< lldb_private::ConstString, lldb::addr_t > > segment_load_addresses
lldb_private::SectionList & UnifiedList
SegmentParsingContext(EncryptedFileRanges EncryptedRanges, lldb_private::SectionList &UnifiedList)
TrieEntryWithOffset(lldb::offset_t offset)
void Dump(uint32_t idx) const
bool operator<(const TrieEntryWithOffset &other) const
void Dump() const
ConstString name
ConstString import_name
uint32_t segment_count
uint64_t load_address
uint64_t filepath_offset
image_entry(const image_entry &rhs)
uint32_t unused
uint64_t seg_addrs_offset
uuid_t uuid
image_entry()
BaseType GetRangeBase() const
Definition RangeMap.h:45
SizeType GetByteSize() const
Definition RangeMap.h:87
void SetRangeBase(BaseType b)
Set the start value for the range, and keep the same size.
Definition RangeMap.h:48
void SetByteSize(SizeType s)
Definition RangeMap.h:89
Every register is described in detail including its name, alternate name (optional),...
uint32_t byte_size
Size in bytes of the register.
segment_vmaddr(const segment_vmaddr &rhs)