fortrangoingonforty/afs-ld / faaa755

+    "-no_loh",

+            "-no_loh" => {

+                opts.no_loh = true;

+            }

+    #[test]

+    fn no_loh_flag_is_recorded() {

+        let opts = parse(&argv(&["-no_loh", "foo.o"])).unwrap();

+        assert!(opts.no_loh);

+    }

+

+    pub no_loh: bool,

+            no_loh: false,

+    Loh(loh::LohError),

+            LinkError::Loh(e) => write!(f, "{e}"),

+impl From<loh::LohError> for LinkError {

+    fn from(value: loh::LohError) -> Self {

+        LinkError::Loh(value)

+    }

+}

+

+        loh::relax_layout(&mut layout, &linkedit, !opts.no_loh)?;

+use std::collections::HashSet;

+use std::fmt;

+

+use crate::layout::Layout;

+use crate::macho::writer::LinkEditPlan;

+const NOP: u32 = 0xd503_201f;

+#[derive(Debug, Clone, PartialEq, Eq)]

+pub struct LohError(String);

+

+impl fmt::Display for LohError {

+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

+        write!(f, "LOH relaxation error: {}", self.0)

+    }

+}

+

+impl std::error::Error for LohError {}

+

+impl From<ReadError> for LohError {

+    fn from(value: ReadError) -> Self {

+        Self(value.to_string())

+    }

+}

+

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

+struct LocatedWord {

+    section_idx: usize,

+    atom_idx: usize,

+    word_off: usize,

+    addr: u64,

+    insn: u32,

+}

+

+pub fn relax_layout(

+    layout: &mut Layout,

+    linkedit: &LinkEditPlan,

+    enabled: bool,

+) -> Result<(), LohError> {

+    if !enabled || linkedit.loh.is_none() || linkedit.loh_bytes().is_empty() {

+        return Ok(());

+    }

+

+    let entries = parse_loh_blob(linkedit.loh_bytes())?;

+    let mut rewritten = HashSet::new();

+    for entry in entries {

+        if entry.kind != LOH_ARM64_ADRP_ADD || entry.args.len() != 2 {

+            continue;

+        }

+

+        let adrp_off = entry.args[0] as u64;

+        let add_off = entry.args[1] as u64;

+        if !rewritten.insert(adrp_off) || !rewritten.insert(add_off) {

+            continue;

+        }

+

+        let adrp = locate_word(layout, adrp_off)?;

+        let add = locate_word(layout, add_off)?;

+        let Some(target) = decode_adrp_add_target(adrp.insn, add.insn, adrp.addr) else {

+            continue;

+        };

+        let Some(adr) = encode_adr(target, adrp.addr, (adrp.insn & 0x1f) as u8) else {

+            continue;

+        };

+

+        write_word(layout, adrp, adr)?;

+        write_word(layout, add, NOP)?;

+    }

+    Ok(())

+}

+

+fn locate_word(layout: &Layout, file_offset: u64) -> Result<LocatedWord, LohError> {

+    for (section_idx, section) in layout.sections.iter().enumerate() {

+        for (atom_idx, atom) in section.atoms.iter().enumerate() {

+            let start = section.file_off + atom.offset;

+            let end = start + atom.data.len() as u64;

+            if !(start <= file_offset && file_offset + 4 <= end) {

+                continue;

+            }

+            let word_off = (file_offset - start) as usize;

+            let bytes = atom.data.get(word_off..word_off + 4).ok_or_else(|| {

+                LohError(format!(

+                    "instruction read OOB at file offset 0x{file_offset:x}"

+                ))

+            })?;

+            return Ok(LocatedWord {

+                section_idx,

+                atom_idx,

+                word_off,

+                addr: section.addr + atom.offset + word_off as u64,

+                insn: u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),

+            });

+        }

+    }

+    Err(LohError(format!(

+        "LOH instruction offset 0x{file_offset:x} did not resolve to an output atom"

+    )))

+}

+

+fn write_word(layout: &mut Layout, word: LocatedWord, insn: u32) -> Result<(), LohError> {

+    let atom = &mut layout.sections[word.section_idx].atoms[word.atom_idx];

+    let bytes = atom

+        .data

+        .get_mut(word.word_off..word.word_off + 4)

+        .ok_or_else(|| {

+            LohError(format!(

+                "instruction write OOB at section {} atom {} word {}",

+                word.section_idx, word.atom_idx, word.word_off

+            ))

+        })?;

+    bytes.copy_from_slice(&insn.to_le_bytes());

+    Ok(())

+}

+

