1use super::{Error, output::Output};
5use std::{ops::Range, sync::Arc};
6use unityrs_core::budget::DecodeBuf;
7use unityrs_core::{
8 limits::{Meter, MeteredVec},
9 stream::Endian,
10 stream::Reader,
11};
12
13#[derive(Debug)]
14pub struct Program<'a> {
15 subs: MeteredVec<SubProgram>,
16 data: Data<'a>,
17 selected: Option<MeteredVec<usize>>,
18 capacity: usize,
19}
20#[derive(Debug)]
21struct SubProgram {
22 kind: i32,
23 keywords: MeteredVec<Range<usize>>,
24 local: MeteredVec<Range<usize>>,
25 code: Range<usize>,
26 segment: usize,
27}
28fn int(r: &mut Reader<'_>, meter: &Meter) -> Result<i32, Error> {
29 meter.count_decode(4)?;
30 r.read_i32().map_err(|_| Error::Struct)
31}
32fn keywords(
33 r: &mut Reader<'_>,
34 meter: &Arc<Meter>,
35 collect: bool,
36 strict: bool,
37) -> Result<MeteredVec<Range<usize>>, Error> {
38 let count = int(r, meter)?;
39 if strict && count < 0 {
40 return Err(Error::Struct);
41 }
42 let mut words = MeteredVec::new(meter);
43 if i128::from(count.max(0)) * 4 > r.data().len() as i128 - r.position() {
45 return Err(Error::Struct);
46 }
47 for _ in 0..count {
48 let len = int(r, meter)?;
49 if strict && (len < 0 || i128::from(len) > r.data().len() as i128 - r.position()) {
50 return Err(Error::Struct);
51 }
52 let word = if len > 0 && i128::from(len) <= r.data().len() as i128 - r.position() {
53 let word = r.read_range(i64::from(len)).map_err(|_| Error::Struct)?;
54 meter.count_decode(word.len() as u64)?;
55 r.align(4).map_err(|_| Error::Struct)?;
56 word
57 } else {
58 0..0
59 };
60 if collect {
61 words.push(word)?;
62 }
63 }
64 Ok(words)
65}
66impl<'a> Program<'a> {
67 pub(super) fn modern(
69 segments: MeteredVec<DecodeBuf>,
70 version: (u32, u32),
71 form: super::View<'_>,
72 platforms: super::view::Seq<'_>,
73 platform_index: usize,
74 meter: &Arc<Meter>,
75 ) -> Result<Program<'static>, Error> {
76 let data = Data::Segments(segments);
77 let mut table = Reader::new(data.bytes(), Endian::Little);
78 let count = int(&mut table, meter)?;
79 let capacity = usize::try_from(count).map_err(|_| Error::LayoutIndex)?;
80 let stride = if version >= (2019, 3) { 12 } else { 8 };
81 if 4 + capacity as i128 * stride > data.bytes().len() as i128 {
82 return Err(Error::LayoutIndex);
83 }
84 let selection =
85 super::layout::Selection::collect(form, platforms, platform_index, capacity)?;
86 let mut subs = MeteredVec::new(meter);
87 for (indices, code) in [(&selection.code, true), (&selection.parameters, false)] {
88 for index in indices.as_slice() {
89 meter.count_decode(1)?;
90 if *index >= capacity {
91 return Err(Error::LayoutIndex);
92 }
93 table
94 .set_position(4 + *index as i128 * stride)
95 .map_err(|_| Error::LayoutIndex)?;
96 let start =
97 usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?;
98 let length =
99 usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?;
100 let segment = if stride == 12 {
101 usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?
102 } else {
103 0
104 };
105 let bytes = data.segment(segment)?;
106 let end = if length == 0 {
108 bytes.len()
109 } else {
110 start.checked_add(length).ok_or(Error::LayoutIndex)?
111 };
112 if start >= bytes.len() || end > bytes.len() {
113 return Err(Error::LayoutIndex);
114 }
115 if code {
116 let mut r =
117 Reader::new(bytes.get(..end).ok_or(Error::LayoutIndex)?, Endian::Little);
118 r.set_position(start as i128)
119 .map_err(|_| Error::LayoutIndex)?;
120 let mut sub = read_sub(&mut r, meter, true, true).map_err(|e| match e {
121 Error::Struct => Error::LayoutIndex,
122 other => other,
123 })?;
124 sub.segment = segment;
125 subs.push(sub)?;
126 }
127 }
128 }
129 Ok(Program {
130 subs,
131 data,
132 selected: Some(selection.code),
133 capacity,
134 })
135 }
136 pub(super) fn legacy(data: DecodeBuf, meter: &Arc<Meter>) -> Result<Program<'static>, Error> {
137 let data = Data::Decoded(data);
138 let mut r = Reader::new(data.bytes(), Endian::Big);
139 let count = int(&mut r, meter)?;
140 if count < 0 || 4 + i128::from(count) * 8 > data.bytes().len() as i128 {
141 return Err(Error::Struct);
142 }
143 let mut subs = MeteredVec::new(meter);
144 for i in 0..count {
145 r.set_position(4 + i128::from(i) * 8)
146 .map_err(|_| Error::Struct)?;
147 let offset = int(&mut r, meter)?;
148 if usize::try_from(offset).map_or(true, |offset| offset >= data.bytes().len()) {
149 return Err(Error::Struct);
150 }
151 r.set_position(i128::from(offset))
152 .map_err(|_| Error::Struct)?;
153 subs.push(read_sub(&mut r, meter, true, true)?)?;
154 }
155 Ok(Program {
156 subs,
157 data,
158 selected: None,
159 capacity: usize::try_from(count).map_err(|_| Error::Struct)?,
160 })
161 }
162 #[must_use]
164 pub fn subprogram_count(&self) -> usize {
165 self.subs.len()
166 }
167 pub fn parse(blob: &'a [u8], version: (u32, u32), meter: &Arc<Meter>) -> Result<Self, Error> {
169 Self::parse_data(Data::Borrowed(blob), version, meter)
170 }
171 pub(super) fn decoded(
172 blob: DecodeBuf,
173 version: (u32, u32),
174 meter: &Arc<Meter>,
175 ) -> Result<Program<'static>, Error> {
176 Program::parse_data(Data::Decoded(blob), version, meter)
177 }
178 fn parse_data(data: Data<'a>, version: (u32, u32), meter: &Arc<Meter>) -> Result<Self, Error> {
179 let blob = data.bytes();
180 let mut r = Reader::new(blob, Endian::Little);
181 let count = int(&mut r, meter)?;
182 let entry = if version >= (2019, 3) { 12 } else { 8 };
183 if count > 0 && 4 + (i128::from(count) - 1) * entry + 4 > blob.len() as i128 {
184 for i in 0..count {
187 r.set_position(4 + i128::from(i) * entry)
188 .map_err(|_| Error::Struct)?;
189 let offset = int(&mut r, meter)?;
190 r.set_position(i128::from(offset))
191 .map_err(|_| Error::Struct)?;
192 read_sub(&mut r, meter, false, false)?;
193 }
194 return Err(Error::Struct);
195 }
196 let mut subs = MeteredVec::new(meter);
197 for i in 0..count {
198 r.set_position(4 + i128::from(i) * entry)
199 .map_err(|_| Error::Struct)?;
200 let offset = int(&mut r, meter)?;
201 r.set_position(i128::from(offset))
202 .map_err(|_| Error::Struct)?;
203 subs.push(read_sub(&mut r, meter, true, false)?)?;
204 }
205 Ok(Self {
206 subs,
207 data,
208 selected: None,
209 capacity: usize::try_from(count.max(0)).map_err(|_| Error::Struct)?,
210 })
211 }
212 pub fn export(&self, index: i64, meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
214 let mut out = Output::new(meter);
215 out.code_fallback = false;
216 self.write(index, &mut out)?;
217 Ok(out.bytes)
218 }
219 pub(super) fn write(&self, index: i64, out: &mut Output<'_>) -> Result<(), Error> {
220 let index = if index < 0 {
221 self.capacity as i128 + i128::from(index)
222 } else {
223 i128::from(index)
224 };
225 let index = usize::try_from(index).map_err(|_| Error::Index)?;
226 let index = if let Some(selected) = &self.selected {
227 out.work(u64::from(selected.len().max(1).ilog2()) + 1)?;
228 selected
229 .as_slice()
230 .binary_search(&index)
231 .map_err(|_| Error::Index)?
232 } else {
233 index
234 };
235 let sub = Some(index)
236 .and_then(|i| self.subs.as_slice().get(i))
237 .ok_or(Error::Index)?;
238 for (label, words) in [
239 ("Keywords { ", &sub.keywords),
240 ("Local Keywords { ", &sub.local),
241 ] {
242 if !words.is_empty() {
243 out.text(label)?;
244 for word in words.as_slice() {
245 out.text("\"")?;
246 out.text(
247 self.data
248 .segment(sub.segment)?
249 .get(word.clone())
250 .ok_or(Error::Index)?,
251 )?;
252 out.text("\" ")?;
253 }
254 out.text("}\n")?;
255 }
256 }
257 out.text("\"")?;
258 let code = self
259 .data
260 .segment(sub.segment)?
261 .get(sub.code.clone())
262 .ok_or(Error::Index)?;
263 if !code.is_empty() {
264 match sub.kind {
265 1..=8 | 26..=30 => utf8(code, sub.kind, out)?,
266 9..=22 => out.text("// shader disassembly not supported on DXBC")?,
267 23 | 24 => {
268 out.work((code.len() as u64).saturating_mul(2))?;
270 match metal_source(code) {
271 Ok(source) => utf8(source, sub.kind, out)?,
272 Err(Error::Struct | Error::Unterminated) if out.code_fallback => {
273 unsupported(sub.kind, out)?;
274 }
275 Err(error) => return Err(error),
276 }
277 }
278 25 => {}
279 n => unsupported(n, out)?,
280 }
281 }
282 out.text("\"")
283 }
284}
285fn metal_source(code: &[u8]) -> Result<&[u8], Error> {
286 let mut r = Reader::new(code, Endian::Little);
287 let tag = r.read_u32().map_err(|_| Error::Struct)?;
288 if tag == 0xf00d_cafe {
289 let offset = r.read_i32().map_err(|_| Error::Struct)?;
290 r.set_position(i128::from(offset))
291 .map_err(|_| Error::Struct)?;
292 }
293 r.read_string_to_null().map_err(|_| Error::Unterminated)?;
294 let remaining = code.len() as i128 - r.position();
295 let remaining = i64::try_from(remaining).map_err(|_| Error::Struct)?;
296 r.read(remaining).map_err(|_| Error::Struct)
297}
298
299fn unsupported(kind: i32, out: &mut Output<'_>) -> Result<(), Error> {
300 out.text("//shader disassembly not supported on ")?;
301 out.int(i128::from(kind))
302}
303
304fn utf8(code: &[u8], kind: i32, out: &mut Output<'_>) -> Result<(), Error> {
305 out.work(code.len() as u64)?;
306 if std::str::from_utf8(code).is_err() {
307 return if out.code_fallback {
308 unsupported(kind, out)
309 } else {
310 Err(out.utf8_error(code))
311 };
312 }
313 out.text(code)
314}
315
316#[derive(Debug)]
317enum Data<'a> {
318 Borrowed(&'a [u8]),
319 Decoded(DecodeBuf),
320 Segments(MeteredVec<DecodeBuf>),
321}
322impl Data<'_> {
323 fn segment(&self, i: usize) -> Result<&[u8], Error> {
324 match self {
325 Self::Segments(b) => b
326 .as_slice()
327 .get(i)
328 .map(DecodeBuf::as_slice)
329 .ok_or(Error::LayoutIndex),
330 _ if i == 0 => Ok(self.bytes()),
331 _ => Err(Error::LayoutIndex),
332 }
333 }
334 fn bytes(&self) -> &[u8] {
335 match self {
336 Self::Borrowed(b) => b,
337 Self::Decoded(b) => b.as_slice(),
338 Self::Segments(b) => b.as_slice().first().map_or(&[], DecodeBuf::as_slice),
339 }
340 }
341}
342
343fn read_sub(
344 r: &mut Reader<'_>,
345 meter: &Arc<Meter>,
346 collect: bool,
347 strict: bool,
348) -> Result<SubProgram, Error> {
349 let version = int(r, meter)?;
350 let kind = int(r, meter)?;
351 if !(0..=31).contains(&kind) {
352 return Err(Error::ProgramType(kind));
353 }
354 r.set_position(r.position() + 12 + if version >= 201_608_170 { 4 } else { 0 })
355 .map_err(|_| Error::Struct)?;
356 let words = keywords(r, meter, collect, strict)?;
357 let local = if (201_806_140..202_012_090).contains(&version) {
358 keywords(r, meter, collect, strict)?
359 } else {
360 MeteredVec::new(meter)
361 };
362 let len = int(r, meter)?;
363 if strict && (len < 0 || i128::from(len) > r.data().len() as i128 - r.position()) {
364 return Err(Error::Struct);
365 }
366 let code = r.read_range(i64::from(len)).map_err(|_| Error::Struct)?;
367 meter.count_decode(code.len() as u64)?;
368 r.align(4).map_err(|_| Error::Struct)?;
369 Ok(SubProgram {
370 kind,
371 keywords: words,
372 local,
373 code,
374 segment: 0,
375 })
376}