Re: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

Re: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

[Miguel Ojeda]

On Tue, Aug 12, 2025 at 11:17 PM Areej <areejhamid8560@gmail.com> wrote:
>
> From ca720a9f7b977a6360f47b0037a9f8784dee192d Mon Sep 17 00:00:00 2001
> From: Areej <areejhamid8560@gmail.com>
> Date: Tue, 12 Aug 2025 23:34:20 +0500
> Subject: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

This seems to still be part of the email body -- worse, it is a
multipart one with HTML too, which means it didn't arrive to the
mailing list.

I would suggest trying `git send-email` (it comes with Git).

Also, please Cc all the relevant members/people -- you can use
`scripts/get_maintainer.pl` to get a list for a given patch (or file).

> Signed-off-by: Areej <areejhamid8560@gmail.com>

The kernel requires using a "known identity" (typically meaning the
full/real name) -- please see
https://docs.kernel.org/process/submitting-patches.html#developer-s-certificate-of-origin-1-1

> Use this macro to refactor CONFIG_64BIT conditionals by replacing
> repetitive #[cfg] blocks with cleaner inline expressions.

This could, in principle, be split into a second patch, so that you
can Cc the timekeeping maintainers ("DELAY, SLEEP, TIMEKEEPING, TIMERS
[RUST]") and use a suitable title prefix (e.g. "rust: time: ...") etc.

> +/// let x = if_cfg!(if feature = "foo" {

We don't use `feature =` in the kernel (apart from places like
pin-init which are vendored), so it would be best to show an example
with a `CONFIG_*` instead.

> +/// // `x` will be 10 if the feature "foo" is enabled, otherwise 20.
> +/// assert!(x == 10 || x == 20);

I guess we could have two `static_assert!`s, one per `cfg`, but I
guess this may be simpler/easier to read.

Thanks!

Cheers,
Miguel

[PATCH] rust: lib: add if_cfg! macro for conditional compilation

[Areej]

Add a new if_cfg! macro to simplify conditional compilation using
cfg attributes. This macro expands to paired #[cfg(cond)] and 
#[cfg(not(cond))] blocks, allowing compile-time selection between 
code branches in both expression and statement contexts.

Suggested-by: Benno Lossin <lossin@kernel.org>
Link: https://github.com/Rust-for-Linux/linux/issues/1183
Signed-off-by: Areej Hamid <areejhamid8560@gmail.com>
---
 rust/kernel/lib.rs | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index ed53169e795c..47e73949392d 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -294,6 +294,42 @@ macro_rules! asm {
     };
 }
 
+/// Conditionally compiles and executes code based on a `#[cfg]` condition.
+///
+/// Expands to `#[cfg(cond)] { ... }` and `#[cfg(not(cond))] { ... }`,
+/// allowing conditional compilation in both expression and statement positions.
+///
+/// This macro is useful when both branches must be valid Rust code and the
+/// selection between them is done at compile time via a config option.
+/// # Examples
+/// ```
+/// # use kernel::if_cfg;
+/// // Select a value depending on CONFIG_64BIT.
+/// let x = if_cfg!(if CONFIG_64BIT {
+///     64
+/// } else {
+///     32
+/// });
+///
+/// // `x` will be 64 if CONFIG_64BIT is enabled, otherwise 32.
+/// assert!(x == 64 || x == 32);
+/// ```
+#[macro_export]
+macro_rules! if_cfg {
+    (if $cond:tt { $($then:tt)* } else { $($else:tt)* }) => {{
+        #[cfg($cond)]
+        { $($then)* }
+        #[cfg(not($cond))]
+        { $($else)* }
+    }};
+    (if $cond:tt { $($then:tt)* }) => {{
+        #[cfg($cond)]
+        { $($then)* }
+        #[cfg(not($cond))]
+        { () }
+    }};
+}
+
 /// Gets the C string file name of a [`Location`].
 ///
 /// If `file_with_nul()` is not available, returns a string that warns about it.
@@ -337,3 +373,4 @@ pub fn file_from_location<'a>(loc: &'a core::panic::Location<'a>) -> &'a core::f
         c"<Location::file_with_nul() not supported>"
     }
 }
+
-- 
2.43.0

Re: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

[Thomas Weißschuh]