+fn decode_adrp_add_target(adrp: u32, add: u32, place: u64) -> Option<u64> {

+    if !is_adrp(adrp) || !is_add_imm_64(add) {

+        return None;

+    }

+    let rd = (adrp & 0x1f) as u8;

+    let add_rd = (add & 0x1f) as u8;

+    let add_rn = ((add >> 5) & 0x1f) as u8;

+    if rd == 31 || add_rd != rd || add_rn != rd {

+        return None;

+    }

+    let adrp_immlo = ((adrp >> 29) & 0x3) as i64;

+    let adrp_immhi = ((adrp >> 5) & 0x7ffff) as i64;

+    let adrp_pages = sign_extend_21((adrp_immhi << 2) | adrp_immlo);

+    let adrp_base = ((place as i64) & !0xfff) + (adrp_pages << 12);

+    let low = ((add >> 10) & 0xfff) as u64;

+    Some((adrp_base as u64) + low)

+}

+

+fn encode_adr(target: u64, place: u64, reg: u8) -> Option<u32> {

+    if reg == 31 {

+        return None;

+    }

+    let delta = (target as i64).wrapping_sub(place as i64);

+    if !fits_signed(delta, 21) {

+        return None;

+    }

+    let encoded = (delta as u32) & 0x1f_ffff;

+    let immlo = encoded & 0x3;

+    let immhi = (encoded >> 2) & 0x7ffff;

+    Some(0x1000_0000 | (immlo << 29) | (immhi << 5) | reg as u32)

+}

+

+fn is_adrp(insn: u32) -> bool {

+    (insn & 0x9f00_0000) == 0x9000_0000

+}

+

+fn is_add_imm_64(insn: u32) -> bool {

+    (insn & 0xffc0_0000) == 0x9100_0000

+}

+

+fn fits_signed(value: i64, bits: u32) -> bool {

+    let min = -(1i64 << (bits - 1));

+    let max = (1i64 << (bits - 1)) - 1;

+    (min..=max).contains(&value)

+}

+

+fn sign_extend_21(value: i64) -> i64 {

+    if value & (1 << 20) != 0 {

+        value | !0x1f_ffff

+    } else {

+        value

+    }

+}

+

+

+    #[test]

+    fn encode_adr_round_trips_small_delta() {

+        let place = 0x1_0000_1000;

+        let target = place + 0x48;

+        let adr = encode_adr(target, place, 9).unwrap();

+        assert_eq!(adr & 0x1f, 9);

+        let immlo = ((adr >> 29) & 0x3) as i64;

+        let immhi = ((adr >> 5) & 0x7ffff) as i64;

+        let delta = sign_extend_21((immhi << 2) | immlo);

+        assert_eq!(place.wrapping_add_signed(delta), target);

+    }

+

+    pub fn loh_bytes(&self) -> &[u8] {

+        &self.loh_bytes

+    }

+  -no_loh                         Skip LOH relaxation

+#[test]

+fn no_loh_flag_links_successfully() {

+    if !have_xcrun() {

+        eprintln!("skipping: xcrun as unavailable");

+        return;

+    }

+

+    let exe = env!("CARGO_BIN_EXE_afs-ld");

+    let obj = match assemble_minimal_main("no-loh-main.o") {

+        Ok(obj) => obj,

+        Err(e) => {

+            eprintln!("skipping: assemble failed: {e}");

+            return;

+        }

+    };

+    let out_path = scratch("no-loh.out");

+    let out = Command::new(exe)

+        .arg("-no_loh")

+        .arg("-o")

+        .arg(&out_path)

+        .arg(&obj)

+        .output()

+        .expect("afs-ld should run");

+    assert!(

+        out.status.success(),

+        "-no_loh link should succeed:\nstderr:\n{}",

+        String::from_utf8_lossy(&out.stderr)

+    );

+    assert!(

+        out_path.is_file(),

+        "expected -no_loh link to produce {}",

+        out_path.display()

+    );

+

+    let _ = fs::remove_file(obj);

+    let _ = fs::remove_file(out_path);

+}

+

+fn is_adr(insn: u32) -> bool {

+    (insn & 0x9f00_0000) == 0x1000_0000

+}

+

+fn is_adrp(insn: u32) -> bool {

+    (insn & 0x9f00_0000) == 0x9000_0000

+}

+

+fn is_add_imm_64(insn: u32) -> bool {

+    (insn & 0xffc0_0000) == 0x9100_0000

+}

+

+fn decode_adr_target(insn: u32, place: u64) -> u64 {

+    let immlo = ((insn >> 29) & 0x3) as i64;

+    let immhi = ((insn >> 5) & 0x7ffff) as i64;

+    let delta = sign_extend_21((immhi << 2) | immlo);

+    place.wrapping_add_signed(delta)

+}

+

+#[test]

