Skip to contentSkip to conversation

arc: Fix __fls() const-foldability via __builtin_clzl()

PATCH Superseded Kees Cook 3 participants 6 messages Aug 26, 2025 – Aug 27, 2025

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Kees Cook

author
#0 lore raw

PATCH 1/1 arc: Fix __fls() const-foldability via __builtin_clzl()

While tracking down a problem where constant expressions used by BUILD_BUG_ON() suddenly stopped working[1], we found that an added static initializer was convincing the compiler that it couldn't track the state of the prior statically initialized value. Tracing this down found that ffs() was used in the initializer macro, but since it wasn't marked with __attribute__const__, the compiler had to assume the function might change variable states as a side-effect (which is not true for ffs(), which provides deterministic math results).

For arc architecture with CONFIG_ISA_ARCV2=y, the __fls() function uses __builtin_arc_fls() which lacks GCC's const attribute, preventing compile-time constant folding[2]. Fix this by handling compile-time constants with the standard __builtin_clzl() builtin (which has const attribute) while preserving the optimized arc-specific builtin for runtime cases. This has the added benefit of skipping runtime calculation of compile-time constant values.

Build tested ARCH=arc allyesconfig with GCC arc-linux 15.2.0.

---
Cc: Yury Norov <[email protected]>
Cc: Rasmus Villemoes <[email protected]>
Cc: Vineet Gupta <[email protected]>
Cc: <[email protected]>

---
 arch/arc/include/asm/bitops.h | 2 ++
 1 file changed, 2 insertions(+)
arch/arc/include/asm/bitops.h +2 -0
index 5340c2871392..df894235fdbc 100644
@@ -133,6 +133,8 @@ static inline __attribute__ ((const)) int fls(unsigned int x)
  */
 static inline __attribute__ ((const)) unsigned long __fls(unsigned long x)
 {
+	if (__builtin_constant_p(x))
+		return x ? BITS_PER_LONG - 1 - __builtin_clzl(x) : 0;
 	/* FLS insn has exactly same semantics as the API */
 	return	__builtin_arc_fls(x);
 }
Signature · 1 line
2.34.1
#1 lore raw
Quoted 9 lines · Kees Cook

While tracking down a problem where constant expressions used by BUILD_BUG_ON() suddenly stopped working[1], we found that an added static initializer was convincing the compiler that it couldn't track the state of the prior statically initialized value. Tracing this down found that ffs() was used in the initializer macro, but since it wasn't marked with __attribute__const__, the compiler had to assume the function might change variable states as a side-effect (which is not true for ffs(), which provides deterministic math results).

Quoted 3 lines

For arc architecture with CONFIG_ISA_ARCV2=y, the __fls() function uses __builtin_arc_fls() which lacks GCC's const attribute, preventing compile-time constant folding[2].

That sounds like a compiler bug, or "missed optimization". Looking into the gcc source code, it seems that most "generic" builtins (well, those eligible because they're just math) are internally declared with that const attribute. E.g. there's

gcc/builtins.def:DEF_GCC_BUILTIN (BUILT_IN_CLZL, "clzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)

The DEF_BUILTIN macro for e.g. avr seems to support providing such attributes, e.g. there's

gcc/config/avr/builtins.def:DEF_BUILTIN (ABSHR, 1, hr_ftype_hr, ssabsqq2, "__ssabs_1", attr_const)

But the arc-specific ones in gcc/config/arc/builtins.def have no such infrastructure readily available.

Of course, I also don't know if __builtin_arc_fls() is even eligible for the const attribute (I don't know if it might have some side effects on a flags register or something). But if it is, perhaps it's possible to amend gcc's builtin declaration by explicitly (re)declaring it

int __builtin_arc_fls(int x) __attribute_const;

?

If __builtin_arc_fls() simply doesn't qualify for attr_const for $reason, I think it would be good to have that documented in the commit msg. If it does, I think a gcc ticket and link to that would be in order.

Rasmus

author
#2 lore raw
Quoted 3 lines · Rasmus Villemoes

If __builtin_arc_fls() simply doesn't qualify for attr_const for $reason, I think it would be good to have that documented in the commit msg. If it does, I think a gcc ticket and link to that would be in order.

I already sent the patch to fix it. :)

