#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FieldLayout {
pub name: String,
pub offset: usize,
pub size: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ClassLayout {
pub size: usize,
pub alignment: usize,
pub union: bool,
pub fields: Vec<FieldLayout>,
pub unknown: Vec<String>,
}
impl ClassLayout {
pub fn of(members: &[(String, usize, usize)], union: bool, unknown: Vec<String>) -> Self {
let mut offset = 0usize;
let mut size = 0usize;
let mut alignment = 1usize;
let mut fields = Vec::with_capacity(members.len());
for (name, member_size, member_alignment) in members {
let member_alignment = (*member_alignment).max(1);
alignment = alignment.max(member_alignment);
if union {
fields.push(FieldLayout {
name: name.clone(),
offset: 0,
size: *member_size,
});
size = size.max(*member_size);
continue;
}
let at = offset.div_ceil(member_alignment) * member_alignment;
fields.push(FieldLayout {
name: name.clone(),
offset: at,
size: *member_size,
});
offset = at + member_size;
size = offset;
}
let size = size.max(1);
ClassLayout {
size: size.div_ceil(alignment) * alignment,
alignment,
union,
fields,
unknown,
}
}
pub fn describe(&self, name: &str) -> String {
let mut out = format!(
"**Layout** (x64)\n\nsize {} byte(s), alignment {}{}\n\n```text\n",
self.size,
self.alignment,
if self.union { ", a union" } else { "" }
);
out.push_str(&format!("{name}\n"));
for field in &self.fields {
out.push_str(&format!(
" {:<32} offset {:>3}, {} byte(s)\n",
field.name, field.offset, field.size
));
}
out.push_str("```\n");
out
}
}
pub fn a_builtin_in_memory(spelling: &str) -> Option<(usize, usize)> {
let mut word = spelling.trim();
let mut at = 0usize;
let bytes = word.as_bytes();
let mut depth = 0i32;
let mut angle = 0i32;
while at < bytes.len() {
match bytes[at] {
b'<' => angle += 1,
b'>' => angle -= 1,
b'(' | b'[' => {
if angle == 0 {
depth += 1
}
}
b')' | b']' => depth -= 1,
b'*' | b'&' if depth == 0 && angle == 0 => return Some((8, 8)),
_ => {}
}
at += 1;
}
if let Some((element, rest)) = word.split_once('[')
&& let Some(count) = rest.strip_suffix(']')
&& let Ok(count) = count.trim().parse::<usize>()
&& let Some((size, alignment)) = a_builtin_in_memory(element)
{
return Some((size.saturating_mul(count), alignment));
}
for qualifier in [
"const",
"volatile",
"static",
"extern",
"mutable",
"thread_local",
] {
if let Some(rest) = word.strip_prefix(qualifier)
&& rest.starts_with(char::is_whitespace)
{
word = rest.trim_start();
}
}
let words: Vec<&str> = word
.split(|character: char| character.is_whitespace() || character == '*' || character == '&')
.filter(|word| !word.is_empty())
.collect();
let has = |candidate: &str| words.contains(&candidate);
if has("bool") || has("_Bool") {
return Some((1, 1));
}
if has("char") || has("char8_t") {
return Some((1, 1));
}
if has("char16_t") {
return Some((2, 2));
}
if has("char32_t") || has("float") {
return Some((4, 4));
}
if has("short") || has("wchar_t") {
return Some((2, 2));
}
if has("double") {
return Some((8, 8));
}
if words.iter().filter(|word| **word == "long").count() >= 2 {
return Some((8, 8));
}
for (spelled, bytes) in [
("__int128", 16usize),
("__int64", 8),
("__int32", 4),
("__int16", 2),
("__int8", 1),
] {
if has(spelled) {
return Some((bytes, bytes.min(8)));
}
}
if has("long") || has("int") || has("unsigned") || has("signed") {
return Some((4, 4));
}
if has("void") {
return Some((1, 1));
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_struct_packs_its_members_with_their_own_alignment() {
let layout = ClassLayout::of(
&[("x".into(), 4, 4), ("y".into(), 8, 8), ("c".into(), 1, 1)],
false,
Vec::new(),
);
assert_eq!(layout.size, 24);
assert_eq!(layout.alignment, 8);
let offsets: Vec<(usize, usize)> = layout
.fields
.iter()
.map(|field| (field.offset, field.size))
.collect();
assert_eq!(offsets, [(0, 4), (8, 8), (16, 1)]);
}
#[test]
fn a_union_is_as_large_as_its_largest_member() {
let layout = ClassLayout::of(
&[("i".into(), 4, 4), ("d".into(), 8, 8), ("c".into(), 1, 1)],
true,
Vec::new(),
);
assert_eq!(layout.size, 8);
assert_eq!(layout.alignment, 8);
assert!(layout.fields.iter().all(|field| field.offset == 0));
}
#[test]
fn an_empty_class_is_one_byte() {
let layout = ClassLayout::of(&[], false, Vec::new());
assert_eq!(layout.size, 1);
assert_eq!(layout.alignment, 1);
}
#[test]
fn the_sized_integer_keywords_are_sized() {
assert_eq!(a_builtin_in_memory("__int64"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("unsigned __int64"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("__int32"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("__int16"), Some((2, 2)));
assert_eq!(a_builtin_in_memory("__int8"), Some((1, 1)));
assert_eq!(a_builtin_in_memory("const __int64"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("__int64*"), Some((8, 8)));
}
#[test]
fn the_builtins_and_the_shapes_around_them() {
assert_eq!(a_builtin_in_memory("int"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("unsigned long long"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("long"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("char"), Some((1, 1)));
assert_eq!(a_builtin_in_memory("char *"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("const Widget&"), Some((8, 8)));
assert_eq!(a_builtin_in_memory("int[4]"), Some((16, 4)));
assert_eq!(a_builtin_in_memory("double[3]"), Some((24, 8)));
assert_eq!(a_builtin_in_memory("Widget"), None);
assert_eq!(a_builtin_in_memory("std::string"), None);
}
#[test]
fn a_bare_unsigned_or_signed_is_an_int() {
assert_eq!(a_builtin_in_memory("unsigned"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("signed"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("unsigned int"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("unsigned char"), Some((1, 1)));
assert_eq!(a_builtin_in_memory("unsigned short"), Some((2, 2)));
assert_eq!(a_builtin_in_memory("unsigned long"), Some((4, 4)));
assert_eq!(a_builtin_in_memory("unsigned long long"), Some((8, 8)));
}
}