1use kh_runtime::GuestPageSize;
4
5#[derive(Debug, Clone, PartialEq, Eq)]
7#[allow(clippy::struct_excessive_bools)]
8pub struct MachOSummary {
9 pub path: String,
11 pub fat: bool,
13 pub file_slice_offset: u64,
18 pub cpu: String,
20 pub file_type: String,
22 pub file_type_raw: u32,
24 pub flags: u32,
26 pub ncmds: u32,
28 pub sizeofcmds: u32,
30 pub entry: Option<u64>,
32 pub old_style_entry: bool,
34 pub uuid: Option<String>,
36 pub minos: Option<String>,
38 pub platform: Option<String>,
40 pub is_64: bool,
42 pub little_endian: bool,
44}
45
46#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct SegmentInfo {
49 pub name: String,
51 pub vmaddr: u64,
53 pub vmsize: u64,
55 pub fileoff: u64,
57 pub filesize: u64,
59 pub maxprot: u32,
61 pub initprot: u32,
63 pub sections: Vec<SectionInfo>,
65}
66
67#[derive(Debug, Clone, PartialEq, Eq)]
69pub struct SectionInfo {
70 pub name: String,
72 pub segname: String,
74 pub addr: u64,
76 pub size: u64,
78 pub offset: u32,
80 pub align: u32,
82 pub flags: u32,
84}
85
86#[derive(Debug, Clone, Copy, PartialEq, Eq)]
88pub enum DylibKind {
89 Load,
91 Weak,
93 Reexport,
95 Lazy,
97 Upward,
99 Id,
101}
102
103impl DylibKind {
104 #[must_use]
106 pub const fn as_str(self) -> &'static str {
107 match self {
108 Self::Load => "load",
109 Self::Weak => "weak",
110 Self::Reexport => "reexport",
111 Self::Lazy => "lazy",
112 Self::Upward => "upward",
113 Self::Id => "id",
114 }
115 }
116}
117
118#[derive(Debug, Clone, PartialEq, Eq)]
120pub struct DylibDep {
121 pub kind: DylibKind,
123 pub name: String,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq)]
129pub struct LoadCommandInfo {
130 pub index: u32,
132 pub name: String,
134 pub cmdsize: u32,
136 pub detail: Option<String>,
138}
139
140#[derive(Debug, Clone, PartialEq, Eq)]
142pub struct MachOImage {
143 pub summary: MachOSummary,
145 pub segments: Vec<SegmentInfo>,
147 pub dylibs: Vec<DylibDep>,
149 pub load_commands: Vec<LoadCommandInfo>,
151 pub rpaths: Vec<String>,
153}
154
155impl MachOImage {
156 #[must_use]
158 pub fn summary(&self) -> &MachOSummary {
159 &self.summary
160 }
161
162 #[must_use]
164 pub fn dylibs_matching(&self, find: Option<&str>) -> Vec<&DylibDep> {
165 self.dylibs
166 .iter()
167 .filter(|dep| find.is_none_or(|needle| dep.name.contains(needle)))
168 .collect()
169 }
170
171 #[must_use]
173 pub fn plan(&self, guest: GuestPageSize) -> ImagePlan {
174 ImagePlan::from_image(self, guest)
175 }
176}
177
178#[derive(Debug, Clone, PartialEq, Eq)]
180pub struct PlannedMapping {
181 pub name: String,
183 pub vmaddr: u64,
185 pub vmsize: u64,
187 pub fileoff: u64,
189 pub filesize: u64,
191 pub guest_aligned_addr: u64,
193 pub guest_aligned_end: u64,
195 pub initprot: u32,
197 pub maxprot: u32,
199 pub vmaddr_guest_aligned: bool,
201 pub vmsize_guest_aligned: bool,
203 pub svc_scan_ranges: Vec<(u64, u64)>,
208}
209
210#[derive(Debug, Clone, PartialEq, Eq)]
212pub struct ImagePlan {
213 pub guest_page_size: u32,
215 pub preferred_base: u64,
217 pub entry: Option<u64>,
219 pub mappings: Vec<PlannedMapping>,
221 pub fully_guest_aligned: bool,
223}
224
225impl ImagePlan {
226 #[inline]
228 #[must_use]
229 pub const fn empty() -> Self {
230 Self {
231 guest_page_size: 0,
232 preferred_base: 0,
233 entry: None,
234 mappings: Vec::new(),
235 fully_guest_aligned: true,
236 }
237 }
238
239 #[must_use]
241 pub fn from_image(image: &MachOImage, guest: GuestPageSize) -> Self {
242 use kh_runtime::PageLayout;
243
244 let guest_page = guest.bytes();
245 let mut preferred_base = u64::MAX;
246 let mut mappings = Vec::with_capacity(image.segments.len());
247 let mut fully_aligned = true;
248
249 for seg in &image.segments {
250 let aligned_addr = PageLayout::align_down(seg.vmaddr, guest_page).unwrap_or(seg.vmaddr);
251 let end = seg.vmaddr.saturating_add(seg.vmsize);
252 let aligned_end = PageLayout::align_up(end, guest_page).unwrap_or(end);
253
254 let vmaddr_ok = guest_page != 0 && seg.vmaddr.is_multiple_of(u64::from(guest_page));
255 let vmsize_ok = guest_page != 0
256 && (seg.vmsize == 0 || seg.vmsize.is_multiple_of(u64::from(guest_page)));
257 if !vmaddr_ok || !vmsize_ok {
258 fully_aligned = false;
259 }
260
261 let is_pagezero = seg.name == "__PAGEZERO" || (seg.initprot == 0 && seg.fileoff == 0);
263 if seg.vmsize > 0 && !is_pagezero && seg.vmaddr < preferred_base {
264 preferred_base = seg.vmaddr;
265 }
266
267 let svc_scan_ranges = instruction_scan_ranges(seg);
268
269 mappings.push(PlannedMapping {
270 name: seg.name.clone(),
271 vmaddr: seg.vmaddr,
272 vmsize: seg.vmsize,
273 fileoff: seg.fileoff.saturating_add(image.summary.file_slice_offset),
275 filesize: seg.filesize,
276 guest_aligned_addr: aligned_addr,
277 guest_aligned_end: aligned_end,
278 initprot: seg.initprot,
279 maxprot: seg.maxprot,
280 vmaddr_guest_aligned: vmaddr_ok,
281 vmsize_guest_aligned: vmsize_ok,
282 svc_scan_ranges,
283 });
284 }
285
286 if preferred_base == u64::MAX {
287 preferred_base = 0;
288 }
289
290 Self {
291 guest_page_size: guest_page,
292 preferred_base,
293 entry: image.summary.entry,
294 mappings,
295 fully_guest_aligned: fully_aligned,
296 }
297 }
298
299 #[must_use]
301 pub fn segment_count(&self) -> usize {
302 self.mappings.len()
303 }
304}
305
306const S_ATTR_PURE_INSTRUCTIONS: u32 = 0x8000_0000;
308const S_ATTR_SOME_INSTRUCTIONS: u32 = 0x0000_0400;
310
311fn instruction_scan_ranges(seg: &SegmentInfo) -> Vec<(u64, u64)> {
318 let mut out = Vec::new();
319 for sect in &seg.sections {
320 if sect.flags & (S_ATTR_PURE_INSTRUCTIONS | S_ATTR_SOME_INSTRUCTIONS) == 0 {
321 continue;
322 }
323 if sect.size == 0 {
324 continue;
325 }
326 let sect_off = u64::from(sect.offset);
327 if sect_off < seg.fileoff {
328 continue;
329 }
330 let rel = sect_off.saturating_sub(seg.fileoff);
331 if rel >= seg.filesize {
332 continue;
333 }
334 let max_len = seg.filesize.saturating_sub(rel);
335 let len = sect.size.min(max_len);
336 if len > 0 {
337 out.push((rel, len));
338 }
339 }
340 out
341}