Improve VarNode and Pcode formatting and add display tests

Author: toolCHAINZ

jingle/src/display.rs

@@ -1,6 +1,7 @@
 use crate::varnode::{ResolvedIndirectVarNode, ResolvedVarnode};
 use jingle_sleigh::{
-    GeneralizedVarNode, IndirectVarNode, Instruction, PcodeOperation, SleighArchInfo, VarNode,
+    GeneralizedVarNode, IndirectVarNode, Instruction, PcodeOperation, SleighArchInfo, SpaceType,
+    VarNode,
 };
 use std::fmt::{Display, Formatter};
 use z3::ast::Ast;
@@ -51,13 +52,17 @@ impl JingleDisplay<ResolvedIndirectVarNode> {
 impl JingleDisplayable for VarNode {
     fn fmt_jingle(&self, f: &mut Formatter<'_>, ctx: &SleighArchInfo) -> std::fmt::Result {
         if self.space_index == VarNode::CONST_SPACE_INDEX {
-            write!(f, "{:x}:{:x}", self.offset, self.size)
+            write!(f, "{:#x}:{}", self.offset, self.size)
         } else if let Some(name) = ctx.register_name(self) {
             write!(f, "{name}")
+        } else if let Some(SpaceType::IPTR_INTERNAL) =
+            ctx.get_space(self.space_index).map(|s| s._type)
+        {
+            write!(f, "$U{:x}:{}", self.offset, self.size)
         } else {
             write!(
                 f,
-                "{}[{:x}]:{:x}",
+                "[{}]{:#x}:{}",
                 ctx.get_space(self.space_index).ok_or(std::fmt::Error)?.name,
                 self.offset,
                 self.size
@@ -70,12 +75,11 @@ impl JingleDisplayable for IndirectVarNode {
     fn fmt_jingle(&self, f: &mut Formatter<'_>, ctx: &SleighArchInfo) -> std::fmt::Result {
         write!(
             f,
-            "*({}[{}]:{})",
+            "{}({})",
             ctx.get_space(self.pointer_space_index)
                 .ok_or(std::fmt::Error)?
                 .name,
-            self.pointer_location,
-            self.access_size_bytes
+            self.pointer_location.display(ctx)
         )
     }
 }
@@ -93,12 +97,11 @@ impl JingleDisplayable for ResolvedIndirectVarNode {
     fn fmt_jingle(&self, f: &mut Formatter<'_>, ctx: &SleighArchInfo) -> std::fmt::Result {
         write!(
             f,
-            "{}[{}]:{}",
+            "{}({})",
             ctx.get_space(self.pointer_space_idx)
                 .ok_or(std::fmt::Error)?
                 .name,
             self.pointer.simplify(),
-            self.access_size_bytes
         )
     }
 }
@@ -136,3 +139,80 @@ impl JingleDisplayable for Instruction {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use jingle_sleigh::context::SleighContextBuilder;
+    use jingle_sleigh::{PcodeOperation, VarNode};
+
+    fn make_sleigh() -> jingle_sleigh::context::SleighContext {
+        // Mirrors other tests in the repo which expect a local Ghidra checkout at this path.
+        let ctx_builder =
+            SleighContextBuilder::load_ghidra_installation("/Applications/ghidra").unwrap();
+        ctx_builder.build("x86:LE:64:default").unwrap()
+    }
+
+    #[test]
+    fn test_varnode_display_cases() {
+        let sleigh = make_sleigh();
+        let info = sleigh.arch_info().clone();
+
+        // const varnode should display as "<hex_offset>:<size>"
+        let const_vn = VarNode {
+            space_index: VarNode::CONST_SPACE_INDEX,
+            offset: 0x42,
+            size: 1,
+        };
+        assert_eq!(format!("{}", const_vn.display(&info)), "0x42:1");
+
+        // registers: if registers exist, pretty display should equal the register name
+        let regs: Vec<_> = sleigh.arch_info().registers().collect();
+        if !regs.is_empty() {
+            let (vn, name) = regs[0].clone();
+            assert_eq!(format!("{}", vn.display(&info)), name);
+        }
+
+        // other space: we expect a bracketed form like "[<space>]offset:size" or internal $U...
+        let other = VarNode {
+            space_index: 1,
+            offset: 0x10,
+            size: 4,
+        };
+        let s = format!("{}", other.display(&info));
+        // be permissive: ensure it contains the size and either bracket or unique prefix
+        assert!(s.contains(":4"));
+    }
+
+    #[test]
+    fn test_pcode_display_and_round_trip_copy() {
+        let sleigh = make_sleigh();
+        let info = sleigh.arch_info().clone();
+
+        let output = VarNode {
+            space_index: 4,
+            offset: 0x20,
+            size: 4,
+        };
+        let input = VarNode {
+            space_index: VarNode::CONST_SPACE_INDEX,
+            offset: 0x1,
+            size: 4,
+        };
+
+        let op = PcodeOperation::Copy {
+            input: input.clone(),
+            output: output.clone(),
+        };
+
+        // display formatting contains the opcode name and operands
+        let s = format!("{}", op.display(&info));
+        assert_eq!(s, "ESP = COPY 0x1:4");
+        // Try to round-trip: render to textual pcode and parse with SleighContext.parse_pcode_listing
+        // Use the same textual format that `display` produces for varnodes.
+
+        let parsed = sleigh.parse_pcode_listing(s).unwrap();
+        assert_eq!(parsed.len(), 1);
+        assert_eq!(parsed[0], op);
+    }
+}

jingle_sleigh/src/context/mod.rs

@@ -61,7 +61,7 @@ impl Default for ModelingBehavior {
 
 /// A naive representation of the effects of a function
 #[derive(Debug, Clone, Default, Hash, PartialEq, Eq, Serialize, Deserialize)]
-#[pyclass]
+#[cfg_attr(feature = "pyo3", pyclass)]
 pub struct CallInfo {
     pub args: Vec<VarNode>,
     pub outputs: Option<Vec<VarNode>>,

jingle_sleigh/src/pcode/parse/helpers.rs

@@ -111,6 +111,7 @@ pub fn parse_varnode_location(pair: Pair<Rule>) -> Result<(String, u64), JingleS
                 let space = pairs[0].as_str().to_string();
                 let offset = pairs[1].as_str();
                 let radix = if offset.starts_with("0x") { 16 } else { 10 };
+                let offset = offset.strip_prefix("0x").unwrap_or(offset);
                 let offset = u64::from_str_radix(offset, radix).unwrap();
                 return Ok((space, offset));
             }