On 2025-08-14 01:38:26+0500, Areej wrote:
> Add a new if_cfg! macro to simplify conditional compilation using
> cfg attributes. This macro expands to paired #[cfg(cond)] and 
> #[cfg(not(cond))] blocks, allowing compile-time selection between 
> code branches in both expression and statement contexts.
> 
> Suggested-by: Benno Lossin <lossin@kernel.org>
> Link: https://github.com/Rust-for-Linux/linux/issues/1183
> Signed-off-by: Areej Hamid <areejhamid8560@gmail.com>
> ---
>  rust/kernel/lib.rs | 37 +++++++++++++++++++++++++++++++++++++
>  1 file changed, 37 insertions(+)
> 
> diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
> index ed53169e795c..47e73949392d 100644
> --- a/rust/kernel/lib.rs
> +++ b/rust/kernel/lib.rs
> @@ -294,6 +294,42 @@ macro_rules! asm {
>      };
>  }
>  
> +/// Conditionally compiles and executes code based on a `#[cfg]` condition.
> +///
> +/// Expands to `#[cfg(cond)] { ... }` and `#[cfg(not(cond))] { ... }`,
> +/// allowing conditional compilation in both expression and statement positions.
> +///
> +/// This macro is useful when both branches must be valid Rust code and the
> +/// selection between them is done at compile time via a config option.
> +/// # Examples
> +/// ```
> +/// # use kernel::if_cfg;
> +/// // Select a value depending on CONFIG_64BIT.
> +/// let x = if_cfg!(if CONFIG_64BIT {
> +///     64
> +/// } else {
> +///     32
> +/// });

Isn't this the same as cfg!()?

if cfg!(CONFIG_64BIT) {
	64
} else {
	32
}

https://doc.rust-lang.org/std/macro.cfg.html

> +///
> +/// // `x` will be 64 if CONFIG_64BIT is enabled, otherwise 32.
> +/// assert!(x == 64 || x == 32);
> +/// ```
> +#[macro_export]
> +macro_rules! if_cfg {
> +    (if $cond:tt { $($then:tt)* } else { $($else:tt)* }) => {{
> +        #[cfg($cond)]
> +        { $($then)* }
> +        #[cfg(not($cond))]
> +        { $($else)* }
> +    }};
> +    (if $cond:tt { $($then:tt)* }) => {{
> +        #[cfg($cond)]
> +        { $($then)* }
> +        #[cfg(not($cond))]
> +        { () }
> +    }};
> +}
> +
>  /// Gets the C string file name of a [`Location`].
>  ///
>  /// If `file_with_nul()` is not available, returns a string that warns about it.
> @@ -337,3 +373,4 @@ pub fn file_from_location<'a>(loc: &'a core::panic::Location<'a>) -> &'a core::f
>          c"<Location::file_with_nul() not supported>"
>      }
>  }
> +

Spurous whitespace change.

Re: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

[Thomas Weißschuh]

Hi!

Please respond inline instead of top-posting.

On 2025-08-14 05:22:51+0500, Areej wrote:
> On Thu, 14 Aug 2025 at 01:59, Thomas Weißschuh <thomas@t-8ch.de> wrote:
> 
> > On 2025-08-14 01:38:26+0500, Areej wrote:
> > > Add a new if_cfg! macro to simplify conditional compilation using
> > > cfg attributes. This macro expands to paired #[cfg(cond)] and
> > > #[cfg(not(cond))] blocks, allowing compile-time selection between
> > > code branches in both expression and statement contexts.
> > >
> > > Suggested-by: Benno Lossin <lossin@kernel.org>
> > > Link: https://github.com/Rust-for-Linux/linux/issues/1183
> > > Signed-off-by: Areej Hamid <areejhamid8560@gmail.com>
> > > ---
> > >  rust/kernel/lib.rs | 37 +++++++++++++++++++++++++++++++++++++
> > >  1 file changed, 37 insertions(+)
> > >
> > > diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
> > > index ed53169e795c..47e73949392d 100644
> > > --- a/rust/kernel/lib.rs
> > > +++ b/rust/kernel/lib.rs
> > > @@ -294,6 +294,42 @@ macro_rules! asm {
> > >      };
> > >  }
> > >
> > > +/// Conditionally compiles and executes code based on a `#[cfg]`
> > condition.
> > > +///
> > > +/// Expands to `#[cfg(cond)] { ... }` and `#[cfg(not(cond))] { ... }`,
> > > +/// allowing conditional compilation in both expression and statement
> > positions.
> > > +///
> > > +/// This macro is useful when both branches must be valid Rust code and
> > the
> > > +/// selection between them is done at compile time via a config option.
> > > +/// # Examples
> > > +/// ```
> > > +/// # use kernel::if_cfg;
> > > +/// // Select a value depending on CONFIG_64BIT.
> > > +/// let x = if_cfg!(if CONFIG_64BIT {
> > > +///     64
> > > +/// } else {
> > > +///     32
> > > +/// });
> >
> > Isn't this the same as cfg!()?
> >
> > if cfg!(CONFIG_64BIT) {
> >         64
> > } else {
> >         32
> > }
> >
> > https://doc.rust-lang.org/std/macro.cfg.html

