use super::Error;
use crate::discovery::{ResolvedItem, ResolvedItemKind, SelectedField};
use crate::layout;
use crate::layout::{FieldLayout, RecordLayout};
use crate::pdb::ir::{Alignment, Database, RecordKind};
use pdb_bindgen_macro_support::FragmentKind;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Write as _;
pub(super) fn render(item: &ResolvedItem, database: &Database) -> Result<Vec<u8>, Error> {
let ResolvedItemKind::Type {
rust_name,
type_name,
kind,
syntax,
fields,
} = &item.kind
else {
unreachable!("codegen receives types only");
};
let record = database.record(type_name).map_err(|source| Error::Record {
image: item.image.image.clone(),
pdb_name: type_name.clone(),
source,
})?;
let expected_union = *kind == FragmentKind::Union;
let actual_union = record.kind == RecordKind::Union;
if expected_union != actual_union {
return Err(Error::KindMismatch {
pdb_name: type_name.clone(),
expected: if expected_union {
"union"
} else {
"struct/class/interface"
},
actual: if actual_union {
"union"
} else {
"struct/class/interface"
},
});
}
let layout = layout::record(database, record.id).map_err(|source| Error::Layout {
pdb_name: type_name.clone(),
source,
})?;
let Alignment::Known(alignment) = layout.alignment else {
return Err(Error::Alignment {
pdb_name: type_name.clone(),
alignment: None,
});
};
if !alignment.is_power_of_two() {
return Err(Error::Alignment {
pdb_name: type_name.clone(),
alignment: Some(alignment),
});
}
let selected = selected(fields)?;
for field in fields {
let matches = layout
.fields
.iter()
.filter(|physical| physical.name == field.field_name)
.count();
if matches != 1 {
return Err(Error::MissingField {
pdb_name: field.field_name.clone(),
rust_name: field.rust_name.clone(),
});
}
}
let selected_names = fields
.iter()
.map(|field| field.rust_name.as_str())
.collect::<BTreeSet<_>>();
let mut methods = BTreeSet::new();
for physical in &layout.fields {
let Some(field) = selected.get(physical.name.as_str()) else {
continue;
};
if physical.bitfield.is_none() {
if field.read_only {
return Err(Error::Unsupported {
pdb_name: type_name.clone(),
rust_name: field.rust_name.clone(),
detail: "`read_only` is only supported on bitfield selections".into(),
});
}
continue;
}
let getter = field.rust_name.clone();
if !methods.insert(getter.clone()) {
return Err(Error::NameCollision { name: getter });
}
if !field.read_only {
let setter = format!("set_{}", field.rust_name);
if selected_names.contains(setter.as_str()) || !methods.insert(setter.clone()) {
return Err(Error::NameCollision { name: setter });
}
}
}
let mut names = fields
.iter()
.map(|field| field.rust_name.clone())
.collect::<BTreeSet<_>>();
let output = if expected_union {
render_union(
rust_name, type_name, syntax, &layout, &selected, &mut names, alignment,
)?
} else {
render_struct(
rust_name, type_name, syntax, &layout, &selected, &mut names, alignment,
)?
};
syn::parse_file(&output).map_err(|source| Error::InvalidFragment {
rust_name: rust_name.clone(),
source,
})?;
Ok(output.into_bytes())
}
fn selected(fields: &[SelectedField]) -> Result<BTreeMap<&str, &SelectedField>, Error> {
let mut selected = BTreeMap::new();
for field in fields {
if selected.insert(field.field_name.as_str(), field).is_some() {
return Err(Error::DuplicateField {
pdb_name: field.field_name.clone(),
});
}
}
let mut rust_names = BTreeSet::new();
for field in fields {
if !rust_names.insert(&field.rust_name) {
return Err(Error::NameCollision {
name: field.rust_name.clone(),
});
}
}
Ok(selected)
}
fn render_struct(
rust_name: &str,
pdb_name: &str,
syntax: &crate::discovery::TypeSyntax,
layout: &RecordLayout,
selected: &BTreeMap<&str, &SelectedField>,
names: &mut BTreeSet<String>,
alignment: u64,
) -> Result<String, Error> {
let mut body = String::new();
let mut assertions = String::new();
let mut methods = String::new();
let mut cursor = 0;
let mut pad = 0;
let mut natural = 1;
let mut bits = BTreeMap::<(u64, u64, Alignment), String>::new();
emit_alignment_carrier(&mut body, names, layout)?;
for physical in &layout.fields {
let Some(source) = selected.get(physical.name.as_str()) else {
continue;
};
if cursor < physical.offset {
emit_pad(&mut body, names, &mut pad, physical.offset - cursor)?;
}
if physical.bitfield.is_some() {
let key = (physical.offset, physical.size, physical.alignment.clone());
let backing = if let Some(backing) = bits.get(&key) {
backing.clone()
} else {
let backing = helper("__pdb_bindgen_bits", bits.len(), names)?;
let storage_ty = storage_type(physical, pdb_name, source)?;
let storage_alignment = storage_alignment(storage_ty);
require_alignment(physical, pdb_name, source, storage_alignment)?;
natural = natural.max(storage_alignment);
emit_field_line(&mut body, &[], "", &backing, storage_ty);
assertions.push_str(&offset_assertion(rust_name, &backing, physical.offset));
assertions.push_str(&size_assertion(storage_ty, physical.size));
assertions.push_str(&align_assertion(storage_ty, storage_alignment));
bits.insert(key, backing.clone());
backing
};
emit_accessor(&mut methods, source, physical, &backing, false, pdb_name)?;
} else {
let field_alignment = require_alignment(physical, pdb_name, source, 0)?;
natural = natural.max(field_alignment);
emit_field_line(
&mut body,
&source.attributes,
&source.visibility,
&source.rust_name,
&source.ty,
);
assertions.push_str(&offset_assertion(
rust_name,
&source.rust_name,
physical.offset,
));
assertions.push_str(&size_assertion(&source.ty, physical.size));
assertions.push_str(&align_assertion(&source.ty, field_alignment));
}
cursor = cursor.max(physical.offset + physical.size);
}
if selected.is_empty() && layout.size > 0 {
let storage = helper("__pdb_bindgen_storage", 0, names)?;
emit_field_line(
&mut body,
&[],
"",
&storage,
&format!("[u8; {}]", layout.size),
);
assertions.push_str(&size_assertion(
&format!("[u8; {}]", layout.size),
layout.size,
));
} else if cursor < layout.size {
emit_pad(&mut body, names, &mut pad, layout.size - cursor)?;
}
let repr = repr(layout.packed, alignment, natural);
Ok(finish(
rust_name,
syntax,
"struct",
&repr,
body,
methods,
assertions,
layout.size,
alignment,
))
}
fn render_union(
rust_name: &str,
pdb_name: &str,
syntax: &crate::discovery::TypeSyntax,
layout: &RecordLayout,
selected: &BTreeMap<&str, &SelectedField>,
names: &mut BTreeSet<String>,
alignment: u64,
) -> Result<String, Error> {
let mut body = String::new();
let mut assertions = String::new();
let mut methods = String::new();
let mut natural = 1;
emit_alignment_carrier(&mut body, names, layout)?;
let storage = helper("__pdb_bindgen_storage", 0, names)?;
emit_field_line(
&mut body,
&[],
"",
&storage,
&format!("[u8; {}]", layout.size),
);
assertions.push_str(&offset_assertion(rust_name, &storage, 0));
assertions.push_str(&size_assertion(
&format!("[u8; {}]", layout.size),
layout.size,
));
let mut bit_index = 0;
for physical in &layout.fields {
let Some(source) = selected.get(physical.name.as_str()) else {
continue;
};
if physical.offset != 0 {
return Err(Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: source.rust_name.clone(),
detail: "union member offset is not zero".into(),
});
}
if physical.bitfield.is_some() {
let backing = helper("__pdb_bindgen_bits", bit_index, names)?;
bit_index += 1;
let storage_ty = storage_type(physical, pdb_name, source)?;
let storage_alignment = storage_alignment(storage_ty);
require_alignment(physical, pdb_name, source, storage_alignment)?;
natural = natural.max(storage_alignment);
emit_field_line(&mut body, &[], "", &backing, storage_ty);
assertions.push_str(&offset_assertion(rust_name, &backing, 0));
assertions.push_str(&size_assertion(storage_ty, physical.size));
assertions.push_str(&align_assertion(storage_ty, storage_alignment));
emit_accessor(&mut methods, source, physical, &backing, true, pdb_name)?;
} else {
let field_alignment = require_alignment(physical, pdb_name, source, 0)?;
natural = natural.max(field_alignment);
emit_field_line(
&mut body,
&source.attributes,
&source.visibility,
&source.rust_name,
&source.ty,
);
assertions.push_str(&offset_assertion(rust_name, &source.rust_name, 0));
assertions.push_str(&size_assertion(&source.ty, physical.size));
assertions.push_str(&align_assertion(&source.ty, field_alignment));
}
}
Ok(finish(
rust_name,
syntax,
"union",
&repr(layout.packed, alignment, natural),
body,
methods,
assertions,
layout.size,
alignment,
))
}
fn emit_accessor(
out: &mut String,
field: &SelectedField,
physical: &FieldLayout,
backing: &str,
union: bool,
pdb_name: &str,
) -> Result<(), Error> {
let bit = physical.bitfield.as_ref().expect("bitfield branch");
let scalar = scalar(&field.ty).ok_or_else(|| Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: field.rust_name.clone(),
detail: "unsupported bitfield accessor type".into(),
})?;
let width = scalar.1;
if (bit.length as u16) > width || (scalar.0 == "bool" && bit.length != 1) {
return Err(Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: field.rust_name.clone(),
detail: "bitfield length does not fit accessor type".into(),
});
}
let getter = &field.rust_name;
let setter = format!("set_{getter}");
if setter == *getter {
return Err(Error::NameCollision { name: setter });
}
emit_attributes(out, &field.attributes, " ");
if union {
out.push_str(" #[allow(unsafe_code)]\n");
}
writeln!(
out,
" {} fn {}(&self) -> {} {{",
visibility(&field.visibility),
getter,
field.ty
)
.expect("writing to a String cannot fail");
if union {
write!(out, " // SAFETY: reading an integer union member is valid because every bit pattern of its unsigned storage type is valid.\n let raw = unsafe {{ self.{backing} }} as u64;\n")
.expect("writing to a String cannot fail");
} else {
writeln!(out, " let raw = self.{backing} as u64;")
.expect("writing to a String cannot fail");
}
let mask = mask(bit.length);
writeln!(
out,
" let value = (raw >> {}) & {mask};",
bit.position
)
.expect("writing to a String cannot fail");
match scalar.0 {
"bool" => out.push_str(" value != 0\n"),
"i8" | "i16" | "i32" | "i64" => writeln!(
out,
" ((value << {}) as i64 >> {}) as {}",
64 - bit.length,
64 - bit.length,
field.ty
)
.expect("writing to a String cannot fail"),
_ => {
writeln!(out, " value as {}", field.ty).expect("writing to a String cannot fail")
}
}
out.push_str(" }\n");
if !field.read_only {
emit_attributes(
out,
&field
.attributes
.iter()
.filter(|attribute| !is_doc_attribute(attribute))
.cloned()
.collect::<Vec<_>>(),
" ",
);
writeln!(
out,
" {} fn {setter}(&mut self, value: {}) {{",
visibility(&field.visibility),
field.ty
)
.expect("writing to a String cannot fail");
writeln!(out, " let fixed_mask = {mask};").expect("writing to a String cannot fail");
if union {
writeln!(
out,
" self.{backing} = (((value as u64) & fixed_mask) << {}) as _;",
bit.position
)
.expect("writing to a String cannot fail");
} else {
writeln!(out, " let mask = fixed_mask << {};", bit.position)
.expect("writing to a String cannot fail");
writeln!(out, " self.{backing} = ((self.{backing} as u64 & !mask) | (((value as u64) & fixed_mask) << {})) as _;", bit.position)
.expect("writing to a String cannot fail");
}
out.push_str(" }\n");
}
Ok(())
}
fn storage_type<'a>(
physical: &FieldLayout,
pdb_name: &str,
source: &SelectedField,
) -> Result<&'a str, Error> {
match physical.size {
1 => Ok("u8"),
2 => Ok("u16"),
4 => Ok("u32"),
8 => Ok("u64"),
_ => Err(Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: source.rust_name.clone(),
detail: "unsupported bitfield storage width".into(),
}),
}
}
fn storage_alignment(ty: &str) -> u64 {
match ty {
"u8" => 1,
"u16" => 2,
"u32" => 4,
"u64" => 8,
_ => unreachable!("storage_type only returns unsigned integer types"),
}
}
fn require_alignment(
physical: &FieldLayout,
pdb_name: &str,
source: &SelectedField,
expected: u64,
) -> Result<u64, Error> {
let Alignment::Known(alignment) = physical.alignment else {
return Err(Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: source.rust_name.clone(),
detail: "selected field has unavailable alignment".into(),
});
};
if expected != 0 && alignment != expected {
return Err(Error::Unsupported {
pdb_name: pdb_name.into(),
rust_name: source.rust_name.clone(),
detail: "bitfield storage alignment does not match its Rust backing type".into(),
});
}
Ok(alignment)
}
fn scalar(ty: &str) -> Option<(&str, u16)> {
match ty {
"bool" => Some(("bool", 1)),
"u8" | "i8" => Some((ty, 8)),
"u16" | "i16" => Some((ty, 16)),
"u32" | "i32" => Some((ty, 32)),
"u64" | "i64" => Some((ty, 64)),
_ => None,
}
}
fn mask(length: u8) -> String {
if length == 64 {
"u64::MAX".into()
} else {
format!("0x{:x}u64", (1u64 << length) - 1)
}
}
fn repr(packed: bool, alignment: u64, natural: u64) -> String {
if packed {
return format!("#[repr(C, packed({alignment}))]");
}
if alignment > natural {
format!("#[repr(C, align({alignment}))]")
} else {
"#[repr(C)]".into()
}
}
fn emit_alignment_carrier(
body: &mut String,
names: &mut BTreeSet<String>,
layout: &RecordLayout,
) -> Result<(), Error> {
if !layout.packed || layout.alignment == Alignment::Known(1) {
return Ok(());
}
let Alignment::Known(alignment) = layout.alignment else {
unreachable!("renderer requires known record alignment");
};
let ty = match alignment {
2 => "u16",
4 => "u32",
8 => "u64",
16 => "u128",
_ => unreachable!("packed layout only permits supported MSVC alignments"),
};
let name = helper("__pdb_bindgen_align", 0, names)?;
emit_field_line(body, &[], "", &name, &format!("[{ty}; 0]"));
Ok(())
}
fn visibility(value: &str) -> String {
if value.is_empty() {
String::new()
} else {
format!("{value} ")
}
}
fn is_doc_attribute(attribute: &str) -> bool {
attribute.starts_with("#[doc ") || attribute.starts_with("#[doc=")
}
fn emit_attributes(out: &mut String, attributes: &[String], prefix: &str) {
for attribute in attributes {
out.push_str(prefix);
out.push_str(attribute);
out.push('\n');
}
}
fn emit_field_line(
out: &mut String,
attributes: &[String],
field_visibility: &str,
name: &str,
ty: &str,
) {
emit_attributes(out, attributes, " ");
writeln!(out, " {}{name}: {ty},", visibility(field_visibility))
.expect("writing to a String cannot fail");
}
fn emit_pad(
out: &mut String,
names: &mut BTreeSet<String>,
index: &mut usize,
size: u64,
) -> Result<(), Error> {
let name = helper("__pdb_bindgen_pad", *index, names)?;
*index += 1;
emit_field_line(out, &[], "", &name, &format!("[u8; {size}]"));
Ok(())
}
fn helper(prefix: &str, index: usize, names: &mut BTreeSet<String>) -> Result<String, Error> {
let name = format!("{prefix}_{index}");
if names.insert(name.clone()) {
Ok(name)
} else {
Err(Error::NameCollision { name })
}
}
fn offset_assertion(rust_name: &str, field: &str, offset: u64) -> String {
format!("const _: () = assert!(::core::mem::offset_of!({rust_name}, {field}) == {offset});\n")
}
fn size_assertion(ty: &str, size: u64) -> String {
format!("const _: () = assert!(::core::mem::size_of::<{ty}>() == {size});\n")
}
fn align_assertion(ty: &str, alignment: u64) -> String {
format!("const _: () = assert!(::core::mem::align_of::<{ty}>() == {alignment});\n")
}
#[allow(
clippy::too_many_arguments,
reason = "the renderer's single final formatting boundary keeps item parts local"
)]
fn finish(
rust_name: &str,
syntax: &crate::discovery::TypeSyntax,
keyword: &str,
repr: &str,
body: String,
methods: String,
assertions: String,
size: u64,
alignment: u64,
) -> String {
let mut out = String::new();
emit_attributes(&mut out, &syntax.attributes, "");
out.push_str(repr);
out.push('\n');
write!(
out,
"{}{keyword} {rust_name} {{\n{body}}}\n",
visibility(&syntax.visibility)
)
.expect("writing to a String cannot fail");
if !methods.is_empty() {
write!(out, "impl {rust_name} {{\n{methods}}}\n").expect("writing to a String cannot fail");
}
write!(out, "const _: () = assert!(::core::mem::size_of::<usize>() == 8);\nconst _: () = assert!(::core::mem::size_of::<{rust_name}>() == {size});\nconst _: () = assert!(::core::mem::align_of::<{rust_name}>() == {alignment});\n{assertions}")
.expect("writing to a String cannot fail");
if !out.ends_with('\n') {
out.push('\n');
}
out
}