+fn linker_run_relaxes_adrp_add_loh_when_target_is_near() {

+    if !have_xcrun() {

+        eprintln!("skipping: xcrun unavailable");

+        return;

+    }

+

+    let obj = scratch("loh-relax-near.o");

+    let out = scratch("loh-relax-near.out");

+    let src = r#"

+        .section __TEXT,__text,regular,pure_instructions

+        .globl _main

+        .globl _target

+        _main:

+        Lloh0:

+            adrp x0, _target@PAGE

+        Lloh1:

+            add x0, x0, _target@PAGEOFF

+            mov w0, #0

+            ret

+        _target:

+            ret

+        .loh AdrpAdd Lloh0, Lloh1

+        .subsections_via_symbols

+    "#;

+    if let Err(e) = assemble(src, &obj) {

+        eprintln!("skipping: assemble failed: {e}");

+        return;

+    }

+

+    let opts = LinkOptions {

+        inputs: vec![obj.clone()],

+        output: Some(out.clone()),

+        kind: OutputKind::Executable,

+        ..LinkOptions::default()

+    };

+    Linker::run(&opts).unwrap();

+

+    let bytes = fs::read(&out).unwrap();

+    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();

+    let target_addr = symbol_values(&bytes)["_target"];

+    let first = read_insn(&text, 0).unwrap();

+    let second = read_insn(&text, 4).unwrap();

+    assert!(

+        is_adr(first),

+        "expected ADR after LOH relaxation, got {first:#010x}"

+    );

+    assert_eq!(second, 0xd503_201f, "expected NOP after LOH relaxation");

+    assert_eq!(decode_adr_target(first, text_addr), target_addr);

+

+    let _ = fs::remove_file(obj);

+    let _ = fs::remove_file(out);

+}

+

+#[test]

+fn linker_run_keeps_adrp_add_loh_when_target_is_far() {

+    if !have_xcrun() {

+        eprintln!("skipping: xcrun unavailable");

+        return;

+    }

+

+    let obj = scratch("loh-relax-far.o");

+    let out = scratch("loh-relax-far.out");

+    let src = r#"

+        .section __TEXT,__text,regular,pure_instructions

+        .globl _main

+        .globl _target

+        _main:

+        Lloh0:

+            adrp x0, _target@PAGE

+        Lloh1:

+            add x0, x0, _target@PAGEOFF

+            mov w0, #0

+            ret

+            .space 0x200000

+        _target:

+            ret

+        .loh AdrpAdd Lloh0, Lloh1

+        .subsections_via_symbols

+    "#;

+    if let Err(e) = assemble(src, &obj) {

+        eprintln!("skipping: assemble failed: {e}");

+        return;

+    }

+

+    let opts = LinkOptions {

+        inputs: vec![obj.clone()],

+        output: Some(out.clone()),

+        kind: OutputKind::Executable,

+        ..LinkOptions::default()

+    };

+    Linker::run(&opts).unwrap();

+

+    let bytes = fs::read(&out).unwrap();

+    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();

+    let target_addr = symbol_values(&bytes)["_target"];

+    let first = read_insn(&text, 0).unwrap();

+    let second = read_insn(&text, 4).unwrap();

+    assert!(

+        is_adrp(first),

+        "far LOH pair should stay ADRP, got {first:#010x}"

+    );

+    assert!(

+        is_add_imm_64(second),

+        "far LOH pair should keep ADD immediate, got {second:#010x}"

+    );

+    assert_eq!(

+        decode_page_reference(&text, text_addr, 0, &PageRefKind::Add).unwrap(),

+        target_addr

+    );

+

+    let _ = fs::remove_file(obj);

+    let _ = fs::remove_file(out);

+}

+

+#[test]

+fn linker_run_no_loh_keeps_adrp_add_unrelaxed() {

+    if !have_xcrun() {

+        eprintln!("skipping: xcrun unavailable");

+        return;

+    }

+

+    let obj = scratch("loh-no-relax.o");

+    let out = scratch("loh-no-relax.out");

+    let src = r#"

+        .section __TEXT,__text,regular,pure_instructions

+        .globl _main

+        .globl _target

+        _main:

+        Lloh0:

+            adrp x0, _target@PAGE

+        Lloh1:

+            add x0, x0, _target@PAGEOFF

+            mov w0, #0

+            ret

+        _target:

+            ret

+        .loh AdrpAdd Lloh0, Lloh1

+        .subsections_via_symbols

+    "#;

+    if let Err(e) = assemble(src, &obj) {

+        eprintln!("skipping: assemble failed: {e}");

+        return;

+    }

+

+    let opts = LinkOptions {

+        inputs: vec![obj.clone()],

+        output: Some(out.clone()),

+        kind: OutputKind::Executable,

+        no_loh: true,

+        ..LinkOptions::default()

+    };

+    Linker::run(&opts).unwrap();

+

+    let bytes = fs::read(&out).unwrap();

+    let (text_addr, text) = output_section(&bytes, "__TEXT", "__text").unwrap();

+    let target_addr = symbol_values(&bytes)["_target"];

+    let first = read_insn(&text, 0).unwrap();

+    let second = read_insn(&text, 4).unwrap();

+    assert!(is_adrp(first), "expected ADRP when -no_loh is set");

+    assert!(is_add_imm_64(second), "expected ADD when -no_loh is set");

+    assert_eq!(

+        decode_page_reference(&text, text_addr, 0, &PageRefKind::Add).unwrap(),

+        target_addr

+    );

+

+    let _ = fs::remove_file(obj);

+    let _ = fs::remove_file(out);

+}

+

+  -no_loh                         Skip LOH relaxation