1.78.0-beta.1

Author: billy1624

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.78.0 - Pending
+
+### Versions
+
++ `1.78.0-beta.1`: 2024-04-23
+
 ## 1.77.1 - 2024-04-19
 
 ### Bug Fixes

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-cli"
-version = "1.77.1"
+version = "1.78.0-beta.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = [

command/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-rust-debugger"
-version = "1.77.1"
+version = "1.78.0-beta.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 build = "build.rs"

debugger/Cargo.toml

@@ -362,7 +362,9 @@ fn run(mut params: DebuggerParams, mut producer: SeaProducer) -> Result<()> {
         let mut return_immediately = false;
         if matches!(
             bp_event_type,
-            BreakpointType::Breakpoint | BreakpointType::FunctionCall { .. }
+            BreakpointType::Breakpoint
+                | BreakpointType::FunctionCall { .. }
+                | BreakpointType::FutureEndpoint
         ) {
             let mut event = if matches!(bp_event_type, BreakpointType::Breakpoint) {
                 let (active_frame_id, reason) = active_frames
@@ -519,6 +521,25 @@ fn run(mut params: DebuggerParams, mut producer: SeaProducer) -> Result<()> {
                 }
 
                 EventStream::function_call(bp_id, thread_id, active_frames.last().expect("Pushed"))
+            } else if matches!(bp_event_type, BreakpointType::FutureEndpoint) {
+                let sb_function = sb_frame.function();
+                let fn_name = sb_function.name();
+                let (active_frame_id, reason) = active_frames
+                    .last()
+                    .map(|active_frame| {
+                        (
+                            active_frame.frame_id,
+                            if fn_name.ends_with("::{{closure}}") {
+                                Reason::FutureExit
+                            } else {
+                                Reason::FutureEnter
+                            },
+                        )
+                    })
+                    .unwrap_or_default();
+                let mut event = EventStream::breakpoint(bp_id, thread_id, active_frame_id, reason);
+                event.write_string(rwriter, "fn", &fn_name.replace("::{{closure}}", ""));
+                event
             } else {
                 unreachable!();
             };
@@ -1104,6 +1125,14 @@ impl Bytes {
         };
         self.write_value(rwriter, name, bytes.as_bytes());
     }
+
+    fn write_string(&mut self, rwriter: &mut RValueWriter, name: &str, value: &str) {
+        self.identifier(name);
+        self.push_str("name");
+        self.space();
+        self.push_bytes(rwriter.strlit_v(value.as_bytes()));
+        self.space();
+    }
 }
 
 impl Default for Thread {
@@ -1117,7 +1146,7 @@ impl Default for Thread {
 }
 
 #[doc(hidden)]
-pub fn new_breakpoint(id: u32, file_id: u32, func: FunctionDef) -> Breakpoint {
+pub fn new_breakpoint(id: u32, file_id: u32, func: &FunctionDef) -> Breakpoint {
     Breakpoint {
         id,
         file_id,
@@ -1130,6 +1159,18 @@ pub fn new_breakpoint(id: u32, file_id: u32, func: FunctionDef) -> Breakpoint {
     }
 }
 
+#[doc(hidden)]
+pub fn new_async_breakpoint(id: u32, file_id: u32, func: &FunctionDef) -> Breakpoint {
+    Breakpoint {
+        id,
+        file_id,
+        loc: func.end,
+        loc_end: None,
+        breakpoint_type: BreakpointType::FutureEndpoint,
+        capture: VariableCapture::None,
+    }
+}
+
 fn register_breakpoint(breakpoint_addresses: &mut FxHashMap<u64, BpId>, sb_bp: &SBBreakpoint) {
     for sb_bp_loc in sb_bp.locations() {
         breakpoint_addresses.insert(sb_bp_loc.address().file_address() as u64, BpId(sb_bp.id()));

debugger/src/debugger.rs

@@ -34,6 +34,7 @@ lazy_static::lazy_static! {
     pub static ref KEEP_HASH_ORDER: bool = config_bool("KEEP_HASH_ORDER");
     /// If set, don't trace heap allocations.
     pub static ref DONT_TRACE_ALLOCATION: bool = config_bool("DONT_TRACE_ALLOCATION");
+    static ref SAMPLE: Option<String> = config_string("SAMPLE");
 }
 
 #[doc(hidden)]
@@ -43,20 +44,27 @@ pub fn load_config() -> usize {
 }
 
 fn config_usize(key: &str) -> Option<usize> {
-    match CONFIG.get(key).cloned() {
-        Some(ConfigValue::u64(v)) => Some(v as usize),
+    match CONFIG.get(key) {
+        Some(ConfigValue::u64(v)) => Some(*v as usize),
         _ => None,
     }
 }
 
 /// Unset is false
 fn config_bool(key: &str) -> bool {
-    match CONFIG.get(key).cloned() {
-        Some(ConfigValue::bool(v)) => v,
+    match CONFIG.get(key) {
+        Some(ConfigValue::bool(v)) => *v,
         _ => false,
     }
 }
 
+fn config_string(key: &str) -> Option<String> {
+    match CONFIG.get(key).cloned() {
+        Some(ConfigValue::String(v)) => Some(v),
+        _ => None,
+    }
+}
+
 #[derive(Debug, Clone)]
 #[allow(non_camel_case_types)]
 enum ConfigValue {

debugger/src/debugger/config.rs

@@ -607,7 +607,7 @@ pub(super) fn write_return_value(
                                 let rcx_u64 = read_u64(&rcx())?;
                                 let res_is_rcx = (rdx_u64 == 0 && rcx_u64 == 1)
                                     || (rdx_u64 == 0 && rcx_u64 == 0);
-                                if res_is_rcx && (read_u64(&rdx())? & 0xF) != 0 {
+                                if res_is_rcx && (read_u64(&rcx())? & 0xF) != 0 {
                                     let v = {
                                         let v = [reg("rsi"), reg("r8")];
                                         &values_to_bytes::<16, _>(v.into_iter(), 2)?
@@ -824,7 +824,6 @@ pub(super) fn write_return_value(
                                 let rcx_u64 = read_u64(&rcx())?;
                                 let res_is_rcx = (rdx_u64 == 0 && rcx_u64 == 1)
                                     || (rdx_u64 == 0 && rcx_u64 == 0);
-                                let has_unit = left_size == 0 || right_size == 0;
                                 let res = if res_is_rcx { rcx_u64 } else { rdx_u64 };
                                 let v = if res_is_rcx {
                                     [reg("rsi"), reg("r8")]
@@ -898,6 +897,38 @@ pub(super) fn write_return_value(
                             val,
                         );
                         return Ok(());
+                    } else if cfg!(target_arch = "aarch64")
+                        && (left_size <= 8 && right_size <= 8)
+                        && (left.is_integer() && right.is_integer())
+                        && left.is_signed_integer() != right.is_signed_integer()
+                    {
+                        // since llvm 18; Result<u32, i32> Result<u64, i64>
+                        log::trace!("{} x0, x1", return_type.name());
+                        let res = read_u64(&reg("x0"))?;
+                        let left_or_right = if res == 0 { &left } else { &right };
+                        let val = get_prim_from_rdx(rwriter, left_or_right)?;
+                        event.write_result(rwriter, RETVAL, return_type.name(), res == 0, val);
+                        return Ok(());
+                    } else if cfg!(target_arch = "aarch64")
+                        && matches!(
+                            (&left, &right),
+                            (ValueType::u128, ValueType::i128) | (ValueType::i128, ValueType::u128)
+                        )
+                    {
+                        // since llvm 18; Result<u128, i128>
+                        log::trace!("{} x0, x2, x3", return_type.name());
+                        let res = read_u64(&reg("x0"))?;
+                        let left_or_right = if res == 0 { &left } else { &right };
+                        let val = rwriter.prim_v(
+                            match left_or_right {
+                                ValueType::u128 => "u128",
+                                ValueType::i128 => "i128",
+                                _ => unreachable!(),
+                            },
+                            &values_to_bytes::<16, _>([reg("x2"), reg("x3")].into_iter(), 2)?,
+                        );
+                        event.write_result(rwriter, RETVAL, return_type.name(), res == 0, val);
+                        return Ok(());
                     } else if (left_size <= 8 && right_size <= 8) // must fit in register
                         && (left == right // same type, easy case
                         || (left.is_thin_ptr() && right.is_thin_ptr()) // both are pointers
@@ -919,18 +950,22 @@ pub(super) fn write_return_value(
                             // this is the complex case, where the discriminant and value are both squashed into the same register
                             let data = read_u64(&rax())?;
                             let res = data & 0x1; // select the least significant bit
-                            let b = data.to_ne_bytes();
-                            // print!("bytes = "); for b in b.iter() { print!("{b:02X}"); } log::trace!();
                             let left_or_right = if res == 0 { &left } else { &right };
                             let left_or_right_size = if res == 0 { left_size } else { right_size };
                             let ty = left_or_right.primitive_name();
 
-                            let val = match left_or_right_size {
-                                // the value is in the 2nd lower word
-                                1 => rwriter.prim_v(ty, &b[1..2]),
-                                2 => rwriter.prim_v(ty, &b[2..4]),
-                                4 => rwriter.prim_v(ty, &b[4..8]),
-                                _ => unreachable!(),
+                            let val = if data == 0 || data == 1 {
+                                let b = read_u64(&rdx())?.to_ne_bytes();
+                                rwriter.prim_v(ty, &b[..left_or_right_size])
+                            } else {
+                                let b = data.to_ne_bytes();
+                                match left_or_right_size {
+                                    // the value is in the 2nd lower word
+                                    1 => rwriter.prim_v(ty, &b[1..2]),
+                                    2 => rwriter.prim_v(ty, &b[2..4]),
+                                    4 => rwriter.prim_v(ty, &b[4..8]),
+                                    _ => unreachable!(),
+                                }
                             };
                             event.write_result(rwriter, RETVAL, return_type.name(), res == 0, val);
                         } else if (left == ValueType::Unit || right == ValueType::Unit)
@@ -993,9 +1028,29 @@ pub(super) fn write_return_value(
             // Result<i32, i64>, Result<u64, i64>
             #[cfg(target_arch = "x86_64")]
             {
-                log::trace!("{} pass by stack (rax)", return_type.name());
-                let sb_value = sb_value_from_rax(return_type)?;
-                event.write_sb_value(rwriter, &sb_value);
+                let data = read_u64(&rax())?;
+                if data == 0 || data == 1 {
+                    let res = data & 0x1; // select the least significant bit
+                    let left_or_right = if res == 0 { &left } else { &right };
+                    let left_or_right_size = match (left.size_of(), right.size_of()) {
+                        (SizeOfType::Sized(left_size), SizeOfType::Sized(right_size)) => {
+                            if res == 0 {
+                                left_size
+                            } else {
+                                right_size
+                            }
+                        }
+                        _ => unreachable!(),
+                    };
+                    let ty = left_or_right.primitive_name();
+                    let b = read_u64(&rdx())?.to_ne_bytes();
+                    let val = rwriter.prim_v(ty, &b[..left_or_right_size]);
+                    event.write_result(rwriter, RETVAL, return_type.name(), res == 0, val);
+                } else {
+                    log::trace!("{} pass by stack (rax)", return_type.name());
+                    let sb_value = sb_value_from_rax(return_type)?;
+                    event.write_sb_value(rwriter, &sb_value);
+                }
             }
             #[cfg(target_arch = "aarch64")]
             {

debugger/src/debugger/return_value.rs

@@ -23,12 +23,22 @@ impl EventStream {
         assert!(source.len() > 0);
         let event = match source.get(0) {
             b'B' => {
-                let reason = match source.get(1) {
+                let mut i = 1;
+                let reason = match source.get(i) {
                     b'B' => crate::Reason::Breakpoint,
                     b'P' => crate::Reason::Panic,
+                    b'F' => {
+                        i += 1;
+                        match source.get(i) {
+                            b'{' => crate::Reason::FutureEnter,
+                            b'}' => crate::Reason::FutureExit,
+                            other => panic!("Unknown reason, got {other:?}"),
+                        }
+                    }
                     other => panic!("Unknown reason, got {other:?}"),
                 };
-                reader.set_source(source, 2);
+                i += 1;
+                reader.set_source(source, i);
                 let breakpoint_id = reader.read_int().unwrap() as u32;
                 let thread_id = reader.read_int().unwrap();
                 let frame_id = reader.read_int().unwrap();
@@ -94,7 +104,14 @@ impl EventStream {
         bytes.push_byte(match reason {
             crate::Reason::Breakpoint => b'B',
             crate::Reason::Panic => b'P',
+            crate::Reason::FutureEnter => b'F',
+            crate::Reason::FutureExit => b'F',
         });
+        match reason {
+            crate::Reason::FutureEnter => bytes.push_byte(b'{'),
+            crate::Reason::FutureExit => bytes.push_byte(b'}'),
+            _ => (),
+        }
         bytes.integer(bp_id.0);
         bytes.integer(thread_id);
         bytes.integer(frame_id);

debugger/src/event.rs

@@ -144,7 +144,7 @@ async fn main() -> Result<()> {
             modified,
         });
         for func in functions {
-            breakpoints.push(new_breakpoint(breakpoints.len() as u32, id, func));
+            breakpoints.push(new_breakpoint(breakpoints.len() as u32, id, &func));
         }
         id += 1;
     };