Linux and mac compatibility

decoder/Cargo.toml

@@ -37,6 +37,7 @@ gimli = { version = "0.29", default-features = false, features = [
 ] }
 object = { version = "0.36", default-features = false, features = [
     "read_core",
+    "macho",
     "elf",
     "std",
 ] }

decoder/src/elf2table/mod.rs

@@ -14,23 +14,28 @@ use std::{
 };
 
 use anyhow::{anyhow, bail, ensure};
-use object::{Object, ObjectSection, ObjectSymbol};
+use object::{Object, ObjectSection, ObjectSegment, ObjectSymbol};
 
 use crate::{BitflagsKey, StringEntry, Table, TableEntry, Tag, DEFMT_VERSIONS};
 
 pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyhow::Error> {
     let elf = object::File::parse(elf)?;
+    let is_mac = elf.format() == object::BinaryFormat::MachO;
     // first pass to extract the `_defmt_version`
     let mut version = None;
     let mut encoding = None;
 
     // Note that we check for a quoted and unquoted version symbol, since LLD has a bug that
     // makes it keep the quotes from the linker script.
     let try_get_version = |name: &str| {
-        if name.starts_with("\"_defmt_version_ = ") || name.starts_with("_defmt_version_ = ") {
+        if name.starts_with("\"_defmt_version_ = ")
+            || name.starts_with("_defmt_version_ = ")
+            || name.starts_with("__defmt_version_ = ")
+        {
             Some(
                 name.trim_start_matches("\"_defmt_version_ = ")
                     .trim_start_matches("_defmt_version_ = ")
+                    .trim_start_matches("__defmt_version_ = ")
                     .trim_end_matches('"')
                     .to_string(),
             )
@@ -43,6 +48,7 @@ pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyh
     // using `#[export_name = "_defmt_encoding_ = x"]`, never in linker scripts.
     let try_get_encoding = |name: &str| {
         name.strip_prefix("_defmt_encoding_ = ")
+            .or_else(|| name.strip_prefix("__defmt_encoding_ = "))
             .map(ToString::to_string)
     };
 
@@ -77,12 +83,33 @@ pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyh
         }
     }
 
+    let mut defmt_sections = HashMap::new();
+    if is_mac {
+        let defmt_segment = elf.segments().find(|segment| {
+            object::ObjectSegment::name(segment).is_ok_and(|name| name == Some(".defmt"))
+        });
+        if let Some(defmt_segment) = defmt_segment {
+            for section in elf.sections() {
+                // check if the section is in the segment by comparing the section's address
+                // with the segment's address and size
+                if section.address() >= defmt_segment.address()
+                    && section.address() < defmt_segment.address() + defmt_segment.size()
+                {
+                    defmt_sections.insert(section.index(), section);
+                }
+            }
+        }
+    } else {
+        let defmt_section = elf.section_by_name(".defmt");
+        if let Some(defmt_section) = defmt_section {
+            defmt_sections.insert(defmt_section.index(), defmt_section);
+        }
+    }
+
     // NOTE: We need to make sure to return `Ok(None)`, not `Err`, when defmt is not in use.
     // Otherwise probe-run won't work with apps that don't use defmt.
 
-    let defmt_section = elf.section_by_name(".defmt");
-
-    let (defmt_section, version) = match (defmt_section, version) {
+    let (_defmt_section, version) = match (defmt_sections.values().next(), version) {
         (None, None) => return Ok(None), // defmt is not used
         (Some(defmt_section), Some(version)) => (defmt_section, version),
         (None, Some(_)) => {
@@ -124,15 +151,23 @@ pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyh
             continue;
         }
 
-        if name.starts_with("_defmt") || name.starts_with("__DEFMT_MARKER") {
+        if name.starts_with("_defmt")
+            || name.starts_with("__DEFMT_MARKER")
+            || name.starts_with("__defmt")
+        {
             // `_defmt_version_` is not a JSON encoded `defmt` symbol / log-message; skip it
             // LLD and GNU LD behave differently here. LLD doesn't include `_defmt_version_`
             // (defined in a linker script) in the `.defmt` section but GNU LD does.
             continue;
         }
 
-        if entry.section_index() == Some(defmt_section.index()) {
-            let sym = symbol::Symbol::demangle(name)?;
+        // find the relevant section using the section index
+        if let Some(section_index) = entry.section_index() {
+            if !defmt_sections.contains_key(&section_index) {
+                continue;
+            }
+
+            let sym = symbol::Symbol::demangle(name, is_mac)?;
             match sym.tag() {
                 symbol::SymbolTag::Defmt(Tag::Timestamp) => {
                     if timestamp.is_some() {
@@ -145,18 +180,9 @@ pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyh
                     ));
                 }
                 symbol::SymbolTag::Defmt(Tag::BitflagsValue) => {
-                    // Bitflags values always occupy 128 bits / 16 bytes.
-                    const BITFLAGS_VALUE_SIZE: u64 = 16;
-
-                    if entry.size() != BITFLAGS_VALUE_SIZE {
-                        bail!(
-                            "bitflags value does not occupy 16 bytes (symbol `{}`)",
-                            name
-                        );
-                    }
-
-                    let defmt_data = defmt_section.data()?;
-                    let addr = entry.address() as usize;
+                    let section = defmt_sections.get(&section_index).unwrap();
+                    let defmt_data = section.data()?;
+                    let addr = (entry.address() - section.address()) as usize;
                     let value = match defmt_data.get(addr..addr + 16) {
                         Some(bytes) => u128::from_le_bytes(bytes.try_into().unwrap()),
                         None => bail!(
@@ -189,7 +215,7 @@ pub fn parse_impl(elf: &[u8], check_version: bool) -> Result<Option<Table>, anyh
                 }
                 symbol::SymbolTag::Defmt(tag) => {
                     map.insert(
-                        entry.address() as usize,
+                        (entry.address() as u16) as usize,
                         TableEntry::new(
                             StringEntry::new(tag, sym.data().to_string()),
                             name.to_string(),

decoder/src/elf2table/symbol.rs

@@ -37,7 +37,14 @@ pub(super) enum SymbolTag {
 }
 
 impl Symbol {
-    pub fn demangle(raw: &str) -> anyhow::Result<Self> {
+    pub fn demangle(raw: &str, is_mac: bool) -> anyhow::Result<Self> {
+        let raw = if is_mac {
+            // remove the prefix from the raw string
+            raw.strip_prefix("_")
+                .ok_or_else(|| anyhow::anyhow!("macos symbol `{}` should start with `_`", raw))?
+        } else {
+            raw
+        };
         serde_json::from_str(raw)
             .map_err(|j| anyhow::anyhow!("failed to demangle defmt symbol `{}`: {}", raw, j))
     }

defmt/src/export/mod.rs

@@ -25,6 +25,7 @@ thread_local! {
 #[cfg(feature = "unstable-test")]
 pub fn fetch_string_index() -> u16 {
     I.with(|i| i.load(core::sync::atomic::Ordering::Relaxed))
+        .wrapping_sub(binary_base())
 }
 
 /// For testing purposes
@@ -98,9 +99,61 @@ pub fn timestamp(fmt: crate::Formatter<'_>) {
     unsafe { _defmt_timestamp(fmt) }
 }
 
+/// For bare-metal targets there is no ASLR, so the base address is always 0.
+#[cfg(target_os = "none")]
+fn binary_base() -> u16 {
+    0
+}
+
+/// For Linux (ELF), use the linker-provided `__executable_start` symbol.
+#[cfg(target_os = "linux")]
+#[allow(unused_unsafe)]
+fn binary_base() -> u16 {
+    extern "C" {
+        static __executable_start: u8;
+    }
+    // SAFETY: `__executable_start` is a linker-provided symbol marking the start of the executable.
+    (unsafe { core::ptr::addr_of!(__executable_start) as usize }) as u16
+}
+
+/// For macOS (Mach-O), use the linker-provided `_mh_execute_header` symbol.
+#[cfg(target_os = "macos")]
+#[allow(unused_unsafe)]
+fn binary_base() -> u16 {
+    extern "C" {
+        static _mh_execute_header: u8;
+    }
+    // SAFETY: `_mh_execute_header` is a linker-provided symbol marking the Mach-O header.
+    (unsafe { core::ptr::addr_of!(_mh_execute_header) as usize }) as u16
+}
+
+/// For Windows, use the DOS header address from the PE format.
+#[cfg(target_os = "windows")]
+#[allow(unused_unsafe)]
+fn binary_base() -> u16 {
+    extern "C" {
+        static __ImageBase: u8;
+    }
+    // SAFETY: `__ImageBase` is a linker-provided symbol marking the base of the PE image.
+    (unsafe { core::ptr::addr_of!(__ImageBase) as usize }) as u16
+}
+
+/// Fallback for other platforms - assume no ASLR, so the base address is always 0.
+#[cfg(not(any(
+    target_os = "none",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "windows"
+)))]
+fn binary_base() -> u16 {
+    0
+}
+
 /// Returns the interned string at `address`.
 pub fn make_istr(address: u16) -> Str {
-    Str { address }
+    Str {
+        address: address.wrapping_sub(binary_base()),
+    }
 }
 
 /// Create a Formatter.

macros/src/construct.rs

@@ -59,7 +59,7 @@ pub(crate) fn interned_string(
 
 /// work around restrictions on length and allowed characters imposed by macos linker
 /// returns (note the comma character for macos):
-///   under macos: ".defmt," + 16 character hex digest of symbol's hash
+///   under macos: ".defmt," + prefix
 ///   otherwise:   ".defmt." + prefix + symbol
 pub(crate) fn linker_section(for_macos: bool, prefix: Option<&str>, symbol: &str) -> String {
     let mut sub_section = if let Some(prefix) = prefix {
@@ -69,7 +69,13 @@ pub(crate) fn linker_section(for_macos: bool, prefix: Option<&str>, symbol: &str
     };
 
     if for_macos {
-        sub_section = format!(",{:x}", hash(&sub_section));
+        // Use a single section per severity level instead of unique section per log.
+        // This avoids hitting macOS's 255 section-per-segment limit.
+        // The symbol's export_name is still unique, so address-based lookup works.
+        sub_section = match prefix {
+            Some(p) => format!(",{p}"),
+            None => ",data".to_string(),
+        };
     }
 
     format!(".defmt{sub_section}")

macros/src/items/bitflags.rs

@@ -82,6 +82,7 @@ fn codegen_flag_statics(input: &Input) -> Vec<TokenStream2> {
 
             quote! {
                 #(#cfg_attrs)*
+                #[cfg_attr(target_os = "macos", used)]
                 #[cfg_attr(target_os = "macos", link_section = ".defmt,end")]
                 #[cfg_attr(not(target_os = "macos"), link_section = ".defmt.end")]
                 #[export_name = #sym_name]

macros/src/items/timestamp.rs

@@ -44,6 +44,7 @@ pub(crate) fn expand(args: TokenStream) -> TokenStream {
                 }
             }
 
+            #[cfg_attr(target_os = "macos", used)]
             #var_item;
 
             // Unique symbol name to prevent multiple `timestamp!` invocations in the crate graph.