object/write/
macho.rs

1use core::mem;
2
3use crate::endian::*;
4use crate::macho;
5use crate::write::string::*;
6use crate::write::util::*;
7use crate::write::*;
8
9#[derive(Default, Clone, Copy)]
10struct SectionOffsets {
11    index: usize,
12    offset: usize,
13    address: u64,
14    reloc_offset: usize,
15    reloc_count: usize,
16}
17
18#[derive(Default, Clone, Copy)]
19struct SymbolOffsets {
20    index: usize,
21    str_id: Option<StringId>,
22}
23
24/// The customizable portion of a [`macho::BuildVersionCommand`].
25#[derive(Debug, Default, Clone, Copy)]
26#[non_exhaustive] // May want to add the tool list?
27pub struct MachOBuildVersion {
28    /// One of the `PLATFORM_` constants (for example,
29    /// [`object::macho::PLATFORM_MACOS`](macho::PLATFORM_MACOS)).
30    pub platform: u32,
31    /// The minimum OS version, where `X.Y.Z` is encoded in nibbles as
32    /// `xxxx.yy.zz`.
33    pub minos: u32,
34    /// The SDK version as `X.Y.Z`, where `X.Y.Z` is encoded in nibbles as
35    /// `xxxx.yy.zz`.
36    pub sdk: u32,
37}
38
39impl MachOBuildVersion {
40    fn cmdsize(&self) -> u32 {
41        // Same size for both endianness, and we don't have `ntools`.
42        let sz = mem::size_of::<macho::BuildVersionCommand<Endianness>>();
43        debug_assert!(sz <= u32::MAX as usize);
44        sz as u32
45    }
46}
47
48// Public methods.
49impl<'a> Object<'a> {
50    /// Specify the Mach-O CPU subtype.
51    ///
52    /// Requires `feature = "macho"`.
53    #[inline]
54    pub fn set_macho_cpu_subtype(&mut self, cpu_subtype: u32) {
55        self.macho_cpu_subtype = Some(cpu_subtype);
56    }
57
58    /// Specify information for a Mach-O `LC_BUILD_VERSION` command.
59    ///
60    /// Requires `feature = "macho"`.
61    #[inline]
62    pub fn set_macho_build_version(&mut self, info: MachOBuildVersion) {
63        self.macho_build_version = Some(info);
64    }
65}
66
67// Private methods.
68impl<'a> Object<'a> {
69    pub(crate) fn macho_segment_name(&self, segment: StandardSegment) -> &'static [u8] {
70        match segment {
71            StandardSegment::Text => &b"__TEXT"[..],
72            StandardSegment::Data => &b"__DATA"[..],
73            StandardSegment::Debug => &b"__DWARF"[..],
74        }
75    }
76
77    pub(crate) fn macho_section_info(
78        &self,
79        section: StandardSection,
80    ) -> (&'static [u8], &'static [u8], SectionKind, SectionFlags) {
81        match section {
82            StandardSection::Text => (
83                &b"__TEXT"[..],
84                &b"__text"[..],
85                SectionKind::Text,
86                SectionFlags::None,
87            ),
88            StandardSection::Data => (
89                &b"__DATA"[..],
90                &b"__data"[..],
91                SectionKind::Data,
92                SectionFlags::None,
93            ),
94            StandardSection::ReadOnlyData => (
95                &b"__TEXT"[..],
96                &b"__const"[..],
97                SectionKind::ReadOnlyData,
98                SectionFlags::None,
99            ),
100            StandardSection::ReadOnlyDataWithRel => (
101                &b"__DATA"[..],
102                &b"__const"[..],
103                SectionKind::ReadOnlyDataWithRel,
104                SectionFlags::None,
105            ),
106            StandardSection::ReadOnlyString => (
107                &b"__TEXT"[..],
108                &b"__cstring"[..],
109                SectionKind::ReadOnlyString,
110                SectionFlags::None,
111            ),
112            StandardSection::UninitializedData => (
113                &b"__DATA"[..],
114                &b"__bss"[..],
115                SectionKind::UninitializedData,
116                SectionFlags::None,
117            ),
118            StandardSection::Tls => (
119                &b"__DATA"[..],
120                &b"__thread_data"[..],
121                SectionKind::Tls,
122                SectionFlags::None,
123            ),
124            StandardSection::UninitializedTls => (
125                &b"__DATA"[..],
126                &b"__thread_bss"[..],
127                SectionKind::UninitializedTls,
128                SectionFlags::None,
129            ),
130            StandardSection::TlsVariables => (
131                &b"__DATA"[..],
132                &b"__thread_vars"[..],
133                SectionKind::TlsVariables,
134                SectionFlags::None,
135            ),
136            StandardSection::Common => (
137                &b"__DATA"[..],
138                &b"__common"[..],
139                SectionKind::Common,
140                SectionFlags::None,
141            ),
142            StandardSection::GnuProperty => {
143                // Unsupported section.
144                (&[], &[], SectionKind::Note, SectionFlags::None)
145            }
146        }
147    }
148
149    fn macho_tlv_bootstrap(&mut self) -> SymbolId {
150        match self.tlv_bootstrap {
151            Some(id) => id,
152            None => {
153                let id = self.add_symbol(Symbol {
154                    name: b"_tlv_bootstrap".to_vec(),
155                    value: 0,
156                    size: 0,
157                    kind: SymbolKind::Text,
158                    scope: SymbolScope::Dynamic,
159                    weak: false,
160                    section: SymbolSection::Undefined,
161                    flags: SymbolFlags::None,
162                });
163                self.tlv_bootstrap = Some(id);
164                id
165            }
166        }
167    }
168
169    /// Create the `__thread_vars` entry for a TLS variable.
170    ///
171    /// The symbol given by `symbol_id` will be updated to point to this entry.
172    ///
173    /// A new `SymbolId` will be returned. The caller must update this symbol
174    /// to point to the initializer.
175    ///
176    /// If `symbol_id` is not for a TLS variable, then it is returned unchanged.
177    pub(crate) fn macho_add_thread_var(&mut self, symbol_id: SymbolId) -> SymbolId {
178        let symbol = self.symbol_mut(symbol_id);
179        if symbol.kind != SymbolKind::Tls {
180            return symbol_id;
181        }
182
183        // Create the initializer symbol.
184        let mut name = symbol.name.clone();
185        name.extend_from_slice(b"$tlv$init");
186        let init_symbol_id = self.add_raw_symbol(Symbol {
187            name,
188            value: 0,
189            size: 0,
190            kind: SymbolKind::Tls,
191            scope: SymbolScope::Compilation,
192            weak: false,
193            section: SymbolSection::Undefined,
194            flags: SymbolFlags::None,
195        });
196
197        // Add the tlv entry.
198        // Three pointers in size:
199        //   - __tlv_bootstrap - used to make sure support exists
200        //   - spare pointer - used when mapped by the runtime
201        //   - pointer to symbol initializer
202        let section = self.section_id(StandardSection::TlsVariables);
203        let address_size = self.architecture.address_size().unwrap().bytes();
204        let size = u64::from(address_size) * 3;
205        let data = vec![0; size as usize];
206        let offset = self.append_section_data(section, &data, u64::from(address_size));
207
208        let tlv_bootstrap = self.macho_tlv_bootstrap();
209        self.add_relocation(
210            section,
211            Relocation {
212                offset,
213                symbol: tlv_bootstrap,
214                addend: 0,
215                flags: RelocationFlags::Generic {
216                    kind: RelocationKind::Absolute,
217                    encoding: RelocationEncoding::Generic,
218                    size: address_size * 8,
219                },
220            },
221        )
222        .unwrap();
223        self.add_relocation(
224            section,
225            Relocation {
226                offset: offset + u64::from(address_size) * 2,
227                symbol: init_symbol_id,
228                addend: 0,
229                flags: RelocationFlags::Generic {
230                    kind: RelocationKind::Absolute,
231                    encoding: RelocationEncoding::Generic,
232                    size: address_size * 8,
233                },
234            },
235        )
236        .unwrap();
237
238        // Update the symbol to point to the tlv.
239        let symbol = self.symbol_mut(symbol_id);
240        symbol.value = offset;
241        symbol.size = size;
242        symbol.section = SymbolSection::Section(section);
243
244        init_symbol_id
245    }
246
247    pub(crate) fn macho_translate_relocation(&mut self, reloc: &mut Relocation) -> Result<()> {
248        use RelocationEncoding as E;
249        use RelocationKind as K;
250
251        let (kind, encoding, mut size) = if let RelocationFlags::Generic {
252            kind,
253            encoding,
254            size,
255        } = reloc.flags
256        {
257            (kind, encoding, size)
258        } else {
259            return Ok(());
260        };
261        // Aarch64 relocs of these sizes act as if they are double-word length
262        if self.architecture == Architecture::Aarch64 && matches!(size, 12 | 21 | 26) {
263            size = 32;
264        }
265        let r_length = match size {
266            8 => 0,
267            16 => 1,
268            32 => 2,
269            64 => 3,
270            _ => return Err(Error(format!("unimplemented reloc size {:?}", reloc))),
271        };
272        let unsupported_reloc = || Err(Error(format!("unimplemented relocation {:?}", reloc)));
273        let (r_pcrel, r_type) = match self.architecture {
274            Architecture::I386 => match kind {
275                K::Absolute => (false, macho::GENERIC_RELOC_VANILLA),
276                _ => return unsupported_reloc(),
277            },
278            Architecture::X86_64 => match (kind, encoding) {
279                (K::Absolute, E::Generic) => (false, macho::X86_64_RELOC_UNSIGNED),
280                (K::Relative, E::Generic) => (true, macho::X86_64_RELOC_SIGNED),
281                (K::Relative, E::X86RipRelative) => (true, macho::X86_64_RELOC_SIGNED),
282                (K::Relative, E::X86Branch) => (true, macho::X86_64_RELOC_BRANCH),
283                (K::PltRelative, E::X86Branch) => (true, macho::X86_64_RELOC_BRANCH),
284                (K::GotRelative, E::Generic) => (true, macho::X86_64_RELOC_GOT),
285                (K::GotRelative, E::X86RipRelativeMovq) => (true, macho::X86_64_RELOC_GOT_LOAD),
286                _ => return unsupported_reloc(),
287            },
288            Architecture::Aarch64 | Architecture::Aarch64_Ilp32 => match (kind, encoding) {
289                (K::Absolute, E::Generic) => (false, macho::ARM64_RELOC_UNSIGNED),
290                (K::Relative, E::AArch64Call) => (true, macho::ARM64_RELOC_BRANCH26),
291                _ => return unsupported_reloc(),
292            },
293            _ => {
294                return Err(Error(format!(
295                    "unimplemented architecture {:?}",
296                    self.architecture
297                )));
298            }
299        };
300        reloc.flags = RelocationFlags::MachO {
301            r_type,
302            r_pcrel,
303            r_length,
304        };
305        Ok(())
306    }
307
308    pub(crate) fn macho_adjust_addend(&mut self, relocation: &mut Relocation) -> Result<bool> {
309        let (r_type, r_pcrel) = if let RelocationFlags::MachO {
310            r_type, r_pcrel, ..
311        } = relocation.flags
312        {
313            (r_type, r_pcrel)
314        } else {
315            return Err(Error(format!("invalid relocation flags {:?}", relocation)));
316        };
317        if r_pcrel {
318            // For PC relative relocations on some architectures, the
319            // addend does not include the offset required due to the
320            // PC being different from the place of the relocation.
321            // This differs from other file formats, so adjust the
322            // addend here to account for this.
323            let pcrel_offset = match self.architecture {
324                Architecture::I386 => 4,
325                Architecture::X86_64 => match r_type {
326                    macho::X86_64_RELOC_SIGNED_1 => 5,
327                    macho::X86_64_RELOC_SIGNED_2 => 6,
328                    macho::X86_64_RELOC_SIGNED_4 => 8,
329                    _ => 4,
330                },
331                // TODO: maybe missing support for some architectures and relocations
332                _ => 0,
333            };
334            relocation.addend += pcrel_offset;
335        }
336        // Determine if addend is implicit.
337        let implicit = if self.architecture == Architecture::Aarch64 {
338            match r_type {
339                macho::ARM64_RELOC_BRANCH26
340                | macho::ARM64_RELOC_PAGE21
341                | macho::ARM64_RELOC_PAGEOFF12 => false,
342                _ => true,
343            }
344        } else {
345            true
346        };
347        Ok(implicit)
348    }
349
350    pub(crate) fn macho_relocation_size(&self, reloc: &Relocation) -> Result<u8> {
351        if let RelocationFlags::MachO { r_length, .. } = reloc.flags {
352            Ok(8 << r_length)
353        } else {
354            Err(Error("invalid relocation flags".into()))
355        }
356    }
357
358    pub(crate) fn macho_write(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
359        let address_size = self.architecture.address_size().unwrap();
360        let endian = self.endian;
361        let macho32 = MachO32 { endian };
362        let macho64 = MachO64 { endian };
363        let macho: &dyn MachO = match address_size {
364            AddressSize::U8 | AddressSize::U16 | AddressSize::U32 => &macho32,
365            AddressSize::U64 => &macho64,
366        };
367        let pointer_align = address_size.bytes() as usize;
368
369        // Calculate offsets of everything, and build strtab.
370        let mut offset = 0;
371
372        // Calculate size of Mach-O header.
373        offset += macho.mach_header_size();
374
375        // Calculate size of commands.
376        let mut ncmds = 0;
377        let command_offset = offset;
378
379        // Calculate size of segment command and section headers.
380        let segment_command_offset = offset;
381        let segment_command_len =
382            macho.segment_command_size() + self.sections.len() * macho.section_header_size();
383        offset += segment_command_len;
384        ncmds += 1;
385
386        // Calculate size of build version.
387        let build_version_offset = offset;
388        if let Some(version) = &self.macho_build_version {
389            offset += version.cmdsize() as usize;
390            ncmds += 1;
391        }
392
393        // Calculate size of symtab command.
394        let symtab_command_offset = offset;
395        let symtab_command_len = mem::size_of::<macho::SymtabCommand<Endianness>>();
396        offset += symtab_command_len;
397        ncmds += 1;
398
399        // Calculate size of dysymtab command.
400        let dysymtab_command_offset = offset;
401        let dysymtab_command_len = mem::size_of::<macho::DysymtabCommand<Endianness>>();
402        offset += dysymtab_command_len;
403        ncmds += 1;
404
405        let sizeofcmds = offset - command_offset;
406
407        // Calculate size of section data.
408        // Section data can immediately follow the load commands without any alignment padding.
409        let segment_file_offset = offset;
410        let mut section_offsets = vec![SectionOffsets::default(); self.sections.len()];
411        let mut address = 0;
412        for (index, section) in self.sections.iter().enumerate() {
413            section_offsets[index].index = 1 + index;
414            if !section.is_bss() {
415                address = align_u64(address, section.align);
416                section_offsets[index].address = address;
417                section_offsets[index].offset = segment_file_offset + address as usize;
418                address += section.size;
419            }
420        }
421        let segment_file_size = address as usize;
422        offset += address as usize;
423        for (index, section) in self.sections.iter().enumerate() {
424            if section.is_bss() {
425                debug_assert!(section.data.is_empty());
426                address = align_u64(address, section.align);
427                section_offsets[index].address = address;
428                address += section.size;
429            }
430        }
431
432        // Partition symbols and add symbol strings to strtab.
433        let mut strtab = StringTable::default();
434        let mut symbol_offsets = vec![SymbolOffsets::default(); self.symbols.len()];
435        let mut local_symbols = vec![];
436        let mut external_symbols = vec![];
437        let mut undefined_symbols = vec![];
438        for (index, symbol) in self.symbols.iter().enumerate() {
439            // The unified API allows creating symbols that we don't emit, so filter
440            // them out here.
441            //
442            // Since we don't actually emit the symbol kind, we validate it here too.
443            match symbol.kind {
444                SymbolKind::Text | SymbolKind::Data | SymbolKind::Tls | SymbolKind::Unknown => {}
445                SymbolKind::File | SymbolKind::Section => continue,
446                SymbolKind::Label => {
447                    return Err(Error(format!(
448                        "unimplemented symbol `{}` kind {:?}",
449                        symbol.name().unwrap_or(""),
450                        symbol.kind
451                    )));
452                }
453            }
454            if !symbol.name.is_empty() {
455                symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
456            }
457            if symbol.is_undefined() {
458                undefined_symbols.push(index);
459            } else if symbol.is_local() {
460                local_symbols.push(index);
461            } else {
462                external_symbols.push(index);
463            }
464        }
465
466        external_symbols.sort_by_key(|index| &*self.symbols[*index].name);
467        undefined_symbols.sort_by_key(|index| &*self.symbols[*index].name);
468
469        // Count symbols.
470        let mut nsyms = 0;
471        for index in local_symbols
472            .iter()
473            .copied()
474            .chain(external_symbols.iter().copied())
475            .chain(undefined_symbols.iter().copied())
476        {
477            symbol_offsets[index].index = nsyms;
478            nsyms += 1;
479        }
480
481        // Calculate size of relocations.
482        for (index, section) in self.sections.iter().enumerate() {
483            let count: usize = section
484                .relocations
485                .iter()
486                .map(|reloc| 1 + usize::from(reloc.addend != 0))
487                .sum();
488            if count != 0 {
489                offset = align(offset, pointer_align);
490                section_offsets[index].reloc_offset = offset;
491                section_offsets[index].reloc_count = count;
492                let len = count * mem::size_of::<macho::Relocation<Endianness>>();
493                offset += len;
494            }
495        }
496
497        // Calculate size of symtab.
498        offset = align(offset, pointer_align);
499        let symtab_offset = offset;
500        let symtab_len = nsyms * macho.nlist_size();
501        offset += symtab_len;
502
503        // Calculate size of strtab.
504        let strtab_offset = offset;
505        // Start with null name.
506        let mut strtab_data = vec![0];
507        strtab.write(1, &mut strtab_data);
508        write_align(&mut strtab_data, pointer_align);
509        offset += strtab_data.len();
510
511        // Start writing.
512        buffer
513            .reserve(offset)
514            .map_err(|_| Error(String::from("Cannot allocate buffer")))?;
515
516        // Write file header.
517        let (cputype, mut cpusubtype) = match (self.architecture, self.sub_architecture) {
518            (Architecture::Arm, None) => (macho::CPU_TYPE_ARM, macho::CPU_SUBTYPE_ARM_ALL),
519            (Architecture::Aarch64, None) => (macho::CPU_TYPE_ARM64, macho::CPU_SUBTYPE_ARM64_ALL),
520            (Architecture::Aarch64, Some(SubArchitecture::Arm64E)) => {
521                (macho::CPU_TYPE_ARM64, macho::CPU_SUBTYPE_ARM64E)
522            }
523            (Architecture::Aarch64_Ilp32, None) => {
524                (macho::CPU_TYPE_ARM64_32, macho::CPU_SUBTYPE_ARM64_32_V8)
525            }
526            (Architecture::I386, None) => (macho::CPU_TYPE_X86, macho::CPU_SUBTYPE_I386_ALL),
527            (Architecture::X86_64, None) => (macho::CPU_TYPE_X86_64, macho::CPU_SUBTYPE_X86_64_ALL),
528            (Architecture::PowerPc, None) => {
529                (macho::CPU_TYPE_POWERPC, macho::CPU_SUBTYPE_POWERPC_ALL)
530            }
531            (Architecture::PowerPc64, None) => {
532                (macho::CPU_TYPE_POWERPC64, macho::CPU_SUBTYPE_POWERPC_ALL)
533            }
534            _ => {
535                return Err(Error(format!(
536                    "unimplemented architecture {:?} with sub-architecture {:?}",
537                    self.architecture, self.sub_architecture
538                )));
539            }
540        };
541
542        if let Some(cpu_subtype) = self.macho_cpu_subtype {
543            cpusubtype = cpu_subtype;
544        }
545
546        let mut flags = match self.flags {
547            FileFlags::MachO { flags } => flags,
548            _ => 0,
549        };
550        if self.macho_subsections_via_symbols {
551            flags |= macho::MH_SUBSECTIONS_VIA_SYMBOLS;
552        }
553        macho.write_mach_header(
554            buffer,
555            MachHeader {
556                cputype,
557                cpusubtype,
558                filetype: macho::MH_OBJECT,
559                ncmds,
560                sizeofcmds: sizeofcmds as u32,
561                flags,
562            },
563        );
564
565        // Write segment command.
566        debug_assert_eq!(segment_command_offset, buffer.len());
567        macho.write_segment_command(
568            buffer,
569            SegmentCommand {
570                cmdsize: segment_command_len as u32,
571                segname: [0; 16],
572                vmaddr: 0,
573                vmsize: address,
574                fileoff: segment_file_offset as u64,
575                filesize: segment_file_size as u64,
576                maxprot: macho::VM_PROT_READ | macho::VM_PROT_WRITE | macho::VM_PROT_EXECUTE,
577                initprot: macho::VM_PROT_READ | macho::VM_PROT_WRITE | macho::VM_PROT_EXECUTE,
578                nsects: self.sections.len() as u32,
579                flags: 0,
580            },
581        );
582
583        // Write section headers.
584        for (index, section) in self.sections.iter().enumerate() {
585            let mut sectname = [0; 16];
586            sectname
587                .get_mut(..section.name.len())
588                .ok_or_else(|| {
589                    Error(format!(
590                        "section name `{}` is too long",
591                        section.name().unwrap_or(""),
592                    ))
593                })?
594                .copy_from_slice(&section.name);
595            let mut segname = [0; 16];
596            segname
597                .get_mut(..section.segment.len())
598                .ok_or_else(|| {
599                    Error(format!(
600                        "segment name `{}` is too long",
601                        section.segment().unwrap_or(""),
602                    ))
603                })?
604                .copy_from_slice(&section.segment);
605            let flags = if let SectionFlags::MachO { flags } = section.flags {
606                flags
607            } else {
608                match section.kind {
609                    SectionKind::Text => {
610                        macho::S_ATTR_PURE_INSTRUCTIONS | macho::S_ATTR_SOME_INSTRUCTIONS
611                    }
612                    SectionKind::Data => 0,
613                    SectionKind::ReadOnlyData | SectionKind::ReadOnlyDataWithRel => 0,
614                    SectionKind::ReadOnlyString => macho::S_CSTRING_LITERALS,
615                    SectionKind::UninitializedData | SectionKind::Common => macho::S_ZEROFILL,
616                    SectionKind::Tls => macho::S_THREAD_LOCAL_REGULAR,
617                    SectionKind::UninitializedTls => macho::S_THREAD_LOCAL_ZEROFILL,
618                    SectionKind::TlsVariables => macho::S_THREAD_LOCAL_VARIABLES,
619                    SectionKind::Debug | SectionKind::DebugString => macho::S_ATTR_DEBUG,
620                    SectionKind::OtherString => macho::S_CSTRING_LITERALS,
621                    SectionKind::Other | SectionKind::Linker | SectionKind::Metadata => 0,
622                    SectionKind::Note | SectionKind::Unknown | SectionKind::Elf(_) => {
623                        return Err(Error(format!(
624                            "unimplemented section `{}` kind {:?}",
625                            section.name().unwrap_or(""),
626                            section.kind
627                        )));
628                    }
629                }
630            };
631            macho.write_section(
632                buffer,
633                SectionHeader {
634                    sectname,
635                    segname,
636                    addr: section_offsets[index].address,
637                    size: section.size,
638                    offset: section_offsets[index].offset as u32,
639                    align: section.align.trailing_zeros(),
640                    reloff: section_offsets[index].reloc_offset as u32,
641                    nreloc: section_offsets[index].reloc_count as u32,
642                    flags,
643                },
644            );
645        }
646
647        // Write build version.
648        if let Some(version) = &self.macho_build_version {
649            debug_assert_eq!(build_version_offset, buffer.len());
650            buffer.write(&macho::BuildVersionCommand {
651                cmd: U32::new(endian, macho::LC_BUILD_VERSION),
652                cmdsize: U32::new(endian, version.cmdsize()),
653                platform: U32::new(endian, version.platform),
654                minos: U32::new(endian, version.minos),
655                sdk: U32::new(endian, version.sdk),
656                ntools: U32::new(endian, 0),
657            });
658        }
659
660        // Write symtab command.
661        debug_assert_eq!(symtab_command_offset, buffer.len());
662        let symtab_command = macho::SymtabCommand {
663            cmd: U32::new(endian, macho::LC_SYMTAB),
664            cmdsize: U32::new(endian, symtab_command_len as u32),
665            symoff: U32::new(endian, symtab_offset as u32),
666            nsyms: U32::new(endian, nsyms as u32),
667            stroff: U32::new(endian, strtab_offset as u32),
668            strsize: U32::new(endian, strtab_data.len() as u32),
669        };
670        buffer.write(&symtab_command);
671
672        // Write dysymtab command.
673        debug_assert_eq!(dysymtab_command_offset, buffer.len());
674        let dysymtab_command = macho::DysymtabCommand {
675            cmd: U32::new(endian, macho::LC_DYSYMTAB),
676            cmdsize: U32::new(endian, dysymtab_command_len as u32),
677            ilocalsym: U32::new(endian, 0),
678            nlocalsym: U32::new(endian, local_symbols.len() as u32),
679            iextdefsym: U32::new(endian, local_symbols.len() as u32),
680            nextdefsym: U32::new(endian, external_symbols.len() as u32),
681            iundefsym: U32::new(
682                endian,
683                local_symbols.len() as u32 + external_symbols.len() as u32,
684            ),
685            nundefsym: U32::new(endian, undefined_symbols.len() as u32),
686            tocoff: U32::default(),
687            ntoc: U32::default(),
688            modtaboff: U32::default(),
689            nmodtab: U32::default(),
690            extrefsymoff: U32::default(),
691            nextrefsyms: U32::default(),
692            indirectsymoff: U32::default(),
693            nindirectsyms: U32::default(),
694            extreloff: U32::default(),
695            nextrel: U32::default(),
696            locreloff: U32::default(),
697            nlocrel: U32::default(),
698        };
699        buffer.write(&dysymtab_command);
700
701        // Write section data.
702        for (index, section) in self.sections.iter().enumerate() {
703            if !section.is_bss() {
704                buffer.resize(section_offsets[index].offset);
705                buffer.write_bytes(&section.data);
706            }
707        }
708        debug_assert_eq!(segment_file_offset + segment_file_size, buffer.len());
709
710        // Write relocations.
711        for (index, section) in self.sections.iter().enumerate() {
712            if !section.relocations.is_empty() {
713                write_align(buffer, pointer_align);
714                debug_assert_eq!(section_offsets[index].reloc_offset, buffer.len());
715
716                let mut write_reloc = |reloc: &Relocation| {
717                    let (r_type, r_pcrel, r_length) = if let RelocationFlags::MachO {
718                        r_type,
719                        r_pcrel,
720                        r_length,
721                    } = reloc.flags
722                    {
723                        (r_type, r_pcrel, r_length)
724                    } else {
725                        return Err(Error("invalid relocation flags".into()));
726                    };
727
728                    // Write explicit addend.
729                    if reloc.addend != 0 {
730                        let r_type = match self.architecture {
731                            Architecture::Aarch64 | Architecture::Aarch64_Ilp32 => {
732                                macho::ARM64_RELOC_ADDEND
733                            }
734                            _ => {
735                                return Err(Error(format!("unimplemented relocation {:?}", reloc)))
736                            }
737                        };
738
739                        let reloc_info = macho::RelocationInfo {
740                            r_address: reloc.offset as u32,
741                            r_symbolnum: reloc.addend as u32,
742                            r_pcrel: false,
743                            r_length,
744                            r_extern: false,
745                            r_type,
746                        };
747                        buffer.write(&reloc_info.relocation(endian));
748                    }
749
750                    let r_extern;
751                    let r_symbolnum;
752                    let symbol = &self.symbols[reloc.symbol.0];
753                    if symbol.kind == SymbolKind::Section {
754                        r_symbolnum = section_offsets[symbol.section.id().unwrap().0].index as u32;
755                        r_extern = false;
756                    } else {
757                        r_symbolnum = symbol_offsets[reloc.symbol.0].index as u32;
758                        r_extern = true;
759                    }
760
761                    let reloc_info = macho::RelocationInfo {
762                        r_address: reloc.offset as u32,
763                        r_symbolnum,
764                        r_pcrel,
765                        r_length,
766                        r_extern,
767                        r_type,
768                    };
769                    buffer.write(&reloc_info.relocation(endian));
770                    Ok(())
771                };
772
773                // Relocations are emitted in descending order as otherwise Apple's
774                // new linker crashes. This matches LLVM's behavior too:
775                // https://github.com/llvm/llvm-project/blob/e9b8cd0c8/llvm/lib/MC/MachObjectWriter.cpp#L1001-L1002
776                let need_reverse = |relocs: &[Relocation]| {
777                    let Some(first) = relocs.first() else {
778                        return false;
779                    };
780                    let Some(last) = relocs.last() else {
781                        return false;
782                    };
783                    first.offset < last.offset
784                };
785                if need_reverse(&section.relocations) {
786                    for reloc in section.relocations.iter().rev() {
787                        write_reloc(reloc)?;
788                    }
789                } else {
790                    for reloc in &section.relocations {
791                        write_reloc(reloc)?;
792                    }
793                }
794            }
795        }
796
797        // Write symtab.
798        write_align(buffer, pointer_align);
799        debug_assert_eq!(symtab_offset, buffer.len());
800        for index in local_symbols
801            .iter()
802            .copied()
803            .chain(external_symbols.iter().copied())
804            .chain(undefined_symbols.iter().copied())
805        {
806            let symbol = &self.symbols[index];
807            // TODO: N_STAB
808            let (mut n_type, n_sect) = match symbol.section {
809                SymbolSection::Undefined => (macho::N_UNDF | macho::N_EXT, 0),
810                SymbolSection::Absolute => (macho::N_ABS, 0),
811                SymbolSection::Section(id) => (macho::N_SECT, id.0 + 1),
812                SymbolSection::None | SymbolSection::Common => {
813                    return Err(Error(format!(
814                        "unimplemented symbol `{}` section {:?}",
815                        symbol.name().unwrap_or(""),
816                        symbol.section
817                    )));
818                }
819            };
820            match symbol.scope {
821                SymbolScope::Unknown | SymbolScope::Compilation => {}
822                SymbolScope::Linkage => {
823                    n_type |= macho::N_EXT | macho::N_PEXT;
824                }
825                SymbolScope::Dynamic => {
826                    n_type |= macho::N_EXT;
827                }
828            }
829
830            let n_desc = if let SymbolFlags::MachO { n_desc } = symbol.flags {
831                n_desc
832            } else {
833                let mut n_desc = 0;
834                if symbol.weak {
835                    if symbol.is_undefined() {
836                        n_desc |= macho::N_WEAK_REF;
837                    } else {
838                        n_desc |= macho::N_WEAK_DEF;
839                    }
840                }
841                n_desc
842            };
843
844            let n_value = match symbol.section.id() {
845                Some(section) => section_offsets[section.0].address + symbol.value,
846                None => symbol.value,
847            };
848
849            let n_strx = symbol_offsets[index]
850                .str_id
851                .map(|id| strtab.get_offset(id))
852                .unwrap_or(0);
853
854            macho.write_nlist(
855                buffer,
856                Nlist {
857                    n_strx: n_strx as u32,
858                    n_type,
859                    n_sect: n_sect as u8,
860                    n_desc,
861                    n_value,
862                },
863            );
864        }
865
866        // Write strtab.
867        debug_assert_eq!(strtab_offset, buffer.len());
868        buffer.write_bytes(&strtab_data);
869
870        debug_assert_eq!(offset, buffer.len());
871
872        Ok(())
873    }
874}
875
876struct MachHeader {
877    cputype: u32,
878    cpusubtype: u32,
879    filetype: u32,
880    ncmds: u32,
881    sizeofcmds: u32,
882    flags: u32,
883}
884
885struct SegmentCommand {
886    cmdsize: u32,
887    segname: [u8; 16],
888    vmaddr: u64,
889    vmsize: u64,
890    fileoff: u64,
891    filesize: u64,
892    maxprot: u32,
893    initprot: u32,
894    nsects: u32,
895    flags: u32,
896}
897
898pub struct SectionHeader {
899    sectname: [u8; 16],
900    segname: [u8; 16],
901    addr: u64,
902    size: u64,
903    offset: u32,
904    align: u32,
905    reloff: u32,
906    nreloc: u32,
907    flags: u32,
908}
909
910struct Nlist {
911    n_strx: u32,
912    n_type: u8,
913    n_sect: u8,
914    n_desc: u16,
915    n_value: u64,
916}
917
918trait MachO {
919    fn mach_header_size(&self) -> usize;
920    fn segment_command_size(&self) -> usize;
921    fn section_header_size(&self) -> usize;
922    fn nlist_size(&self) -> usize;
923    fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, section: MachHeader);
924    fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand);
925    fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader);
926    fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist);
927}
928
929struct MachO32<E> {
930    endian: E,
931}
932
933impl<E: Endian> MachO for MachO32<E> {
934    fn mach_header_size(&self) -> usize {
935        mem::size_of::<macho::MachHeader32<E>>()
936    }
937
938    fn segment_command_size(&self) -> usize {
939        mem::size_of::<macho::SegmentCommand32<E>>()
940    }
941
942    fn section_header_size(&self) -> usize {
943        mem::size_of::<macho::Section32<E>>()
944    }
945
946    fn nlist_size(&self) -> usize {
947        mem::size_of::<macho::Nlist32<E>>()
948    }
949
950    fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, header: MachHeader) {
951        let endian = self.endian;
952        let magic = if endian.is_big_endian() {
953            macho::MH_MAGIC
954        } else {
955            macho::MH_CIGAM
956        };
957        let header = macho::MachHeader32 {
958            magic: U32::new(BigEndian, magic),
959            cputype: U32::new(endian, header.cputype),
960            cpusubtype: U32::new(endian, header.cpusubtype),
961            filetype: U32::new(endian, header.filetype),
962            ncmds: U32::new(endian, header.ncmds),
963            sizeofcmds: U32::new(endian, header.sizeofcmds),
964            flags: U32::new(endian, header.flags),
965        };
966        buffer.write(&header);
967    }
968
969    fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand) {
970        let endian = self.endian;
971        let segment = macho::SegmentCommand32 {
972            cmd: U32::new(endian, macho::LC_SEGMENT),
973            cmdsize: U32::new(endian, segment.cmdsize),
974            segname: segment.segname,
975            vmaddr: U32::new(endian, segment.vmaddr as u32),
976            vmsize: U32::new(endian, segment.vmsize as u32),
977            fileoff: U32::new(endian, segment.fileoff as u32),
978            filesize: U32::new(endian, segment.filesize as u32),
979            maxprot: U32::new(endian, segment.maxprot),
980            initprot: U32::new(endian, segment.initprot),
981            nsects: U32::new(endian, segment.nsects),
982            flags: U32::new(endian, segment.flags),
983        };
984        buffer.write(&segment);
985    }
986
987    fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
988        let endian = self.endian;
989        let section = macho::Section32 {
990            sectname: section.sectname,
991            segname: section.segname,
992            addr: U32::new(endian, section.addr as u32),
993            size: U32::new(endian, section.size as u32),
994            offset: U32::new(endian, section.offset),
995            align: U32::new(endian, section.align),
996            reloff: U32::new(endian, section.reloff),
997            nreloc: U32::new(endian, section.nreloc),
998            flags: U32::new(endian, section.flags),
999            reserved1: U32::default(),
1000            reserved2: U32::default(),
1001        };
1002        buffer.write(&section);
1003    }
1004
1005    fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist) {
1006        let endian = self.endian;
1007        let nlist = macho::Nlist32 {
1008            n_strx: U32::new(endian, nlist.n_strx),
1009            n_type: nlist.n_type,
1010            n_sect: nlist.n_sect,
1011            n_desc: U16::new(endian, nlist.n_desc),
1012            n_value: U32::new(endian, nlist.n_value as u32),
1013        };
1014        buffer.write(&nlist);
1015    }
1016}
1017
1018struct MachO64<E> {
1019    endian: E,
1020}
1021
1022impl<E: Endian> MachO for MachO64<E> {
1023    fn mach_header_size(&self) -> usize {
1024        mem::size_of::<macho::MachHeader64<E>>()
1025    }
1026
1027    fn segment_command_size(&self) -> usize {
1028        mem::size_of::<macho::SegmentCommand64<E>>()
1029    }
1030
1031    fn section_header_size(&self) -> usize {
1032        mem::size_of::<macho::Section64<E>>()
1033    }
1034
1035    fn nlist_size(&self) -> usize {
1036        mem::size_of::<macho::Nlist64<E>>()
1037    }
1038
1039    fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, header: MachHeader) {
1040        let endian = self.endian;
1041        let magic = if endian.is_big_endian() {
1042            macho::MH_MAGIC_64
1043        } else {
1044            macho::MH_CIGAM_64
1045        };
1046        let header = macho::MachHeader64 {
1047            magic: U32::new(BigEndian, magic),
1048            cputype: U32::new(endian, header.cputype),
1049            cpusubtype: U32::new(endian, header.cpusubtype),
1050            filetype: U32::new(endian, header.filetype),
1051            ncmds: U32::new(endian, header.ncmds),
1052            sizeofcmds: U32::new(endian, header.sizeofcmds),
1053            flags: U32::new(endian, header.flags),
1054            reserved: U32::default(),
1055        };
1056        buffer.write(&header);
1057    }
1058
1059    fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand) {
1060        let endian = self.endian;
1061        let segment = macho::SegmentCommand64 {
1062            cmd: U32::new(endian, macho::LC_SEGMENT_64),
1063            cmdsize: U32::new(endian, segment.cmdsize),
1064            segname: segment.segname,
1065            vmaddr: U64::new(endian, segment.vmaddr),
1066            vmsize: U64::new(endian, segment.vmsize),
1067            fileoff: U64::new(endian, segment.fileoff),
1068            filesize: U64::new(endian, segment.filesize),
1069            maxprot: U32::new(endian, segment.maxprot),
1070            initprot: U32::new(endian, segment.initprot),
1071            nsects: U32::new(endian, segment.nsects),
1072            flags: U32::new(endian, segment.flags),
1073        };
1074        buffer.write(&segment);
1075    }
1076
1077    fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
1078        let endian = self.endian;
1079        let section = macho::Section64 {
1080            sectname: section.sectname,
1081            segname: section.segname,
1082            addr: U64::new(endian, section.addr),
1083            size: U64::new(endian, section.size),
1084            offset: U32::new(endian, section.offset),
1085            align: U32::new(endian, section.align),
1086            reloff: U32::new(endian, section.reloff),
1087            nreloc: U32::new(endian, section.nreloc),
1088            flags: U32::new(endian, section.flags),
1089            reserved1: U32::default(),
1090            reserved2: U32::default(),
1091            reserved3: U32::default(),
1092        };
1093        buffer.write(&section);
1094    }
1095
1096    fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist) {
1097        let endian = self.endian;
1098        let nlist = macho::Nlist64 {
1099            n_strx: U32::new(endian, nlist.n_strx),
1100            n_type: nlist.n_type,
1101            n_sect: nlist.n_sect,
1102            n_desc: U16::new(endian, nlist.n_desc),
1103            n_value: U64Bytes::new(endian, nlist.n_value),
1104        };
1105        buffer.write(&nlist);
1106    }
1107}
object/write/macho.rs

object/write/
macho.rs
