1.77.0-beta.1

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.77.0 - Pending
+
++ `1.77.0-beta.1`: 2024-03-25
+
 ## 1.76.1 - Pending
 
 - debugger: trace allocations (Box, Arc, Rc)

command/Cargo.toml

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

debugger/Cargo.toml

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

debugger/src/debugger/return_value.rs

@@ -599,23 +599,47 @@ pub(super) fn write_return_value(
                             None
                         };
                         event.write_option(rwriter, RETVAL, return_type.name(), value);
+                    } else if matches!(left, ValueType::i128 | ValueType::u128) {
+                        let val = {
+                            #[cfg(target_arch = "x86_64")]
+                            {
+                                let rdx_u64 = read_u64(&rdx())?;
+                                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 {
+                                    let v = {
+                                        let v = [reg("rsi"), reg("r8")];
+                                        &values_to_bytes::<16, _>(v.into_iter(), 2)?
+                                    };
+                                    Some(rwriter.prim_v(left.primitive_name(), v))
+                                } else if !res_is_rcx && (read_u64(&rdx())? & 0xF) != 0 {
+                                    let v = {
+                                        let v = [reg("rdi"), reg("r8")];
+                                        &values_to_bytes::<16, _>(v.into_iter(), 2)?
+                                    };
+                                    Some(rwriter.prim_v(left.primitive_name(), v))
+                                } else {
+                                    None
+                                }
+                            }
+                            #[cfg(target_arch = "aarch64")]
+                            {
+                                if opt != 0 {
+                                    let v = {
+                                        let v = [reg("x2"), reg("x3")];
+                                        &values_to_bytes::<16, _>(v.into_iter(), 2)?
+                                    };
+                                    Some(rwriter.prim_v(left.primitive_name(), v))
+                                } else {
+                                    None
+                                }
+                            }
+                        };
+                        event.write_option(rwriter, RETVAL, return_type.name(), val);
                     } else if opt != 0 {
                         let val = if left_size == 0 {
                             rwriter.unit_v()
-                        } else if matches!(left, ValueType::i128 | ValueType::u128) {
-                            let v = {
-                                #[cfg(target_arch = "x86_64")]
-                                {
-                                    // we are using rcx too
-                                    &values_to_bytes::<16, _>([rdx(), rcx()].into_iter(), 2)?
-                                }
-                                #[cfg(target_arch = "aarch64")]
-                                {
-                                    let v = [reg("x2"), reg("x3")];
-                                    &values_to_bytes::<16, _>(v.into_iter(), 2)?
-                                }
-                            };
-                            rwriter.prim_v(left.primitive_name(), v)
                         } else if matches!(left, ValueType::Slice(_)) {
                             get_slice_from_rax_rdx(rwriter, &left, &left_type)?
                         } else if left.is_thin_ptr() {
@@ -793,17 +817,27 @@ pub(super) fn write_return_value(
                     {
                         // Result<i128, i128>, Result<u128, u128>, Result<i128, ()>, Result<(), u128>
                         log::trace!("{} rcx, rdx", return_type.name());
-                        let res = read_u64(&rax())?;
-                        let v = {
+                        let (res, v) = {
                             #[cfg(target_arch = "x86_64")]
                             {
-                                // we are using rcx too
-                                &values_to_bytes::<16, _>([rdx(), rcx()].into_iter(), 2)?
+                                let rdx_u64 = read_u64(&rdx())?;
+                                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")]
+                                } else {
+                                    [reg("rdi"), reg("r8")]
+                                };
+                                (res, &values_to_bytes::<16, _>(v.into_iter(), 2)?)
                             }
                             #[cfg(target_arch = "aarch64")]
                             {
+                                let res = read_u64(&rax())?;
                                 let v = [reg("x2"), reg("x3")];
-                                &values_to_bytes::<16, _>(v.into_iter(), 2)?
+                                (res, &values_to_bytes::<16, _>(v.into_iter(), 2)?)
                             }
                         };
                         let val = if left_size == 0 && res == 0 {

indexer/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-stream-indexer"
-version = "1.76.0"
+version = "1.77.0-beta.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = [
@@ -28,7 +28,7 @@ tokio = { version = "1", optional = true }
 pretty_assertions = { version = "1", optional = true }
 async-trait = { version = "0.1", optional = true }
 # workspace
-firedbg-rust-debugger = { path = "../debugger", version = "1.76.0", default-features = false }
+firedbg-rust-debugger = { path = "../debugger", version = "1.77.0-beta.1", default-features = false }
 
 [features]
 # The base feature only exports the sea-orm entities

indexer/src/validator.rs

@@ -9,8 +9,8 @@ use crate::{
     Processor,
 };
 use firedbg_rust_debugger::{
-    Breakpoint, Event, EventStream, InfoMessage, SourceFile, BREAKPOINT_STREAM, EVENT_STREAM,
-    FILE_STREAM, INFO_STREAM,
+    Breakpoint, Event, EventStream, InfoMessage, SourceFile, ALLOCATION_STREAM, BREAKPOINT_STREAM,
+    EVENT_STREAM, FILE_STREAM, INFO_STREAM,
 };
 
 #[derive(Debug, Default, Serialize, Deserialize)]
@@ -57,6 +57,7 @@ impl Processor for Validator {
                     event.redacted();
                     self.data.events.push(event);
                 }
+                ALLOCATION_STREAM => {}
                 _ => anyhow::bail!("Unexpected stream key {}", message.stream_key()),
             }
         }

parser/src/parsing/workspace.rs

@@ -12,7 +12,7 @@ pub(crate) fn parse_workspace(raw_workspace: raw::Workspace) -> Workspace {
 fn parse_packages(raw_packages: Vec<raw::Package>, workspace_root_dir: &str) -> Vec<Package> {
     let get_package_root_dir = |id: &str| -> String {
         let (_, after) = id.split_once("path+file://").expect("Have path");
-        let root_dir = after.chars().take_while(|c| ')'.ne(c)).collect();
+        let root_dir = after.chars().take_while(|c| '#'.ne(c)).collect();
         root_dir
     };
     raw_packages
@@ -22,7 +22,7 @@ fn parse_packages(raw_packages: Vec<raw::Package>, workspace_root_dir: &str) ->
             let version = &raw_package.version;
             let package_id = &raw_package.id;
             // Is local package
-            if package_id.starts_with(&format!("{name} {version} (path+file://")) {
+            if package_id.starts_with("path+file://") {
                 let root_dir = get_package_root_dir(&package_id);
                 // Is within the root workspace directory
                 if root_dir.starts_with(workspace_root_dir) {