encounter/decomp-toolkit
1
0
Fork 0
mirror of https://github.com/encounter/decomp-toolkit.git synced 2025-06-08 15:43:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
decomp-toolkit/src/util/dwarf.rs

1941 lines
66 KiB
Rust
Raw Blame History

use std::{
collections::BTreeMap,
convert::TryFrom,
fmt::{Display, Formatter, Write},
io::{BufRead, Cursor, Seek, SeekFrom},
num::NonZeroU32,
};
use anyhow::{anyhow, bail, ensure, Context, Result};
use indent::indent_all_by;
use num_enum::{IntoPrimitive, TryFromPrimitive};
use crate::{
array_ref,
util::reader::{Endian, FromReader},
};
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u16)]
pub enum TagKind {
Padding = 0x0000,
ArrayType = 0x0001,
ClassType = 0x0002,
EntryPoint = 0x0003,
EnumerationType = 0x0004,
FormalParameter = 0x0005,
GlobalSubroutine = 0x0006,
GlobalVariable = 0x0007,
Label = 0x000a,
LexicalBlock = 0x000b,
LocalVariable = 0x000c,
Member = 0x000d,
PointerType = 0x000f,
ReferenceType = 0x0010,
// aka SourceFile
CompileUnit = 0x0011,
StringType = 0x0012,
StructureType = 0x0013,
Subroutine = 0x0014,
SubroutineType = 0x0015,
Typedef = 0x0016,
UnionType = 0x0017,
UnspecifiedParameters = 0x0018,
Variant = 0x0019,
CommonBlock = 0x001a,
CommonInclusion = 0x001b,
Inheritance = 0x001c,
InlinedSubroutine = 0x001d,
Module = 0x001e,
PtrToMemberType = 0x001f,
SetType = 0x0020,
SubrangeType = 0x0021,
WithStmt = 0x0022,
// User types
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u16)]
pub enum FundType {
WideChar = 0x0000, // Likely an MW bug
Char = 0x0001,
SignedChar = 0x0002,
UnsignedChar = 0x0003,
Short = 0x0004,
SignedShort = 0x0005,
UnsignedShort = 0x0006,
Integer = 0x0007,
SignedInteger = 0x0008,
UnsignedInteger = 0x0009,
Long = 0x000a,
SignedLong = 0x000b,
UnsignedLong = 0x000c,
Pointer = 0x000d,
Float = 0x000e,
DblPrecFloat = 0x000f,
ExtPrecFloat = 0x0010,
Complex = 0x0011,
DblPrecComplex = 0x0012,
Void = 0x0014,
Boolean = 0x0015,
ExtPrecComplex = 0x0016,
Label = 0x0017,
// User types
LongLong = 0x8008,
SignedLongLong = 0x8108,
UnsignedLongLong = 0x8208,
Vec2x32Float = 0xac00,
}
impl FundType {
pub fn size(self) -> Result<u32> {
Ok(match self {
FundType::Char | FundType::SignedChar | FundType::UnsignedChar | FundType::Boolean => 1,
FundType::WideChar
| FundType::Short
| FundType::SignedShort
| FundType::UnsignedShort => 2,
FundType::Integer | FundType::SignedInteger | FundType::UnsignedInteger => 4,
FundType::Long
| FundType::SignedLong
| FundType::UnsignedLong
| FundType::Pointer
| FundType::Float => 4,
FundType::DblPrecFloat
| FundType::LongLong
| FundType::SignedLongLong
| FundType::UnsignedLongLong
| FundType::Vec2x32Float => 8,
FundType::Void => 0,
FundType::ExtPrecFloat
| FundType::Complex
| FundType::DblPrecComplex
| FundType::ExtPrecComplex
| FundType::Label => bail!("Unhandled fundamental type {self:?}"),
})
}
pub fn name(self) -> Result<&'static str> {
Ok(match self {
FundType::WideChar => "wchar_t",
FundType::Char => "char",
FundType::SignedChar => "signed char",
FundType::UnsignedChar => "unsigned char",
FundType::Short => "short",
FundType::SignedShort => "signed short",
FundType::UnsignedShort => "unsigned short",
FundType::Integer => "int",
FundType::SignedInteger => "signed int",
FundType::UnsignedInteger => "unsigned int",
FundType::Long => "long",
FundType::SignedLong => "signed long",
FundType::UnsignedLong => "unsigned long",
FundType::Pointer => "void *",
FundType::Float => "float",
FundType::DblPrecFloat => "double",
FundType::ExtPrecFloat => "long double",
FundType::Void => "void",
FundType::Boolean => "bool",
FundType::Complex
| FundType::DblPrecComplex
| FundType::ExtPrecComplex
| FundType::Label => bail!("Unhandled fundamental type {self:?}"),
FundType::LongLong => "long long",
FundType::SignedLongLong => "signed long long",
FundType::UnsignedLongLong => "unsigned long long",
FundType::Vec2x32Float => "__vec2x32float__",
})
}
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u8)]
pub enum Modifier {
PointerTo = 0x01,
ReferenceTo = 0x02,
Const = 0x03,
Volatile = 0x04,
// User types
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u8)]
pub enum SubscriptFormat {
FundTypeConstConst = 0x0,
FundTypeConstLocation = 0x1,
FundTypeLocationConst = 0x2,
FundTypeLocationLocation = 0x3,
UserTypeConstConst = 0x4,
UserTypeConstLocation = 0x5,
UserTypeLocationConst = 0x6,
UserTypeLocationLocation = 0x7,
ElementType = 0x8,
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u8)]
pub enum LocationOp {
Register = 0x01,
BaseRegister = 0x02,
Address = 0x03,
Const = 0x04,
Deref2 = 0x05,
Deref4 = 0x06,
Add = 0x07,
// User types
MwFpReg = 0x80,
MwFpDReg = 0x81,
MwDRef8 = 0x82,
}
const FORM_MASK: u16 = 0xF;
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u16)]
enum FormKind {
Addr = 0x1,
Ref = 0x2,
Block2 = 0x3,
Block4 = 0x4,
Data2 = 0x5,
Data4 = 0x6,
Data8 = 0x7,
String = 0x8,
}
#[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
#[repr(u16)]
pub enum AttributeKind {
Sibling = 0x0010 | (FormKind::Ref as u16),
Location = 0x0020 | (FormKind::Block2 as u16),
Name = 0x0030 | (FormKind::String as u16),
FundType = 0x0050 | (FormKind::Data2 as u16),
ModFundType = 0x0060 | (FormKind::Block2 as u16),
UserDefType = 0x0070 | (FormKind::Ref as u16),
ModUDType = 0x0080 | (FormKind::Block2 as u16),
Ordering = 0x0090 | (FormKind::Data2 as u16),
SubscrData = 0x00a0 | (FormKind::Block2 as u16),
ByteSize = 0x00b0 | (FormKind::Data4 as u16),
BitOffset = 0x00c0 | (FormKind::Data2 as u16),
BitSize = 0x00d0 | (FormKind::Data4 as u16),
ElementList = 0x00f0 | (FormKind::Block4 as u16),
StmtList = 0x0100 | (FormKind::Data4 as u16),
LowPc = 0x0110 | (FormKind::Addr as u16),
HighPc = 0x0120 | (FormKind::Addr as u16),
Language = 0x0130 | (FormKind::Data4 as u16),
Member = 0x0140 | (FormKind::Ref as u16),
Discr = 0x0150 | (FormKind::Ref as u16),
DiscrValue = 0x0160 | (FormKind::Block2 as u16),
StringLength = 0x0190 | (FormKind::Block2 as u16),
CommonReference = 0x01a0 | (FormKind::Ref as u16),
CompDir = 0x01b0 | (FormKind::String as u16),
ConstValueString = 0x01c0 | (FormKind::String as u16),
ConstValueData2 = 0x01c0 | (FormKind::Data2 as u16),
ConstValueData4 = 0x01c0 | (FormKind::Data4 as u16),
ConstValueData8 = 0x01c0 | (FormKind::Data8 as u16),
ConstValueBlock2 = 0x01c0 | (FormKind::Block2 as u16),
ConstValueBlock4 = 0x01c0 | (FormKind::Block4 as u16),
ContainingType = 0x01d0 | (FormKind::Ref as u16),
DefaultValueAddr = 0x01e0 | (FormKind::Addr as u16),
DefaultValueData2 = 0x01e0 | (FormKind::Data2 as u16),
DefaultValueData8 = 0x01e0 | (FormKind::Data8 as u16),
DefaultValueString = 0x01e0 | (FormKind::String as u16),
Friends = 0x01f0 | (FormKind::Block2 as u16),
Inline = 0x0200 | (FormKind::String as u16),
IsOptional = 0x0210 | (FormKind::String as u16),
LowerBoundRef = 0x0220 | (FormKind::Ref as u16),
LowerBoundData2 = 0x0220 | (FormKind::Data2 as u16),
LowerBoundData4 = 0x0220 | (FormKind::Data4 as u16),
LowerBoundData8 = 0x0220 | (FormKind::Data8 as u16),
Program = 0x0230 | (FormKind::String as u16),
Private = 0x0240 | (FormKind::String as u16),
Producer = 0x0250 | (FormKind::String as u16),
Protected = 0x0260 | (FormKind::String as u16),
Prototyped = 0x0270 | (FormKind::String as u16),
Public = 0x0280 | (FormKind::String as u16),
PureVirtual = 0x0290 | (FormKind::String as u16),
ReturnAddr = 0x02a0 | (FormKind::Block2 as u16),
Specification = 0x02b0 | (FormKind::Ref as u16),
StartScope = 0x02c0 | (FormKind::Data4 as u16),
StrideSize = 0x02e0 | (FormKind::Data4 as u16),
UpperBoundRef = 0x02f0 | (FormKind::Ref as u16),
UpperBoundData2 = 0x02f0 | (FormKind::Data2 as u16),
UpperBoundData4 = 0x02f0 | (FormKind::Data4 as u16),
UpperBoundData8 = 0x02f0 | (FormKind::Data8 as u16),
Virtual = 0x0300 | (FormKind::String as u16),
LoUser = 0x2000,
HiUser = 0x3ff0,
// User types
MwMangled = 0x2000 | (FormKind::String as u16),
MwGlobalRef = 0x2020 | (FormKind::Ref as u16),
MwGlobalRefByName = 0x2030 | (FormKind::String as u16),
MwDwarf2Location = 0x2340 | (FormKind::Block2 as u16),
Unknown800 = 0x8000 | (FormKind::Data4 as u16),
Unknown801 = 0x8010 | (FormKind::Data4 as u16),
MwPrologueEnd = 0x8040 | (FormKind::Addr as u16),
MwEpilogueStart = 0x8050 | (FormKind::Addr as u16),
}
#[derive(Debug, Clone)]
pub enum AttributeValue {
Address(u32),
Reference(u32),
Data2(u16),
Data4(u32),
Data8(u64),
Block(Vec<u8>),
String(String),
}
#[derive(Debug, Clone)]
pub struct Attribute {
pub kind: AttributeKind,
pub value: AttributeValue,
}
#[derive(Debug, Clone)]
pub struct Tag {
pub key: u32,
pub kind: TagKind,
pub attributes: Vec<Attribute>,
}
pub type TagMap = BTreeMap<u32, Tag>;
pub type TypedefMap = BTreeMap<u32, Vec<u32>>;
impl Tag {
#[inline]
pub fn attribute(&self, kind: AttributeKind) -> Option<&Attribute> {
self.attributes.iter().find(|attr| attr.kind == kind)
}
#[inline]
pub fn address_attribute(&self, kind: AttributeKind) -> Option<u32> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::Address(addr), .. }) => Some(*addr),
_ => None,
}
}
#[inline]
pub fn reference_attribute(&self, kind: AttributeKind) -> Option<u32> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::Reference(addr), .. }) => Some(*addr),
_ => None,
}
}
#[inline]
pub fn string_attribute(&self, kind: AttributeKind) -> Option<&String> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::String(str), .. }) => Some(str),
_ => None,
}
}
#[inline]
pub fn block_attribute(&self, kind: AttributeKind) -> Option<&[u8]> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::Block(vec), .. }) => Some(vec),
_ => None,
}
}
#[inline]
pub fn data4_attribute(&self, kind: AttributeKind) -> Option<u32> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::Data4(value), .. }) => Some(*value),
_ => None,
}
}
#[inline]
pub fn data2_attribute(&self, kind: AttributeKind) -> Option<u16> {
match self.attribute(kind) {
Some(Attribute { value: AttributeValue::Data2(value), .. }) => Some(*value),
_ => None,
}
}
#[inline]
pub fn type_attribute(&self) -> Option<&Attribute> {
self.attributes.iter().find(|attr| {
matches!(
attr.kind,
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType
)
})
}
pub fn children<'a>(&self, tags: &'a TagMap) -> Vec<&'a Tag> {
let sibling = self.next_sibling(tags);
let mut children = Vec::new();
let mut child = match self.next_tag(tags) {
Some(child) => child,
None => return children,
};
loop {
if let Some(end) = sibling {
if child.key == end.key {
break;
}
}
if child.kind != TagKind::Padding {
children.push(child);
}
match child.next_sibling(tags) {
Some(next) => child = next,
None => break,
}
}
children
}
/// Returns the next sibling tag, if any
pub fn next_sibling<'a>(&self, tags: &'a TagMap) -> Option<&'a Tag> {
if let Some(key) = self.reference_attribute(AttributeKind::Sibling) {
tags.get(&key)
} else {
self.next_tag(tags)
}
}
/// Returns the next tag sequentially, if any
pub fn next_tag<'a>(&self, tags: &'a TagMap) -> Option<&'a Tag> {
tags.range(self.key + 1..).next().map(|(_, tag)| tag)
}
}
pub fn read_debug_section<R>(reader: &mut R) -> Result<TagMap>
where R: BufRead + Seek + ?Sized {
let len = {
let old_pos = reader.stream_position()?;
let len = reader.seek(SeekFrom::End(0))?;
reader.seek(SeekFrom::Start(old_pos))?;
len
};
let mut tags = BTreeMap::new();
loop {
let position = reader.stream_position()?;
if position >= len {
break;
}
let tag = read_tag(reader)?;
tags.insert(position as u32, tag);
}
Ok(tags)
}
#[allow(unused)]
pub fn read_aranges_section<R>(reader: &mut R) -> Result<()>
where R: BufRead + Seek + ?Sized {
let len = {
let old_pos = reader.stream_position()?;
let len = reader.seek(SeekFrom::End(0))?;
reader.seek(SeekFrom::Start(old_pos))?;
len
};
// let mut tags = BTreeMap::new();
loop {
let position = reader.stream_position()?;
if position >= len {
break;
}
let size = u32::from_reader(reader, Endian::Big)?;
let version = u8::from_reader(reader, Endian::Big)?;
ensure!(version == 1, "Expected version 1, got {version}");
let _debug_offs = u32::from_reader(reader, Endian::Big)?;
let _debug_size = u32::from_reader(reader, Endian::Big)?;
while reader.stream_position()? < position + size as u64 {
let _address = u32::from_reader(reader, Endian::Big)?;
let _length = u32::from_reader(reader, Endian::Big)?;
}
}
Ok(())
}
fn read_tag<R>(reader: &mut R) -> Result<Tag>
where R: BufRead + Seek + ?Sized {
let position = reader.stream_position()?;
let size = u32::from_reader(reader, Endian::Big)?;
if size < 8 {
// Null entry
if size > 4 {
reader.seek(SeekFrom::Current(size as i64 - 4))?;
}
return Ok(Tag { key: position as u32, kind: TagKind::Padding, attributes: vec![] });
}
let tag = TagKind::try_from(u16::from_reader(reader, Endian::Big)?)
.context("Unknown DWARF tag type")?;
let mut attributes = Vec::new();
if tag == TagKind::Padding {
reader.seek(SeekFrom::Start(position + size as u64))?; // Skip padding
} else {
while reader.stream_position()? < position + size as u64 {
let attribute = read_attribute(reader)?;
attributes.push(attribute);
}
}
Ok(Tag { key: position as u32, kind: tag, attributes })
}
// TODO Shift-JIS?
fn read_string<R>(reader: &mut R) -> Result<String>
where R: BufRead + ?Sized {
let mut str = String::new();
let mut buf = [0u8; 1];
loop {
reader.read_exact(&mut buf)?;
if buf[0] == 0 {
break;
}
str.push(buf[0] as char);
}
Ok(str)
}
fn read_attribute<R>(reader: &mut R) -> Result<Attribute>
where R: BufRead + Seek + ?Sized {
let attr_type = u16::from_reader(reader, Endian::Big)?;
let attr = AttributeKind::try_from(attr_type).context("Unknown DWARF attribute type")?;
let form = FormKind::try_from(attr_type & FORM_MASK).context("Unknown DWARF form type")?;
let value = match form {
FormKind::Addr => AttributeValue::Address(u32::from_reader(reader, Endian::Big)?),
FormKind::Ref => AttributeValue::Reference(u32::from_reader(reader, Endian::Big)?),
FormKind::Block2 => {
let size = u16::from_reader(reader, Endian::Big)?;
let mut data = vec![0u8; size as usize];
reader.read_exact(&mut data)?;
AttributeValue::Block(data)
}
FormKind::Block4 => {
let size = u32::from_reader(reader, Endian::Big)?;
let mut data = vec![0u8; size as usize];
reader.read_exact(&mut data)?;
AttributeValue::Block(data)
}
FormKind::Data2 => AttributeValue::Data2(u16::from_reader(reader, Endian::Big)?),
FormKind::Data4 => AttributeValue::Data4(u32::from_reader(reader, Endian::Big)?),
FormKind::Data8 => AttributeValue::Data8(u64::from_reader(reader, Endian::Big)?),
FormKind::String => AttributeValue::String(read_string(reader)?),
};
Ok(Attribute { kind: attr, value })
}
#[derive(Debug, Clone)]
pub struct ArrayDimension {
pub index_type: Type,
pub size: Option<NonZeroU32>,
}
#[derive(Debug, Clone)]
pub struct ArrayType {
pub element_type: Box<Type>,
pub dimensions: Vec<ArrayDimension>,
}
#[derive(Debug, Clone)]
pub struct BitData {
pub bit_size: u32,
pub bit_offset: u16,
}
#[derive(Debug, Clone)]
pub struct StructureMember {
pub name: String,
pub kind: Type,
pub offset: u32,
pub bit: Option<BitData>,
pub visibility: Visibility,
pub byte_size: Option<u32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StructureKind {
Struct,
Class,
}
#[derive(Debug, Clone)]
pub struct StructureType {
pub kind: StructureKind,
pub name: Option<String>,
pub byte_size: u32,
pub members: Vec<StructureMember>,
pub bases: Vec<StructureBase>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Visibility {
Private,
Protected,
Public,
}
#[derive(Debug, Clone)]
pub struct StructureBase {
pub name: String,
pub base_type: Type,
pub offset: u32,
pub visibility: Visibility,
pub virtual_base: bool,
}
#[derive(Debug, Clone)]
pub struct EnumerationMember {
pub name: String,
pub value: i32,
}
#[derive(Debug, Clone)]
pub struct EnumerationType {
pub name: Option<String>,
pub byte_size: u32,
pub members: Vec<EnumerationMember>,
}
#[derive(Debug, Clone)]
pub struct UnionType {
pub name: Option<String>,
pub byte_size: u32,
pub members: Vec<StructureMember>,
}
#[derive(Debug, Clone)]
pub struct SubroutineParameter {
pub name: Option<String>,
pub kind: Type,
pub location: Option<String>,
}
#[derive(Debug, Clone)]
pub struct SubroutineVariable {
pub name: Option<String>,
pub kind: Type,
pub location: Option<String>,
}
#[derive(Debug, Clone)]
pub struct SubroutineType {
pub name: Option<String>,
pub mangled_name: Option<String>,
pub return_type: Type,
pub parameters: Vec<SubroutineParameter>,
pub var_args: bool,
pub prototyped: bool,
pub references: Vec<u32>,
pub member_of: Option<u32>,
pub variables: Vec<SubroutineVariable>,
}
#[derive(Debug, Clone)]
pub struct PtrToMemberType {
pub kind: Type,
pub containing_type: u32,
}
#[derive(Debug, Clone)]
pub enum UserDefinedType {
Array(ArrayType),
Structure(StructureType),
Enumeration(EnumerationType),
Union(UnionType),
Subroutine(SubroutineType),
PtrToMember(PtrToMemberType),
}
#[derive(Debug, Clone)]
pub struct VariableTag {
pub name: Option<String>,
pub mangled_name: Option<String>,
pub kind: Type,
pub address: Option<u32>,
pub local: bool,
}
#[derive(Debug, Clone)]
pub struct TypedefTag {
pub name: String,
pub kind: Type,
}
#[derive(Debug, Clone)]
pub enum TagType {
Variable(VariableTag),
Typedef(TypedefTag),
UserDefined(UserDefinedType),
}
impl UserDefinedType {
pub fn is_definition(&self) -> bool {
match self {
UserDefinedType::Array(_) | UserDefinedType::PtrToMember(_) => false,
UserDefinedType::Structure(t) => t.name.is_some(),
UserDefinedType::Enumeration(t) => t.name.is_some(),
UserDefinedType::Union(t) => t.name.is_some(),
UserDefinedType::Subroutine(t) => t.name.is_some(),
}
}
pub fn size(&self, tags: &TagMap) -> Result<u32> {
Ok(match self {
UserDefinedType::Array(t) => {
let mut size = t.element_type.size(tags)?;
for dim in &t.dimensions {
size *= dim.size.map(|u| u.get()).unwrap_or_default();
}
size
}
UserDefinedType::Structure(t) => t.byte_size,
UserDefinedType::Enumeration(t) => t.byte_size,
UserDefinedType::Union(t) => t.byte_size,
UserDefinedType::Subroutine(_) => 0,
UserDefinedType::PtrToMember(_) => 4,
})
}
}
#[derive(Debug, Copy, Clone)]
pub enum TypeKind {
Fundamental(FundType),
UserDefined(u32),
}
#[derive(Debug, Clone)]
pub struct Type {
pub kind: TypeKind,
pub modifiers: Vec<Modifier>,
}
impl Type {
pub fn size(&self, tags: &TagMap) -> Result<u32> {
if self.modifiers.iter().any(|m| matches!(m, Modifier::PointerTo | Modifier::ReferenceTo)) {
return Ok(4);
}
match self.kind {
TypeKind::Fundamental(ft) => ft.size(),
TypeKind::UserDefined(key) => {
let tag = tags
.get(&key)
.ok_or_else(|| anyhow!("Failed to locate user defined type {}", key))?;
let ud_type = ud_type(tags, tag)?;
ud_type.size(tags)
}
}
}
}
pub fn apply_modifiers(mut str: TypeString, modifiers: &[Modifier]) -> Result<TypeString> {
let mut has_pointer = false;
for &modifier in modifiers.iter().rev() {
match modifier {
Modifier::PointerTo => {
if !has_pointer && !str.suffix.is_empty() {
if str.member.is_empty() {
str.prefix.push_str(" (*");
} else {
write!(str.prefix, " ({}*", str.member)?;
}
str.suffix.insert(0, ')');
} else {
str.prefix.push_str(" *");
}
has_pointer = true;
}
Modifier::ReferenceTo => {
if !has_pointer && !str.suffix.is_empty() {
str.prefix.push_str(" (&");
str.suffix.insert(0, ')');
} else {
str.prefix.push_str(" &");
}
has_pointer = true;
}
Modifier::Const => {
if has_pointer {
str.prefix.push_str(" const");
} else {
str.prefix.insert_str(0, "const ");
}
}
Modifier::Volatile => {
if has_pointer {
str.prefix.push_str(" volatile");
} else {
str.prefix.insert_str(0, "volatile ");
}
}
}
}
Ok(str)
}
#[derive(Debug, Default, Clone)]
pub struct TypeString {
pub prefix: String,
pub suffix: String,
// TODO: rework this eventually and merge with PTMF handling
pub member: String,
}
impl Display for TypeString {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if self.member.is_empty() {
write!(f, "{}{}", self.prefix, self.suffix)?;
} else {
// TODO member print likely wrong
write!(f, "{} {}{}", self.prefix, self.member, self.suffix)?;
}
Ok(())
}
}
pub fn type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &Type,
include_anonymous_def: bool,
) -> Result<TypeString> {
let str = match t.kind {
TypeKind::Fundamental(ft) => {
TypeString { prefix: ft.name()?.to_string(), ..Default::default() }
}
TypeKind::UserDefined(key) => {
if let Some(&td_key) = typedefs.get(&key).and_then(|v| v.first()) {
let tag =
tags.get(&td_key).ok_or_else(|| anyhow!("Failed to locate typedef {}", key))?;
let td_name = tag
.string_attribute(AttributeKind::Name)
.ok_or_else(|| anyhow!("typedef without name"))?;
TypeString { prefix: td_name.clone(), ..Default::default() }
} else {
let tag = tags
.get(&key)
.ok_or_else(|| anyhow!("Failed to locate user defined type {}", key))?;
ud_type_string(tags, typedefs, &ud_type(tags, tag)?, true, include_anonymous_def)?
}
}
};
apply_modifiers(str, &t.modifiers)
}
fn array_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &ArrayType,
include_anonymous_def: bool,
) -> Result<TypeString> {
let mut out = type_string(tags, typedefs, t.element_type.as_ref(), include_anonymous_def)?;
for dim in &t.dimensions {
ensure!(
matches!(
dim.index_type.kind,
TypeKind::Fundamental(FundType::Long | FundType::Integer)
),
"Unsupported array index type '{}'",
type_string(tags, typedefs, &dim.index_type, true)?
);
match dim.size {
None => out.suffix.insert_str(0, "[]"),
Some(size) => out.suffix = format!("[{}]{}", size, out.suffix),
};
}
Ok(out)
}
fn structure_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &StructureType,
include_keyword: bool,
include_anonymous_def: bool,
) -> Result<TypeString> {
let prefix = if let Some(name) = t.name.as_ref() {
if include_keyword {
match t.kind {
StructureKind::Struct => format!("struct {}", name),
StructureKind::Class => format!("class {}", name),
}
} else {
name.clone()
}
} else if include_anonymous_def {
struct_def_string(tags, typedefs, t)?
} else if include_keyword {
match t.kind {
StructureKind::Struct => "struct [anonymous]".to_string(),
StructureKind::Class => "class [anonymous]".to_string(),
}
} else {
match t.kind {
StructureKind::Struct => "[anonymous struct]".to_string(),
StructureKind::Class => "[anonymous class]".to_string(),
}
};
Ok(TypeString { prefix, ..Default::default() })
}
fn enumeration_type_string(
_tags: &TagMap,
_typedefs: &TypedefMap,
t: &EnumerationType,
include_keyword: bool,
include_anonymous_def: bool,
) -> Result<TypeString> {
let prefix = if let Some(name) = t.name.as_ref() {
if include_keyword {
format!("enum {}", name)
} else {
name.clone()
}
} else if include_anonymous_def {
enum_def_string(t)?
} else if include_keyword {
"enum [anonymous]".to_string()
} else {
"[anonymous enum]".to_string()
};
Ok(TypeString { prefix, ..Default::default() })
}
fn union_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &UnionType,
include_keyword: bool,
include_anonymous_def: bool,
) -> Result<TypeString> {
let prefix = if let Some(name) = t.name.as_ref() {
if include_keyword {
format!("union {}", name)
} else {
name.clone()
}
} else if include_anonymous_def {
union_def_string(tags, typedefs, t)?
} else if include_keyword {
"union [anonymous]".to_string()
} else {
"[anonymous union]".to_string()
};
Ok(TypeString { prefix, ..Default::default() })
}
pub fn ud_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &UserDefinedType,
include_keyword: bool,
include_anonymous_def: bool,
) -> Result<TypeString> {
Ok(match t {
UserDefinedType::Array(t) => array_type_string(tags, typedefs, t, include_anonymous_def)?,
UserDefinedType::Structure(t) => {
structure_type_string(tags, typedefs, t, include_keyword, include_anonymous_def)?
}
UserDefinedType::Enumeration(t) => {
enumeration_type_string(tags, typedefs, t, include_keyword, include_anonymous_def)?
}
UserDefinedType::Union(t) => {
union_type_string(tags, typedefs, t, include_keyword, include_anonymous_def)?
}
UserDefinedType::Subroutine(t) => subroutine_type_string(tags, typedefs, t)?,
UserDefinedType::PtrToMember(t) => ptr_to_member_type_string(tags, typedefs, t)?,
})
}
fn ptr_to_member_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &PtrToMemberType,
) -> Result<TypeString> {
let ts = type_string(tags, typedefs, &t.kind, true)?;
let containing_type = tags
.get(&t.containing_type)
.ok_or_else(|| anyhow!("Failed to locate containing type {}", t.containing_type))?;
let containing_ts =
ud_type_string(tags, typedefs, &ud_type(tags, containing_type)?, false, false)?;
Ok(TypeString {
prefix: format!("{} ({}::*", ts.prefix, containing_ts.prefix),
suffix: format!("{}){}", containing_ts.suffix, ts.suffix),
..Default::default()
})
}
pub fn ud_type_def(tags: &TagMap, typedefs: &TypedefMap, t: &UserDefinedType) -> Result<String> {
match t {
UserDefinedType::Array(t) => {
let ts = array_type_string(tags, typedefs, t, false)?;
Ok(format!("// Array: {}{}", ts.prefix, ts.suffix))
}
UserDefinedType::Subroutine(t) => Ok(subroutine_def_string(tags, typedefs, t)?),
UserDefinedType::Structure(t) => Ok(struct_def_string(tags, typedefs, t)?),
UserDefinedType::Enumeration(t) => Ok(enum_def_string(t)?),
UserDefinedType::Union(t) => Ok(union_def_string(tags, typedefs, t)?),
UserDefinedType::PtrToMember(t) => {
let ts = ptr_to_member_type_string(tags, typedefs, t)?;
Ok(format!("// PtrToMember: {}{}", ts.prefix, ts.suffix))
}
}
}
pub fn subroutine_type_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &SubroutineType,
) -> Result<TypeString> {
let mut out = type_string(tags, typedefs, &t.return_type, true)?;
let mut parameters = String::new();
if t.parameters.is_empty() {
if t.var_args {
parameters = "...".to_string();
} else if t.prototyped {
parameters = "void".to_string();
}
} else {
for (idx, parameter) in t.parameters.iter().enumerate() {
if idx > 0 {
write!(parameters, ", ")?;
}
let ts = type_string(tags, typedefs, &parameter.kind, true)?;
if let Some(name) = &parameter.name {
write!(parameters, "{} {}{}", ts.prefix, name, ts.suffix)?;
} else {
write!(parameters, "{}{}", ts.prefix, ts.suffix)?;
}
if let Some(location) = &parameter.location {
write!(parameters, " /* {} */", location)?;
}
}
if t.var_args {
write!(parameters, ", ...")?;
}
}
out.suffix = format!("({}){}", parameters, out.suffix);
if let Some(member_of) = t.member_of {
let tag = tags
.get(&member_of)
.ok_or_else(|| anyhow!("Failed to locate member_of tag {}", member_of))?;
let base_name = tag
.string_attribute(AttributeKind::Name)
.ok_or_else(|| anyhow!("member_of tag {} has no name attribute", member_of))?;
out.member = format!("{}::", base_name);
}
Ok(out)
}
pub fn subroutine_def_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &SubroutineType,
) -> Result<String> {
let rt = type_string(tags, typedefs, &t.return_type, true)?;
let mut out = rt.prefix;
out.push(' ');
let mut name_written = false;
if let Some(member_of) = t.member_of {
let tag = tags
.get(&member_of)
.ok_or_else(|| anyhow!("Failed to locate member_of tag {}", member_of))?;
let base_name = tag
.string_attribute(AttributeKind::Name)
.ok_or_else(|| anyhow!("member_of tag {} has no name attribute", member_of))?;
write!(out, "{}::", base_name)?;
// Handle constructors and destructors
if let Some(name) = t.name.as_ref() {
if name == "__dt" {
write!(out, "~{}", base_name)?;
name_written = true;
} else if name == "__ct" {
write!(out, "{}", base_name)?;
name_written = true;
}
}
}
if !name_written {
if let Some(name) = t.name.as_ref() {
out.push_str(name);
}
}
let mut parameters = String::new();
if t.parameters.is_empty() {
if t.var_args {
parameters = "...".to_string();
} else if t.prototyped {
parameters = "void".to_string();
}
} else {
for (idx, parameter) in t.parameters.iter().enumerate() {
if idx > 0 {
write!(parameters, ", ")?;
}
let ts = type_string(tags, typedefs, &parameter.kind, true)?;
if let Some(name) = &parameter.name {
write!(parameters, "{} {}{}", ts.prefix, name, ts.suffix)?;
} else {
write!(parameters, "{}{}", ts.prefix, ts.suffix)?;
}
if let Some(location) = &parameter.location {
write!(parameters, " /* {} */", location)?;
}
}
if t.var_args {
write!(out, ", ...")?;
}
}
write!(out, "({}){} {{", parameters, rt.suffix)?;
if !t.variables.is_empty() {
writeln!(out, "\n // Local variables")?;
let mut var_out = String::new();
for variable in &t.variables {
let ts = type_string(tags, typedefs, &variable.kind, true)?;
write!(
var_out,
"{} {}{};",
ts.prefix,
variable.name.as_deref().unwrap_or_default(),
ts.suffix
)?;
if let Some(location) = &variable.location {
write!(var_out, " // {}", location)?;
}
writeln!(var_out)?;
}
write!(out, "{}", indent_all_by(4, var_out))?;
}
if !t.references.is_empty() {
writeln!(out, "\n // References")?;
for &reference in &t.references {
let tag = tags
.get(&reference)
.ok_or_else(|| anyhow!("Failed to locate reference tag {}", reference))?;
if tag.kind == TagKind::Padding {
writeln!(out, " // -> ??? ({})", reference)?;
continue;
}
let variable = process_variable_tag(tags, tag)?;
writeln!(out, " // -> {}", variable_string(tags, typedefs, &variable, false)?)?;
}
}
writeln!(out, "}}")?;
Ok(out)
}
pub fn struct_def_string(
tags: &TagMap,
typedefs: &TypedefMap,
t: &StructureType,
) -> Result<String> {
let mut out = match t.kind {
StructureKind::Struct => "struct".to_string(),
StructureKind::Class => "class".to_string(),
};
if let Some(name) = t.name.as_ref() {
write!(out, " {}", name)?;
}
let mut wrote_base = false;
for base in &t.bases {
if !wrote_base {
out.push_str(" : ");
wrote_base = true;
} else {
out.push_str(", ");
}
match base.visibility {
Visibility::Private => out.push_str("private "),
Visibility::Protected => out.push_str("protected "),
Visibility::Public => out.push_str("public "),
}
if base.virtual_base {
out.push_str("virtual ");
}
out.push_str(&base.name);
}
writeln!(out, " {{\n // total size: {:#X}", t.byte_size)?;
let mut var_out = String::new();
for member in &t.members {
let ts = type_string(tags, typedefs, &member.kind, true)?;
write!(var_out, "{} {}{}", ts.prefix, member.name, ts.suffix)?;
if let Some(bit) = &member.bit {
write!(var_out, " : {}", bit.bit_size)?;
}
let size = if let Some(size) = member.byte_size { size } else { member.kind.size(tags)? };
writeln!(var_out, "; // offset {:#X}, size {:#X}", member.offset, size)?;
}
write!(out, "{}", indent_all_by(4, var_out))?;
write!(out, "}}")?;
Ok(out)
}
pub fn enum_def_string(t: &EnumerationType) -> Result<String> {
let mut out = match t.name.as_ref() {
Some(name) => format!("enum {} {{\n", name),
None => "enum {\n".to_string(),
};
for member in t.members.iter() {
writeln!(out, " {} = {},", member.name, member.value)?;
}
write!(out, "}}")?;
Ok(out)
}
pub fn union_def_string(tags: &TagMap, typedefs: &TypedefMap, t: &UnionType) -> Result<String> {
let mut out = match t.name.as_ref() {
Some(name) => format!("union {} {{\n", name),
None => "union {\n".to_string(),
};
let mut var_out = String::new();
for member in t.members.iter() {
let ts = type_string(tags, typedefs, &member.kind, true)?;
write!(var_out, "{} {}{};", ts.prefix, member.name, ts.suffix)?;
let size = if let Some(size) = member.byte_size { size } else { member.kind.size(tags)? };
write!(var_out, " // offset {:#X}, size {:#X}", member.offset, size)?;
writeln!(var_out)?;
}
write!(out, "{}", indent_all_by(4, var_out))?;
write!(out, "}}")?;
Ok(out)
}
pub fn process_offset(block: &[u8]) -> Result<u32> {
if block.len() == 6 && block[0] == LocationOp::Const as u8 && block[5] == LocationOp::Add as u8
{
Ok(u32::from_be_bytes(*array_ref!(block, 1, 4)))
} else {
Err(anyhow!("Unhandled location data, expected offset"))
}
}
pub fn process_address(block: &[u8]) -> Result<u32> {
if block.len() == 5 && block[0] == LocationOp::Address as u8 {
Ok(u32::from_be_bytes(*array_ref!(block, 1, 4)))
} else {
Err(anyhow!("Unhandled location data, expected address"))
}
}
pub const REGISTER_NAMES: [&str; 109] = [
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", // 0-7
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", // 8-15
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", // 16-23
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", // 24-31
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", // 32-39
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", // 40-47
"f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", // 48-55
"f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", // 56-63
"mq", "lr", "ctr", "ap", "cr0", "cr1", "cr2", "cr3", // 64-71
"cr4", "cr5", "cr6", "cr7", "xer", "v0", "v1", "v2", // 72-79
"v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", // 80-87
"v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", // 88-95
"v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", // 96-103
"v27", "v28", "v29", "v30", "v31", // 104-108
];
pub const fn register_name(reg: u32) -> &'static str {
if reg < REGISTER_NAMES.len() as u32 {
REGISTER_NAMES[reg as usize]
} else {
"[invalid]"
}
}
pub fn process_variable_location(block: &[u8]) -> Result<String> {
if block.len() == 5
&& (block[0] == LocationOp::Register as u8 || block[0] == LocationOp::BaseRegister as u8)
{
Ok(register_name(u32::from_be_bytes(*array_ref!(block, 1, 4))).to_string())
} else if block.len() == 5 && block[0] == LocationOp::Address as u8 {
Ok(format!("@ {:#010X}", u32::from_be_bytes(*array_ref!(block, 1, 4))))
} else if block.len() == 11
&& block[0] == LocationOp::BaseRegister as u8
&& block[5] == LocationOp::Const as u8
&& block[10] == LocationOp::Add as u8
{
Ok(format!(
"{}+{:#X}",
register_name(u32::from_be_bytes(*array_ref!(block, 1, 4))),
u32::from_be_bytes(*array_ref!(block, 6, 4))
))
} else {
Err(anyhow!("Unhandled location data {:?}, expected variable loc", block))
}
}
fn process_inheritance_tag(tags: &TagMap, tag: &Tag) -> Result<StructureBase> {
ensure!(tag.kind == TagKind::Inheritance, "{:?} is not an Inheritance tag", tag.kind);
let mut name = None;
let mut base_type = None;
let mut offset = None;
let mut visibility = None;
let mut virtual_base = false;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => base_type = Some(process_type(attr)?),
(AttributeKind::Location, AttributeValue::Block(block)) => {
offset = Some(process_offset(block)?)
}
(AttributeKind::Private, _) => visibility = Some(Visibility::Private),
(AttributeKind::Protected, _) => visibility = Some(Visibility::Protected),
(AttributeKind::Public, _) => visibility = Some(Visibility::Public),
(AttributeKind::Virtual, _) => virtual_base = true,
_ => {
bail!("Unhandled Inheritance attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled Inheritance child {:?}", child.kind);
}
let name = name.ok_or_else(|| anyhow!("Inheritance without name: {:?}", tag))?;
let base_type = base_type.ok_or_else(|| anyhow!("Inheritance without base type: {:?}", tag))?;
let offset = offset.ok_or_else(|| anyhow!("Inheritance without offset: {:?}", tag))?;
let visibility =
visibility.ok_or_else(|| anyhow!("Inheritance without visibility: {:?}", tag))?;
Ok(StructureBase { name, base_type, offset, visibility, virtual_base })
}
fn process_structure_member_tag(tags: &TagMap, tag: &Tag) -> Result<StructureMember> {
ensure!(tag.kind == TagKind::Member, "{:?} is not a Member tag", tag.kind);
let mut name = None;
let mut member_type = None;
let mut offset = None;
let mut byte_size = None;
let mut bit_size = None;
let mut bit_offset = None;
let mut visibility = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => member_type = Some(process_type(attr)?),
(AttributeKind::Location, AttributeValue::Block(block)) => {
offset = Some(process_offset(block)?)
}
(AttributeKind::ByteSize, &AttributeValue::Data4(value)) => byte_size = Some(value),
(AttributeKind::BitSize, &AttributeValue::Data4(value)) => bit_size = Some(value),
(AttributeKind::BitOffset, &AttributeValue::Data2(value)) => bit_offset = Some(value),
(AttributeKind::Private, _) => visibility = Some(Visibility::Private),
(AttributeKind::Protected, _) => visibility = Some(Visibility::Protected),
(AttributeKind::Public, _) => visibility = Some(Visibility::Public),
_ => {
bail!("Unhandled Member attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled Member child {:?}", child.kind);
}
let name = name.ok_or_else(|| anyhow!("Member without name: {:?}", tag))?;
let member_type = member_type.ok_or_else(|| anyhow!("Member without type: {:?}", tag))?;
let offset = offset.ok_or_else(|| anyhow!("Member without offset: {:?}", tag))?;
let bit = match (bit_size, bit_offset) {
(Some(bit_size), Some(bit_offset)) => Some(BitData { bit_size, bit_offset }),
(None, None) => None,
_ => bail!("Mismatched bit attributes in Member: {tag:?}"),
};
let visibility = visibility.unwrap_or(Visibility::Public);
Ok(StructureMember {
name: name.clone(),
kind: member_type,
offset,
bit,
visibility,
byte_size,
})
}
fn process_structure_tag(tags: &TagMap, tag: &Tag) -> Result<StructureType> {
ensure!(
matches!(tag.kind, TagKind::StructureType | TagKind::ClassType),
"{:?} is not a Structure type tag",
tag.kind
);
let mut name = None;
let mut byte_size = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(AttributeKind::ByteSize, &AttributeValue::Data4(value)) => byte_size = Some(value),
_ => {
bail!("Unhandled structure attribute {:?}", attr);
}
}
}
let mut members = Vec::new();
let mut bases = Vec::new();
for child in tag.children(tags) {
match child.kind {
TagKind::Inheritance => bases.push(process_inheritance_tag(tags, child)?),
TagKind::Member => members.push(process_structure_member_tag(tags, child)?),
TagKind::Typedef => {
// TODO?
// info!("Structure {:?} Typedef: {:?}", name, child);
}
kind => bail!("Unhandled StructureType child {:?}", kind),
}
}
let byte_size =
byte_size.ok_or_else(|| anyhow!("StructureType without ByteSize: {:?}", tag))?;
Ok(StructureType {
kind: if tag.kind == TagKind::ClassType {
StructureKind::Class
} else {
StructureKind::Struct
},
name,
byte_size,
members,
bases,
})
}
fn process_array_tag(tags: &TagMap, tag: &Tag) -> Result<ArrayType> {
ensure!(tag.kind == TagKind::ArrayType, "{:?} is not an ArrayType tag", tag.kind);
let mut subscr_data = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::SubscrData, AttributeValue::Block(data)) => {
subscr_data =
Some(process_array_subscript_data(data).with_context(|| {
format!("Failed to process SubscrData for tag: {:?}", tag)
})?)
}
_ => {
bail!("Unhandled ArrayType attribute {:?}", attr)
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled ArrayType child {:?}", child.kind);
}
let (element_type, dimensions) =
subscr_data.ok_or_else(|| anyhow!("ArrayType without SubscrData: {:?}", tag))?;
Ok(ArrayType { element_type: Box::from(element_type), dimensions })
}
fn process_array_subscript_data(data: &[u8]) -> Result<(Type, Vec<ArrayDimension>)> {
let mut element_type = None;
let mut dimensions = Vec::new();
let mut data = data;
while !data.is_empty() {
let format = SubscriptFormat::try_from(
data.first().cloned().ok_or_else(|| anyhow!("Empty SubscrData"))?,
)
.context("Unknown array subscript format")?;
data = &data[1..];
match format {
SubscriptFormat::FundTypeConstConst => {
let index_type = FundType::try_from(u16::from_be_bytes(data[..2].try_into()?))
.context("Invalid fundamental type ID")?;
let low_bound = u32::from_be_bytes(data[2..6].try_into()?);
ensure!(low_bound == 0, "Invalid array low bound {low_bound}, expected 0");
let high_bound = u32::from_be_bytes(data[6..10].try_into()?);
data = &data[10..];
dimensions.push(ArrayDimension {
index_type: Type { kind: TypeKind::Fundamental(index_type), modifiers: vec![] },
// u32::MAX will wrap to 0, meaning unbounded
size: NonZeroU32::new(high_bound.wrapping_add(1)),
});
}
SubscriptFormat::ElementType => {
let mut cursor = Cursor::new(data);
let type_attr = read_attribute(&mut cursor)?;
element_type = Some(process_type(&type_attr)?);
data = &data[cursor.position() as usize..];
}
_ => bail!("Unhandled subscript format type {:?}", format),
}
}
let element_type = element_type.ok_or_else(|| anyhow!("ArrayType without ElementType"))?;
Ok((element_type, dimensions))
}
fn process_enumeration_tag(tags: &TagMap, tag: &Tag) -> Result<EnumerationType> {
ensure!(tag.kind == TagKind::EnumerationType, "{:?} is not an EnumerationType tag", tag.kind);
let mut name = None;
let mut byte_size = None;
let mut members = Vec::new();
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(AttributeKind::ByteSize, &AttributeValue::Data4(value)) => byte_size = Some(value),
(AttributeKind::ElementList, AttributeValue::Block(data)) => {
let mut cursor = Cursor::new(data);
while cursor.position() < data.len() as u64 {
let value = i32::from_reader(&mut cursor, Endian::Big)?;
let name = read_string(&mut cursor)?;
members.push(EnumerationMember { name, value });
}
}
_ => {
bail!("Unhandled EnumerationType attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled EnumerationType child {:?}", child.kind);
}
let byte_size =
byte_size.ok_or_else(|| anyhow!("EnumerationType without ByteSize: {:?}", tag))?;
Ok(EnumerationType { name, byte_size, members })
}
fn process_union_tag(tags: &TagMap, tag: &Tag) -> Result<UnionType> {
ensure!(tag.kind == TagKind::UnionType, "{:?} is not a UnionType tag", tag.kind);
let mut name = None;
let mut byte_size = None;
let mut members = Vec::new();
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(AttributeKind::ByteSize, &AttributeValue::Data4(value)) => byte_size = Some(value),
_ => {
bail!("Unhandled UnionType attribute {:?}", attr);
}
}
}
for child in tag.children(tags) {
match child.kind {
TagKind::Member => members.push(process_structure_member_tag(tags, child)?),
kind => bail!("Unhandled UnionType child {:?}", kind),
}
}
let byte_size = byte_size.ok_or_else(|| anyhow!("UnionType without ByteSize: {:?}", tag))?;
Ok(UnionType { name, byte_size, members })
}
fn process_subroutine_tag(tags: &TagMap, tag: &Tag) -> Result<SubroutineType> {
ensure!(
matches!(
tag.kind,
TagKind::SubroutineType | TagKind::GlobalSubroutine | TagKind::Subroutine
),
"{:?} is not a Subroutine tag",
tag.kind
);
let mut name = None;
let mut mangled_name = None;
let mut return_type = None;
let mut prototyped = false;
let mut parameters = Vec::new();
let mut var_args = false;
let mut references = Vec::new();
let mut member_of = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(AttributeKind::MwMangled, AttributeValue::String(s)) => mangled_name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => return_type = Some(process_type(attr)?),
(AttributeKind::Prototyped, _) => prototyped = true,
(AttributeKind::LowPc, _) | (AttributeKind::HighPc, _) => {
// TODO?
}
(AttributeKind::MwGlobalRef, &AttributeValue::Reference(key)) => {
references.push(key);
}
(AttributeKind::ReturnAddr, AttributeValue::Block(_block)) => {
// let location = process_variable_location(block)?;
// info!("ReturnAddr: {}", location);
}
(AttributeKind::Member, &AttributeValue::Reference(key)) => {
member_of = Some(key);
}
_ => {
bail!("Unhandled SubroutineType attribute {:?}", attr);
}
}
}
let mut variables = Vec::new();
for child in tag.children(tags) {
ensure!(!var_args, "{:?} after UnspecifiedParameters", child.kind);
match child.kind {
TagKind::FormalParameter => {
parameters.push(process_subroutine_parameter_tag(tags, child)?)
}
TagKind::UnspecifiedParameters => var_args = true,
TagKind::LocalVariable => variables.push(process_local_variable_tag(tags, child)?),
kind => bail!("Unhandled SubroutineType child {:?}", kind),
}
}
let return_type = return_type
.unwrap_or_else(|| Type { kind: TypeKind::Fundamental(FundType::Void), modifiers: vec![] });
Ok(SubroutineType {
name,
mangled_name,
return_type,
parameters,
var_args,
prototyped,
references,
member_of,
variables,
})
}
fn process_subroutine_parameter_tag(tags: &TagMap, tag: &Tag) -> Result<SubroutineParameter> {
ensure!(tag.kind == TagKind::FormalParameter, "{:?} is not a FormalParameter tag", tag.kind);
let mut name = None;
let mut kind = None;
let mut location = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => kind = Some(process_type(attr)?),
(AttributeKind::Location, AttributeValue::Block(block)) => {
location = Some(process_variable_location(block)?)
}
(AttributeKind::MwDwarf2Location, AttributeValue::Block(_block)) => {
// TODO?
// info!("MwDwarf2Location: {:?} in {:?}", block, tag);
}
_ => {
bail!("Unhandled SubroutineParameter attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled SubroutineParameter child {:?}", child.kind);
}
let kind = kind.ok_or_else(|| anyhow!("SubroutineParameter without type: {:?}", tag))?;
Ok(SubroutineParameter { name, kind, location })
}
fn process_local_variable_tag(tags: &TagMap, tag: &Tag) -> Result<SubroutineVariable> {
ensure!(tag.kind == TagKind::LocalVariable, "{:?} is not a LocalVariable tag", tag.kind);
let mut name = None;
let mut kind = None;
let mut location = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => kind = Some(process_type(attr)?),
(AttributeKind::Location, AttributeValue::Block(block)) => {
location = Some(process_variable_location(block)?)
}
(AttributeKind::MwDwarf2Location, AttributeValue::Block(_block)) => {
// TODO?
// info!("MwDwarf2Location: {:?} in {:?}", block, tag);
}
_ => {
bail!("Unhandled LocalVariable attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled LocalVariable child {:?}", child.kind);
}
let kind = kind.ok_or_else(|| anyhow!("LocalVariable without type: {:?}", tag))?;
Ok(SubroutineVariable { name, kind, location })
}
fn process_ptr_to_member_tag(tags: &TagMap, tag: &Tag) -> Result<PtrToMemberType> {
ensure!(tag.kind == TagKind::PtrToMemberType, "{:?} is not a PtrToMemberType tag", tag.kind);
let mut kind = None;
let mut containing_type = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => kind = Some(process_type(attr)?),
(AttributeKind::ContainingType, &AttributeValue::Reference(key)) => {
containing_type = Some(key)
}
_ => {
bail!("Unhandled PtrToMemberType attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled PtrToMemberType child {:?}", child.kind);
}
let kind = kind.ok_or_else(|| anyhow!("PtrToMemberType without type: {:?}", tag))?;
let containing_type = containing_type
.ok_or_else(|| anyhow!("PtrToMemberType without containing type: {:?}", tag))?;
Ok(PtrToMemberType { kind, containing_type })
}
pub fn ud_type(tags: &TagMap, tag: &Tag) -> Result<UserDefinedType> {
match tag.kind {
TagKind::ArrayType => Ok(UserDefinedType::Array(process_array_tag(tags, tag)?)),
TagKind::StructureType | TagKind::ClassType => {
Ok(UserDefinedType::Structure(process_structure_tag(tags, tag)?))
}
TagKind::EnumerationType => {
Ok(UserDefinedType::Enumeration(process_enumeration_tag(tags, tag)?))
}
TagKind::UnionType => Ok(UserDefinedType::Union(process_union_tag(tags, tag)?)),
TagKind::SubroutineType | TagKind::GlobalSubroutine | TagKind::Subroutine => {
Ok(UserDefinedType::Subroutine(process_subroutine_tag(tags, tag)?))
}
TagKind::PtrToMemberType => {
Ok(UserDefinedType::PtrToMember(process_ptr_to_member_tag(tags, tag)?))
}
kind => Err(anyhow!("Unhandled user defined type {kind:?}")),
}
}
pub fn process_modifiers(block: &[u8]) -> Result<Vec<Modifier>> {
let mut out = Vec::with_capacity(block.len());
for &b in block {
out.push(Modifier::try_from(b)?);
}
Ok(out)
}
pub fn process_type(attr: &Attribute) -> Result<Type> {
match (attr.kind, &attr.value) {
(AttributeKind::FundType, &AttributeValue::Data2(type_id)) => {
let fund_type = FundType::try_from(type_id)
.with_context(|| format!("Invalid fundamental type ID '{}'", type_id))?;
Ok(Type { kind: TypeKind::Fundamental(fund_type), modifiers: vec![] })
}
(AttributeKind::ModFundType, AttributeValue::Block(ops)) => {
let type_id = u16::from_be_bytes(ops[ops.len() - 2..].try_into()?);
let fund_type = FundType::try_from(type_id)
.with_context(|| format!("Invalid fundamental type ID '{}'", type_id))?;
let modifiers = process_modifiers(&ops[..ops.len() - 2])?;
Ok(Type { kind: TypeKind::Fundamental(fund_type), modifiers })
}
(AttributeKind::UserDefType, &AttributeValue::Reference(key)) => {
Ok(Type { kind: TypeKind::UserDefined(key), modifiers: vec![] })
}
(AttributeKind::ModUDType, AttributeValue::Block(ops)) => {
let ud_ref = u32::from_be_bytes(ops[ops.len() - 4..].try_into()?);
let modifiers = process_modifiers(&ops[..ops.len() - 4])?;
Ok(Type { kind: TypeKind::UserDefined(ud_ref), modifiers })
}
_ => Err(anyhow!("Invalid type attribute {:?}", attr)),
}
}
pub fn process_root_tag(tags: &TagMap, tag: &Tag) -> Result<TagType> {
match tag.kind {
TagKind::Typedef => Ok(TagType::Typedef(process_typedef_tag(tags, tag)?)),
TagKind::GlobalVariable | TagKind::LocalVariable => {
Ok(TagType::Variable(process_variable_tag(tags, tag)?))
}
TagKind::StructureType
| TagKind::ArrayType
| TagKind::EnumerationType
| TagKind::UnionType
| TagKind::ClassType
| TagKind::SubroutineType
| TagKind::GlobalSubroutine
| TagKind::Subroutine
| TagKind::PtrToMemberType => Ok(TagType::UserDefined(ud_type(tags, tag)?)),
kind => Err(anyhow!("Unhandled root tag type {:?}", kind)),
}
}
/// Logic to skip uninteresting tags
pub fn should_skip_tag(tag_type: &TagType) -> bool {
match tag_type {
TagType::Variable(_) => false,
TagType::Typedef(_) => false,
TagType::UserDefined(t) => !t.is_definition(),
}
}
pub fn tag_type_string(tags: &TagMap, typedefs: &TypedefMap, tag_type: &TagType) -> Result<String> {
match tag_type {
TagType::Typedef(t) => typedef_string(tags, typedefs, t),
TagType::Variable(v) => variable_string(tags, typedefs, v, true),
TagType::UserDefined(ud) => {
let ud_str = ud_type_def(tags, typedefs, ud)?;
match ud {
UserDefinedType::Structure(_)
| UserDefinedType::Enumeration(_)
| UserDefinedType::Union(_) => Ok(format!("{};", ud_str)),
_ => Ok(ud_str),
}
}
}
}
fn typedef_string(tags: &TagMap, typedefs: &TypedefMap, typedef: &TypedefTag) -> Result<String> {
let ts = type_string(tags, typedefs, &typedef.kind, true)?;
Ok(format!("typedef {} {}{};", ts.prefix, typedef.name, ts.suffix))
}
fn variable_string(
tags: &TagMap,
typedefs: &TypedefMap,
variable: &VariableTag,
include_extra: bool,
) -> Result<String> {
let ts = type_string(tags, typedefs, &variable.kind, include_extra)?;
let mut out = if variable.local { "static ".to_string() } else { String::new() };
out.push_str(&ts.prefix);
out.push(' ');
out.push_str(variable.name.as_deref().unwrap_or("[unknown]"));
out.push_str(&ts.suffix);
match &variable.address {
Some(addr) => out.push_str(&format!(" : {:#010X}", addr)),
None => {}
}
out.push(';');
if include_extra {
let size = variable.kind.size(tags)?;
out.push_str(&format!(" // size: {:#X}", size));
}
Ok(out)
}
fn process_typedef_tag(tags: &TagMap, tag: &Tag) -> Result<TypedefTag> {
ensure!(tag.kind == TagKind::Typedef, "{:?} is not a typedef tag", tag.kind);
let mut name = None;
let mut kind = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => kind = Some(process_type(attr)?),
_ => {
bail!("Unhandled Typedef attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled Typedef child {:?}", child.kind);
}
let name = name.ok_or_else(|| anyhow!("Typedef without Name: {:?}", tag))?;
let kind = kind.ok_or_else(|| anyhow!("Typedef without Type: {:?}", tag))?;
Ok(TypedefTag { name, kind })
}
fn process_variable_tag(tags: &TagMap, tag: &Tag) -> Result<VariableTag> {
ensure!(
matches!(tag.kind, TagKind::GlobalVariable | TagKind::LocalVariable),
"{:?} is not a variable tag",
tag.kind
);
let mut name = None;
let mut mangled_name = None;
let mut kind = None;
let mut address = None;
for attr in &tag.attributes {
match (attr.kind, &attr.value) {
(AttributeKind::Sibling, _) => {}
(AttributeKind::Name, AttributeValue::String(s)) => name = Some(s.clone()),
(AttributeKind::MwMangled, AttributeValue::String(s)) => mangled_name = Some(s.clone()),
(
AttributeKind::FundType
| AttributeKind::ModFundType
| AttributeKind::UserDefType
| AttributeKind::ModUDType,
_,
) => kind = Some(process_type(attr)?),
(AttributeKind::Location, AttributeValue::Block(block)) => {
address = Some(process_address(block)?)
}
_ => {
bail!("Unhandled Variable attribute {:?}", attr);
}
}
}
if let Some(child) = tag.children(tags).first() {
bail!("Unhandled Variable child {:?}", child.kind);
}
let kind = kind.ok_or_else(|| anyhow!("Variable without Type: {:?}", tag))?;
let local = tag.kind == TagKind::LocalVariable;
Ok(VariableTag { name, mangled_name, kind, address, local })
}
Reference in New Issue View Git Blame Copy Permalink