> The key difference is that cfg!() requires both branches to contain valid,
> compilable code, while if_cfg!() uses true conditional compilation via
> #[cfg], so only the branch that matches the configuration is compiled. This
> difference matters when different configurations enable/disable entire
> subsystems, and functions or types may only exist under certain config
> options. The if_cfg!() macro enables cleaner conditional compilation
> without compilation errors from referencing code that isn’t included in the
> current configuration.

The docs for if_cfg!() also says that "both branches must be valid Rust code".
And the example case would be better served by cfg!(). Can both the docs and
example provide a clear distinction between the two?

> > the
> 
> > > +///
> > > +/// // `x` will be 64 if CONFIG_64BIT is enabled, otherwise 32.
> > > +/// assert!(x == 64 || x == 32);
> > > +/// ```
> > > +#[macro_export]
> > > +macro_rules! if_cfg {
> > > +    (if $cond:tt { $($then:tt)* } else { $($else:tt)* }) => {{
> > > +        #[cfg($cond)]
> > > +        { $($then)* }
> > > +        #[cfg(not($cond))]
> > > +        { $($else)* }
> > > +    }};
> > > +    (if $cond:tt { $($then:tt)* }) => {{
> > > +        #[cfg($cond)]
> > > +        { $($then)* }
> > > +        #[cfg(not($cond))]
> > > +        { () }
> > > +    }};
> > > +}
> > > +
> > >  /// Gets the C string file name of a [`Location`].
> > >  ///
> > >  /// If `file_with_nul()` is not available, returns a string that warns
> > about it.
> > > @@ -337,3 +373,4 @@ pub fn file_from_location<'a>(loc: &'a
> > core::panic::Location<'a>) -> &'a core::f
> > >          c"<Location::file_with_nul() not supported>"
> > >      }
> > >  }
> > > +
> >
> > Spurous whitespace change.
> >

Re: [PATCH] rust: lib: add if_cfg! macro for conditional compilation

[Greg Kroah-Hartman]

On Thu, Aug 14, 2025 at 01:38:26AM +0500, Areej wrote:
> Add a new if_cfg! macro to simplify conditional compilation using
> cfg attributes. This macro expands to paired #[cfg(cond)] and 
> #[cfg(not(cond))] blocks, allowing compile-time selection between 
> code branches in both expression and statement contexts.

