Big dwarf dump improvements (#129)

* Support type definitions inside functions in dwarf dump
Detect subroutine parent class and constness
Support nested typedefs

* Omit unnecessary/duplicate dwarf info

* Move total size to before struct so that clangd picks it up

* Subroutine typedefs and subroutine block inner types

* Handle override, const, volatile, virtual, static function logic

* Omit return type of ctors and dtors

* Add back the nested template thing because it's actually useful

* Return type omitting bug fix

* Add static struct members

* Fix formatting

* Handle typedef specification attribute

* Avoid adding duplicate inline params

* Handle non-overriden GCC constructors and destructors

* clippy

* Cargo fmt

* Apply clippy's suggestion

* Extract producer and correctly handle MWCC static members

* Enable static member function detection only for GCC

* Fix bug where function parameter wasn't applied if both names were None

* Fix gcc boolean logic and omit __in_chrg

* Add parent fallback for PS2 MW

* Demangle mangled function names

* Have inlines and blocks in the same vec to keep their correct order

* Change comment

* List member functions inside struct

* Remove Inline comment and add a new line before blocks

* Fix fmt and check

* Support appending static member functions to struct on GCC

* Reverse enum members in GCC

Author: dbalatoni13

Cargo.lock

@@ -44,6 +44,7 @@ filetime = "0.2"
 fixedbitset = "0.5"
 flagset = { version = "0.4", features = ["serde"] }
 glob = "0.3"
+gnuv2_demangle = "0.4"
 hex = "0.4"
 indent = "0.1"
 indexmap = "2.6"

Cargo.toml

@@ -1,5 +1,6 @@
 use std::{
-    collections::{btree_map, BTreeMap},
+    cell::RefCell,
+    collections::btree_map,
     io::{stdout, Cursor, Read, Write},
     ops::Bound::{Excluded, Unbounded},
     str::from_utf8,
@@ -19,8 +20,9 @@ use typed_path::Utf8NativePathBuf;
 use crate::{
     util::{
         dwarf::{
-            process_compile_unit, process_cu_tag, process_overlay_branch, read_debug_section,
-            should_skip_tag, tag_type_string, AttributeKind, TagKind,
+            parse_producer, preprocess_cu_tag, process_compile_unit, process_cu_tag,
+            process_overlay_branch, read_debug_section, should_skip_tag, tag_type_string,
+            AttributeKind, MemberFunctionMap, TagKind, TypedefMap,
         },
         file::buf_writer,
         path::native_path,
@@ -166,7 +168,8 @@ where
     }
 
     let mut reader = Cursor::new(&*data);
-    let info = read_debug_section(&mut reader, obj_file.endianness().into(), args.include_erased)?;
+    let mut info =
+        read_debug_section(&mut reader, obj_file.endianness().into(), args.include_erased)?;
 
     for (&addr, tag) in &info.tags {
         log::debug!("{}: {:?}", addr, tag);
@@ -210,6 +213,7 @@ where
                     writeln!(w, "\n/*\n    Compile unit: {}", unit.name)?;
                     if let Some(producer) = unit.producer {
                         writeln!(w, "    Producer: {producer}")?;
+                        info.producer = parse_producer(&producer);
                     }
                     if let Some(comp_dir) = unit.comp_dir {
                         writeln!(w, "    Compile directory: {comp_dir}")?;
@@ -245,8 +249,29 @@ where
                     }
                     children.sort_by_key(|x| x.key);
 
-                    let mut typedefs = BTreeMap::<u32, Vec<u32>>::new();
-                    for child in children {
+                    let mut typedefs = TypedefMap::new();
+                    info.member_functions = RefCell::new(MemberFunctionMap::new());
+                    // pre-parse step
+                    for &child in &children {
+                        preprocess_cu_tag(&info, child);
+
+                        if let TagKind::Typedef = child.kind {
+                            // TODO fundamental typedefs?
+                            if let Some(ud_type_ref) =
+                                child.reference_attribute(AttributeKind::UserDefType)
+                            {
+                                match typedefs.entry(ud_type_ref) {
+                                    btree_map::Entry::Vacant(e) => {
+                                        e.insert(vec![child.key]);
+                                    }
+                                    btree_map::Entry::Occupied(e) => {
+                                        e.into_mut().push(child.key);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    for &child in &children {
                         let tag_type = match process_cu_tag(&info, child) {
                             Ok(tag_type) => tag_type,
                             Err(e) => {
@@ -284,22 +309,6 @@ where
                                 continue;
                             }
                         }
-
-                        if let TagKind::Typedef = child.kind {
-                            // TODO fundamental typedefs?
-                            if let Some(ud_type_ref) =
-                                child.reference_attribute(AttributeKind::UserDefType)
-                            {
-                                match typedefs.entry(ud_type_ref) {
-                                    btree_map::Entry::Vacant(e) => {
-                                        e.insert(vec![child.key]);
-                                    }
-                                    btree_map::Entry::Occupied(e) => {
-                                        e.into_mut().push(child.key);
-                                    }
-                                }
-                            }
-                        }
                     }
                 }
                 kind => bail!("Unhandled root tag type {:?}", kind),