kill __always_inline
PATCH 1/1 kill __always_inline
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes __always_inline which was formerly in -mm. __always_inline doesn't make any sense:
__always_inline is _exactly_ the same as __inline__, __inline and inline .
The patch below removes __always_inline again:
include/linux/compiler.h renamed from include/linux/compiler.h.old +0 -4
@@ -124,8 +124,4 @@#define noinline#endif -#ifndef __always_inline -#define __always_inline inline -#endif -#endif /* __LINUX_COMPILER_H */
include/asm-i386/fixmap.h renamed from include/asm-i386/fixmap.h.old +1 -1
@@ -129,7 +129,7 @@* directly without tranlation, we catch the bug with a NULL-deference * kernel oops. Illegal ranges of incoming indices are caught too. */ -static __always_inline unsigned long fix_to_virt (const unsigned int idx) +static inline unsigned long fix_to_virt (const unsigned int idx) {/* * this branch gets completely eliminated after inlining,
Quoted 10 lines · Adrian Bunk
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes
__always_inlinewhich was formerly in -mm.__always_inlinedoesn't make any sense:
__always_inlineis _exactly_ the same as__inline__,__inlineand inline .The patch below removes
__always_inlineagain:
But what happens if we later change inline' so that it doesn't do the always inline' thing?
An explicit usage of __always_inline is semantically different than boring old `inline'.
Quoted 10 lines · Andrew Morton
Quoted 9 lines · Adrian Bunk
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes
__always_inlinewhich was formerly in -mm.__always_inlinedoesn't make any sense:
__always_inlineis _exactly_ the same as__inline__,__inlineand inline .
Quoted 7 lines
Quoted 1 line
The patch below removes
__always_inlineagain:But what happens if we later change
inline' so that it doesn't do thealways inline' thing?An explicit usage of
__always_inlineis semantically different than boring old `inline'.
Who audits all current users of inline whether they are __always_inline?
Who ensures, that in the future there will always be the right one of inline and __always_inline choosen in the kernel?
If it doesn't give a compile or runtime error for anyone when it's wrong, many wrong inline/__always_inline will go into the kernel over time.
The intention might be a different semantics, but in the end, it won't work.
E.g., check how many wrong __init/__exit annotations show up in 2.6, each of whom would have been a compile error in 2.4 (and different from a wrong inline/__always_inline, a wrong __init/__exit annotation can cause real problems for users).
If you want to change inline at some point, you will have to audit all users of inline anyway - so why bother if you don't intend to change inline in the forseeable future?
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedQuoted 4 lines · Adrian Bunk
If you want to change inline at some point, you will have to audit all users of inline anyway - so why bother if you don't intend to change inline in the forseeable future?
inline was set to do `always inline' when it was discovered that new gcc was doing dopey things. If gcc gets fixed then we don't need that any more.
But functions which *must* be inlined should be marked __always_inline regardless of anything else.
Hi.
Quoted 11 lines · Adrian Bunk
Quoted 10 lines · Andrew Morton
Quoted 9 lines · Adrian Bunk
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes
__always_inlinewhich was formerly in -mm.__always_inlinedoesn't make any sense:
__always_inlineis _exactly_ the same as__inline__,__inlineand inline .
Quoted 7 lines
Quoted 7 lines
Quoted 1 line
The patch below removes
__always_inlineagain:But what happens if we later change
inline' so that it doesn't do thealways inline' thing?An explicit usage of
__always_inlineis semantically different than boring old `inline'.
Excuse me if I'm being ignorant, but I thought always_inline was introduced because with some recent versions of gcc, inline wasn't doing the job (suspend2, which requires a working inline, was broken by it for example). That is to say, doesn't the definition of always_inline vary with the compiler version?
Regards,
Nigel
Signature · 6 lines
Nigel Cunningham Christian Reformed Church of Tuggeranong PO Box 1004, Tuggeranong, ACT 2901 Many today claim to be tolerant. But true tolerance can cope with others being intolerant.
Quoted 20 lines · Nigel Cunningham
Hi.
Quoted 16 lines · Adrian Bunk
Quoted 15 lines · Andrew Morton
Quoted 10 lines · Adrian Bunk
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes
__always_inlinewhich was formerly in -mm.__always_inlinedoesn't make any sense:
__always_inlineis _exactly_ the same as__inline__,__inlineand inline .The patch below removes
__always_inlineagain:But what happens if we later change
inline' so that it doesn't do thealways inline' thing?
Quoted 7 lines
Quoted 2 lines
Quoted 2 lines
An explicit usage of
__always_inlineis semantically different than boring old `inline'.Excuse me if I'm being ignorant, but I thought
always_inlinewas introduced because with some recent versions of gcc, inline wasn't doing the job (suspend2, which requires a working inline, was broken by it for example).
IIRC, the compiler was generating out-of-line versions of functions in every compilation unit whcih included the header file. When we the developers just wanted inline' to mean inline, dammit'.
If that broke swsusp in some manner then the relevant swsusp functions should be marked always_inline, because they have some special needs.
Quoted 2 lines
That is to say, doesn't the definition of
always_inlinevary with the compiler version?
If the compiler supports attribute((always_inline)) then the kernel build system will use that. If the compiler doesn't support attribute((always_inline)) then we just emit `inline' from cpp and hope that it works out.
Hi.
Quoted 6 lines · Andrew Morton
IIRC, the compiler was generating out-of-line versions of functions in every compilation unit whcih included the header file. When we the developers just wanted
inline' to meaninline, dammit'.If that broke swsusp in some manner then the relevant swsusp functions should be marked
always_inline, because they have some special needs.
Yes, that's exactly right. Suspend relies upon inline always inlining, and as I work around I added...
#undef inline
#define inline __inline__ __attribute__(always_inline))
while this discussion was going on. I should switch this to always_inline now that it's merged.
Quoted 7 lines
Quoted 2 lines
That is to say, doesn't the definition of
always_inlinevary with the compiler version?If the compiler supports attribute((always_inline)) then the kernel build system will use that. If the compiler doesn't support attribute((always_inline)) then we just emit `inline' from cpp and hope that it works out.
Thanks.
Nigel
Signature · 6 lines
Nigel Cunningham Christian Reformed Church of Tuggeranong PO Box 1004, Tuggeranong, ACT 2901 Many today claim to be tolerant. But true tolerance can cope with others being intolerant.
Quoted 24 lines · Andrew Morton
Quoted 23 lines · Nigel Cunningham
Hi.
Quoted 18 lines · Adrian Bunk
Quoted 17 lines · Andrew Morton
Quoted 10 lines · Adrian Bunk
An issue that we already discussed at 2.6.8-rc2-mm2 times:
2.6.9-rc1 includes
__always_inlinewhich was formerly in -mm.__always_inlinedoesn't make any sense:
__always_inlineis _exactly_ the same as__inline__,__inlineand inline .The patch below removes
__always_inlineagain:But what happens if we later change
inline' so that it doesn't do thealways inline' thing?An explicit usage of
__always_inlineis semantically different than boring old `inline'.
Quoted 8 lines
Quoted 4 lines
Excuse me if I'm being ignorant, but I thought
always_inlinewas introduced because with some recent versions of gcc, inline wasn't doing the job (suspend2, which requires a working inline, was broken by it for example).IIRC, the compiler was generating out-of-line versions of functions in every compilation unit whcih included the header file. When we the developers just wanted
inline' to meaninline, dammit'.
`inline, dammit' is
__attribute__((always_inline))
The original `inline' never guarantees that the function will be inlined.
Therefore, `inline' is already #define'd in the Linux kernel to always be __attribute__((always_inline)).
Quoted 10 lines
If that broke swsusp in some manner then the relevant swsusp functions should be marked
always_inline, because they have some special needs.Quoted 2 lines
That is to say, doesn't the definition of
always_inlinevary with the compiler version?If the compiler supports attribute((always_inline)) then the kernel build system will use that. If the compiler doesn't support attribute((always_inline)) then we just emit `inline' from cpp and hope that it works out.
That's exactly how `inline' is already #define'd in the Linux kernel.
And __always_inline is currently simply #define'd to `inline' ...
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedQuoted 9 lines · Adrian Bunk
Quoted 7 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 1 line
The patch below removes
__always_inlineagain:If the compiler supports attribute((always_inline)) then the kernel build system will use that. If the compiler doesn't support attribute((always_inline)) then we just emit `inline' from cpp and hope that it works out.
Quoted 3 lines
That's exactly how `inline' is already #define'd in the Linux kernel.
And
__always_inlineis currently simply #define'd to `inline' ...
Sorry, but the way this is currently done in the Linux kernel is, IMHO, braindead.
I ran into a lot of problems with inline handling while I was working on a piece of instrumentation code that used gcc's -finstrument-functions. I found that the kernel redefinitions for inline were not being universally applied (see the patch below for how I fixed it for my situation). I found that the compiler version affected whether I really got an attribute(always_inline) or not. Also, for some uses, the include order (based on configuration options) affected whether I got the redefinition.
I didn't do a full survey of all inline uses. But the errors I found with this made me nervous.
IMHO, a better approach, if it really is desired to force always_inline, would be to globally replace 'inline' (and friends) with kern_inline or something similar, so you at least get a compiler error if you're picking up the traditional gcc semantics instead of the kernel-mandated semantics.
But my preference would be to do as Andi Kleen has suggested, which is to revert to the use of (un-redefined) 'inline' for optional inlines, and use '__always_inline' for those special cases that REALLY need to be inlines. Most (but probably not all) of these are marked with 'extern inline' in the code today. (Unfortunately, there are a few optional ones marked with 'extern inline' as well - which complicates things). I realize this is riskier, but it seems to make more sense in the long run.
Finally, I think it's bad form to change the meaning of a compiler keyword. It misleading for 'inline' to mean something different in the kernel than it does everywhere else. It means a developer can't use standard gcc documentation to understand kernel code, without inside knowledge. This can be painful for casual or new kernel developers.
Regards,
-- Tim
include/asm-ppc/delay.h +1 -0
@@ -2,6 +2,7 @@#ifndef _PPC_DELAY_H#define _PPC_DELAY_H +#include <linux/compiler.h> /* for inline weirdness */ #include <asm/param.h> /*
include/asm-ppc/processor.h +1 -0
@@ -10,6 +10,7 @@#include <linux/config.h> #include <linux/stringify.h> +#include <linux/compiler.h> /* for inline weirdness */ #include <asm/ptrace.h> #include <asm/types.h>
include/linux/compiler-gcc3.h +1 -1
@@ -3,7 +3,7 @@/* These definitions are for GCC v3.x. */ #include <linux/compiler-gcc.h> -#if __GNUC_MINOR__ >=1 && __GNUC_MINOR__ <4 +#if __GNUC_MINOR__ >=1 # define inline __inline__ __attribute__((always_inline))# define __inline__ __inline__ __attribute__((always_inline))# define __inline __inline__ __attribute__((always_inline))
=============================
Tim Bird
Architecture Group Co-Chair, CE Linux Forum
Senior Staff Engineer, Sony Electronics
E-mail: [email protected]
=============================
Quoted 7 lines · Tim Bird
Finally, I think it's bad form to change the meaning of a compiler keyword. It misleading for 'inline' to mean something different in the kernel than it does everywhere else. It means a developer can't use standard gcc documentation to understand kernel code, without inside knowledge. This can be painful for casual or new kernel developers.
yes, it's horrid. But until and unless gcc gets fixed, what choice do we have? Without this hack, kernel text size increases significantly.
We don't want to have to patch the kernel source in a zillion places for what is hopefully a temporary problem. I'd much rather add `--dwim-dammit' to the gcc command line.
Quoted 2 lines
+#include <
linux/compiler.h> /* for inline weirdness */
#include <asm/param.h>
Mozilla white-space-stuffed your patch. You'll have to use attachments.