https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693273.html

Signature · 1 line
Kees Cook
maintainer
#3 lore raw
Quoted 8 lines · Kees Cook
Quoted 3 lines · Rasmus Villemoes

If __builtin_arc_fls() simply doesn't qualify for attr_const for $reason, I think it would be good to have that documented in the commit msg. If it does, I think a gcc ticket and link to that would be in order.

I already sent the patch to fix it. :)

https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693273.html

I'm OK taking the patch if it fixes real problem for you, but it looks more like a GCC problem, right? Is Clang also affected?

If, say, Clang is not affected, and you expect that newer GCC versions will not be affected too, let's protect the new code with a proper ifdefery, so that it will be easier to drop the workaround later?

Thanks,
Yury

author
#4 lore raw
Quoted 6 lines · Yury Norov
Quoted 5 lines · Kees Cook
Quoted 3 lines · Rasmus Villemoes

If __builtin_arc_fls() simply doesn't qualify for attr_const for $reason, I think it would be good to have that documented in the commit msg. If it does, I think a gcc ticket and link to that would be in order.

Quoted 6 lines
Quoted 3 lines

I already sent the patch to fix it. :)

https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693273.html

I'm OK taking the patch if it fixes real problem for you, but it looks more like a GCC problem, right? Is Clang also affected?

Without it, KUnit testing of ffs/fls fails on arc. Clang is not affected. Even with the GCC fix landed, all older GCCs with still fail, and since it provides a improved code generation for arc, it seems worth it (compile-time-calculable values will be emitted instead of always running the arc instructions).

Quoted 3 lines

If, say, Clang is not affected, and you expect that newer GCC versions will not be affected too, let's protect the new code with a proper ifdefery, so that it will be easier to drop the workaround later?

I think the codegen benefit is worth it as I have it.

Signature · 1 line
Kees Cook
maintainer
#5 lore raw
Quoted 7 lines · Kees Cook
Quoted 6 lines · Yury Norov
Quoted 5 lines · Kees Cook
Quoted 3 lines · Rasmus Villemoes

If __builtin_arc_fls() simply doesn't qualify for attr_const for $reason, I think it would be good to have that documented in the commit msg. If it does, I think a gcc ticket and link to that would be in order.

Quoted 8 lines
Quoted 6 lines
Quoted 3 lines

I already sent the patch to fix it. :)

https://gcc.gnu.org/pipermail/gcc-patches/2025-August/693273.html

I'm OK taking the patch if it fixes real problem for you, but it looks more like a GCC problem, right? Is Clang also affected?

Without it, KUnit testing of ffs/fls fails on arc. Clang is not

That's a solid point. Can you please notice it in changelog too?

Quoted 4 lines

affected. Even with the GCC fix landed, all older GCCs with still fail, and since it provides a improved code generation for arc, it seems worth it (compile-time-calculable values will be emitted instead of always running the arc instructions).

Yep. This is what I meant. Once the fix is landed, we will not need this code. When the minimal supported GCC version will become greater than one that has the fix applied, it will be much easier to spot this hack and drop it, if we mention that explicitly.

Something like that:

    #if IS_ENABLED(CONFIG_CC_IS_GCC) && CONFIG_GCC_VERSION < XXX
        if ( __builtin_constant_p(x))
                return x ? BITS_PER_LONG - 1 - __builtin_clzl(x) : 0;
    #endif
Quoted 5 lines
Quoted 3 lines

If, say, Clang is not affected, and you expect that newer GCC versions will not be affected too, let's protect the new code with a proper ifdefery, so that it will be easier to drop the workaround later?

I think the codegen benefit is worth it as I have it.

That's I'm surely agree.