use crate::{Rd, Result, bad, capacity};
const W: &str = "binding set";
pub const BINDING_SET: u32 = 0xA19B_025D;
pub const PASS_BINDING: u32 = 0x589B_B36E;
const HEADER: usize = 0x20;
const GROUP: usize = 0x40;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Param {
pub name: u64,
pub ty: u32,
pub count: u16,
pub extra: u16,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Entry {
pub at: u32,
pub marker: u16,
pub kind: u16,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Group {
pub name: u64,
pub size: u32,
pub flags: [u8; 4],
pub words: [u16; 4],
pub params: Vec<Param>,
pub entries: Vec<Entry>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Set {
pub id: u64,
pub head: [u32; 2],
pub pass: bool,
pub version: u32,
pub groups: Vec<Group>,
pub trailer: Vec<u8>,
pub lead: Vec<u8>,
pub relocations: Vec<u32>,
}
impl Group {
pub fn buffer_end(&self) -> u64 {
(self.entries.iter())
.filter(|e| e.at != u32::MAX)
.map(|e| u64::from(e.at).saturating_add(u64::from(e.kind) / 4))
.max()
.unwrap_or(0)
}
}
pub fn read(rtype: u32, d: &[u8], meta: &[u8; 16]) -> Result<Set> {
let m = Rd::new(meta, W);
let (size, reloc, id) = (m.u32le(0)? as usize, m.u32le(4)? as usize, m.u64le(8)?);
if size.checked_add(reloc) != Some(d.len()) {
return Err(bad(
W,
0,
format!("size {size} + relocations {reloc} != {}", d.len()),
));
}
let r = Rd::new(d, W);
let pass = match rtype {
PASS_BINDING => true,
BINDING_SET => false,
t => return Err(bad(W, 0, format!("type {t:#010x} is not a binding set"))),
};
let first = r.u32le(0)?;
let (count, own, head, version) = if pass {
(r.u32le(4)? as usize, r.u64le(0x10)?, [0, 0], first)
} else {
(
first as usize,
r.u64le(0x10)?,
[r.u32le(0x18)?, r.u32le(0x1c)?],
0,
)
};
if own != id {
return Err(bad(W, 0x10, format!("id {own:#x}, the metadata's {id:#x}")));
}
if (if pass { r.u32le(8)? } else { r.u32le(4)? }) != 0x20 {
return Err(bad(W, 4, "groups do not start at 0x20"));
}
let tables_end = size;
let mut groups = Vec::with_capacity(capacity(W, count, GROUP, size.saturating_sub(HEADER))?);
let groups_end = crate::at(HEADER, count, GROUP);
let mut end_of_data = groups_end;
let mut pointers = Vec::new();
let mut first_params = usize::MAX;
for g in 0..count {
let at = crate::at(HEADER, g, GROUP);
let field = |k: usize| at.saturating_add(k);
let n = usize::from(r.u16le(field(0x10))?);
let (all, own_params, table, end) = (
r.offset64le(field(0x20))?,
r.offset64le(field(0x28))?,
r.offset64le(field(0x30))?,
r.offset64le(field(0x38))?,
);
pointers.extend([field(0x20), field(0x28), field(0x30), field(0x38)]);
first_params = first_params.min(own_params).min(all);
if end > size {
return Err(bad(
W,
field(0x38),
format!("tables end at {end:#x} in a payload of {size:#x}"),
));
}
let params_end = own_params.checked_add(crate::at(0, n, 16));
let table_end = table.checked_add(crate::at(0, n, 8));
if params_end.is_none_or(|e| e > table) || table_end.is_none_or(|e| e > end.min(tables_end)) {
return Err(bad(
W,
at,
format!("group {g}: {n} parameters at {own_params:#x} and entries at {table:#x} do not fit"),
));
}
if own_params < groups_end {
return Err(bad(
W,
at,
format!("group {g}: parameters at {own_params:#x} before the set's"),
));
}
let params = (0..n)
.map(|i| {
let p = crate::at(own_params, i, 16);
let field = |k: usize| p.saturating_add(k);
Ok(Param {
name: r.u64le(p)?,
ty: r.u32le(field(8))?,
count: r.u16le(field(12))?,
extra: r.u16le(field(14))?,
})
})
.collect::<Result<Vec<_>>>()?;
let entries = (0..n)
.map(|i| {
let e = crate::at(table, i, 8);
Ok(Entry {
at: r.u32le(e)?,
marker: r.u16le(e.saturating_add(4))?,
kind: r.u16le(e.saturating_add(6))?,
})
})
.collect::<Result<Vec<_>>>()?;
end_of_data = end_of_data.max(table_end.unwrap_or(0));
groups.push(Group {
name: r.u64le(at)?,
size: r.u32le(field(8))?,
flags: r.arr(field(12))?,
words: [
r.u16le(field(0x12))?,
r.u16le(field(0x14))?,
r.u16le(field(0x16))?,
r.u16le(field(0x18))?,
],
params,
entries,
});
}
let words = (0..reloc / 4)
.map(|i| r.u32le(crate::at(size, i, 4)))
.collect::<Result<Vec<_>>>()?;
if !reloc.is_multiple_of(4) || reloc < crate::at(4, pointers.len(), 4) {
return Err(bad(
W,
size,
format!("{reloc} relocation bytes for {} groups", groups.len()),
));
}
if let Some(p) = pointers
.iter()
.find(|&&p| !u32::try_from(p).is_ok_and(|p| words.contains(&p)))
{
return Err(bad(
W,
size,
format!("the relocation list lacks the pointer at {p:#x}"),
));
}
let gap = size.checked_sub(end_of_data).filter(|&gap| gap <= 64);
let Some(gap) = gap else {
return Err(bad(
W,
end_of_data,
format!(
"the last entry table ends at {end_of_data:#x} and the relocations start at {size:#x}: expected a gap of at most 64 bytes"
),
));
};
Ok(Set {
id,
head,
pass,
version,
groups,
trailer: r.bytes(end_of_data, gap)?.to_vec(),
lead: r
.bytes(groups_end, first_params.saturating_sub(groups_end))?
.to_vec(),
relocations: words,
})
}
#[derive(Clone, Copy, Debug)]
pub struct Bindings<'a> {
pub pass: Option<&'a Set>,
pub sets: [Option<&'a Set>; 3],
}
impl<'a> Bindings<'a> {
pub fn constant_buffer(&self, register: u32) -> Option<&'a Group> {
let set = match register {
0 => self.sets[1],
1 => self.sets[0],
4 => self.pass,
_ => None,
}?;
set.groups.first()
}
pub fn resource(&self, register: u32) -> Option<(&'a Group, usize)> {
let (set, base) = match register {
0..=31 => (self.sets[1], 0),
32..=63 => (self.sets[0], 32),
_ => (self.pass, 64),
};
let group = set?.groups.get(1)?;
let want = register.checked_sub(base)?;
let i = group.entries.iter().position(|e| e.at == want)?;
Some((group, i))
}
pub fn parameter(&self, name: u64) -> Option<Slot<'a>> {
self.sets.iter().enumerate().find_map(|(set, s)| {
s.as_ref()?.groups.iter().enumerate().find_map(|(group, g)| {
let (index, param) = g.params.iter().enumerate().find(|(_, p)| p.name == name)?;
Some(Slot {
set,
group,
index,
param,
entry: g.entries.get(index)?,
})
})
})
}
}
#[derive(Clone, Copy, Debug)]
pub struct Slot<'a> {
pub set: usize,
pub group: usize,
pub index: usize,
pub param: &'a Param,
pub entry: &'a Entry,
}