Add symbol kind and structured flags to diff proto output

objdiff-core/protos/diff.proto

@@ -39,7 +39,8 @@ message DiffSymbol {
   optional string demangled_name = 2;
   uint64 address = 3;
   uint64 size = 4;
-  uint32 flags = 5;
+  DiffSymbolFlags flags = 5;
+  DiffSymbolKind kind = 10;
   // The symbol index in the _other_ object that this symbol was diffed against
   optional uint32 target_symbol = 6;
   optional float match_percent = 7;
@@ -49,14 +50,22 @@ message DiffSymbol {
   repeated DiffDataSegment data_diff = 9;
 }
 
-// Symbol visibility flags (bitmask)
-enum DiffSymbolFlag {
-  SYMBOL_NONE = 0;
-  SYMBOL_GLOBAL = 1;
-  SYMBOL_LOCAL = 2;
-  SYMBOL_WEAK = 4;
-  SYMBOL_COMMON = 8;
-  SYMBOL_HIDDEN = 16;
+enum DiffSymbolKind {
+  SYMBOL_UNKNOWN = 0;
+  SYMBOL_FUNCTION = 1;
+  SYMBOL_OBJECT = 2;
+  SYMBOL_SECTION = 3;
+}
+
+// Symbol flags
+message DiffSymbolFlags {
+  bool global = 1;
+  bool local = 2;
+  bool weak = 3;
+  bool common = 4;
+  bool hidden = 5;
+  bool ignored = 6;
+  bool size_inferred = 7;
 }
 
 // A single instruction diff row

objdiff-core/src/bindings/diff.rs

@@ -43,9 +43,6 @@ impl DiffObject {
         let mut symbols = Vec::with_capacity(obj.symbols.len());
         for (symbol_idx, symbol) in obj.symbols.iter().enumerate() {
             let symbol_diff = &diff.symbols[symbol_idx];
-            if symbol.size == 0 || symbol.flags.contains(SymbolFlag::Ignored) {
-                continue;
-            }
             symbols.push(DiffSymbol::new(obj, symbol_idx, symbol, symbol_diff, diff_config)?);
         }
 
@@ -112,6 +109,7 @@ impl DiffSymbol {
             address: symbol.address,
             size: symbol.size,
             flags: symbol_flags(&symbol.flags),
+            kind: DiffSymbolKind::from(symbol.kind) as i32,
             // Diff information
             target_symbol: symbol_diff.target_symbol.map(|i| i as u32),
             match_percent: symbol_diff.match_percent,
@@ -121,24 +119,27 @@ impl DiffSymbol {
     }
 }
 
-fn symbol_flags(flags: &obj::SymbolFlagSet) -> u32 {
-    let mut result = 0u32;
-    if flags.contains(SymbolFlag::Global) {
-        result |= DiffSymbolFlag::SymbolGlobal as u32;
-    }
-    if flags.contains(SymbolFlag::Local) {
-        result |= DiffSymbolFlag::SymbolLocal as u32;
-    }
-    if flags.contains(SymbolFlag::Weak) {
-        result |= DiffSymbolFlag::SymbolWeak as u32;
-    }
-    if flags.contains(SymbolFlag::Common) {
-        result |= DiffSymbolFlag::SymbolCommon as u32;
-    }
-    if flags.contains(SymbolFlag::Hidden) {
-        result |= DiffSymbolFlag::SymbolHidden as u32;
+impl From<obj::SymbolKind> for DiffSymbolKind {
+    fn from(value: obj::SymbolKind) -> Self {
+        match value {
+            obj::SymbolKind::Unknown => DiffSymbolKind::SymbolUnknown,
+            obj::SymbolKind::Function => DiffSymbolKind::SymbolFunction,
+            obj::SymbolKind::Object => DiffSymbolKind::SymbolObject,
+            obj::SymbolKind::Section => DiffSymbolKind::SymbolSection,
+        }
     }
-    result
+}
+
+fn symbol_flags(flags: &obj::SymbolFlagSet) -> Option<DiffSymbolFlags> {
+    Some(DiffSymbolFlags {
+        global: flags.contains(SymbolFlag::Global),
+        local: flags.contains(SymbolFlag::Local),
+        weak: flags.contains(SymbolFlag::Weak),
+        common: flags.contains(SymbolFlag::Common),
+        hidden: flags.contains(SymbolFlag::Hidden),
+        ignored: flags.contains(SymbolFlag::Ignored),
+        size_inferred: flags.contains(SymbolFlag::SizeInferred),
+    })
 }
 
 impl DiffInstructionRow {