Nit, trailing whitespace in your text :(

> 
> Suggested-by: Benno Lossin <lossin@kernel.org>
> Link: https://github.com/Rust-for-Linux/linux/issues/1183
> Signed-off-by: Areej Hamid <areejhamid8560@gmail.com>

 From: line does not match up with this text :(

thanks,

greg k-h

[PATCH v2] rust: lib: add if_cfg! macro for conditional compilation

[Areej Hamid]

Add the `if_cfg!` macro to simplify conditional compilation using `cfg`
attributes. The macro expands to paired `#[cfg(cond)]` and
`#[cfg(not(cond))]` blocks, allowing compile-time selection between
code branches in both expression and statement contexts.

Note: Previous documentation incorrectly stated that both branches
must be valid Rust code. In reality, `if_cfg!()` compiles only the
active branch, allowing the inactive branch to reference items that
may not exist under certain configurations.

Suggested-by: Benno Lossin <lossin@kernel.org>
Link: https://github.com/Rust-for-Linux/linux/issues/1183
Signed-off-by: Areej Hamid <areejhamid8560@gmail.com>
---
 rust/kernel/lib.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index ed53169e795c..6bcce24600e3 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -294,6 +294,57 @@ macro_rules! asm {
     };
 }
 
+/// Conditionally compiles and executes code based on a `#[cfg]` condition.
+///
+/// Expands to `#[cfg(cond)] { ... }` and `#[cfg(not(cond))] { ... }`,
+/// allowing conditional compilation in both expression and statement positions.
+///
+/// # Key difference from `cfg!()`
+/// - `cfg!()` evaluates a configuration flag at compile time, but both branches must be valid Rust code
+/// - `if_cfg!()` compiles only the active branch, so the inactive branch can reference
+///   functions, types, or constants that may not exist under certain configurations
+///
+/// # Examples
+///
+/// Demonstrates the difference between `if_cfg!()` and `cfg!()`:
+/// ```ignore
+/// # use kernel::if_cfg;
+/// // FOR CONFIG_64BIT
+/// // Only the active branch is compiled - inactive branch can be invalid
+/// let x = if_cfg!(if CONFIG_64BIT {
+///     42  // valid code
+/// } else {
+///     undefined_function()  // invalid, but completely ignored by compiler
+/// });
+/// assert_eq!(x, 42);
+/// ```
+///
+/// Using `cfg!()` instead would fail compilation:
+/// ```ignore
+/// // This fails because Rust must validate both branches
+/// let x = if cfg!(CONFIG_64BIT) {
+///     42
+/// } else {
+///     undefined_function()  // compilation error - function doesn't exist
+/// };
+/// assert_eq!(x, 42);
+/// ```
+#[macro_export]
+macro_rules! if_cfg {
+    (if $cond:tt { $($then:tt)* } else { $($else:tt)* }) => {{
+        #[cfg($cond)]
+        { $($then)* }
+        #[cfg(not($cond))]
+        { $($else)* }
+    }};
+    (if $cond:tt { $($then:tt)* }) => {{
+        #[cfg($cond)]
+        { $($then)* }
+        #[cfg(not($cond))]
+        { () }
+    }};
+}
+
 /// Gets the C string file name of a [`Location`].
 ///
 /// If `file_with_nul()` is not available, returns a string that warns about it.
-- 
2.43.0

Re: [PATCH v2] rust: lib: add if_cfg! macro for conditional compilation

[Miguel Ojeda]

On Thu, Aug 14, 2025 at 6:25 PM Areej Hamid <areejhamid8560@gmail.com> wrote:
>
> +/// # Key difference from `cfg!()`

Please add an empty docs line after headers. Also before opening examples below.

> +/// - `cfg!()` evaluates a configuration flag at compile time, but both branches must be valid Rust code

Please use intra-doc links wherever they may work. Also please end
sentences with a period in docs and comments.

> +/// - `if_cfg!()` compiles only the active branch, so the inactive branch can reference
> +///   functions, types, or constants that may not exist under certain configurations

Perhaps we could say "... branch can, for instance, reference ...", or
that it is not type checked in general, i.e. more things than
undefined items are allowed.

> +/// // FOR CONFIG_64BIT

I would skip this line.

By the way, Tamir suggested in the linked Rust for Linux issue to
match the name of the upstream one in case we want to migrate to the
standard library one eventually. In the commit message, I would also
mention this and link to the tracking issue that Trevor mentioned:
https://github.com/rust-lang/rust/issues/115585.

Finally, we may want to consider putting this into somewhere else,
rather than the root file of the crate.

Cheers,
Miguel

Re: [PATCH v2] rust: lib: add if_cfg! macro for conditional compilation

[Miguel Ojeda]

On Thu, Aug 14, 2025 at 8:49 PM Miguel Ojeda
<miguel.ojeda.sandonis@gmail.com> wrote:
>
> Finally, we may want to consider putting this into somewhere else,
> rather than the root file of the crate.

By the way, there are some strange addresses in Cc: Thomas at domain
dot com, Andreas at Linaro, etc.

Where are you fetching those from? Please use the ones from the
`MAINTAINERS` file.

Thanks!

Cheers,
Miguel

Re: [PATCH v2] rust: lib: add if_cfg! macro for conditional compilation

[Benno Lossin]

On Thu Aug 14, 2025 at 8:49 PM CEST, Miguel Ojeda wrote:
> By the way, Tamir suggested in the linked Rust for Linux issue to
> match the name of the upstream one in case we want to migrate to the
> standard library one eventually. In the commit message, I would also
> mention this and link to the tracking issue that Trevor mentioned:
> https://github.com/rust-lang/rust/issues/115585.

Didn't we also want to vendor the `cfg-if` crate? Or am I missing
something?

> Finally, we may want to consider putting this into somewhere else,
> rather than the root file of the crate.

Yeah, let's have it in a `cfg_if.rs` or whatever the macro will be
called.

---
Cheers,
Benno