MIPS: Make BUG() __noreturn.

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

There is a small problem in that we have to put a magic while(1); loop to fool GCC into really thinking it is noreturn.

Quoted 9 lines · On Thu, 20 Nov 2008 17:26:36 -0800 David Daney <[email protected]>…

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

There is a small problem in that we have to put a magic while(1); loop to fool GCC into really thinking it is noreturn.

That sounds like your __noreturn macro is wrong.

Try using __attribute__ ((__noreturn__))

if that works then fix up the __noreturn definitions for the MIPS and gcc you have.

Quoted 6 lines

That sounds like your __noreturn macro is wrong.

Try using __attribute__ ((__noreturn__))

if that works then fix up the __noreturn definitions for the MIPS and gcc you have.

Nope, gcc is too smart:

$ cat a.c

int f(void) __attribute__((__noreturn__));

int f(void)
{
}

$ gcc -c -Wall a.c
a.c: In function f:
a.c:6: warning: `noreturn' function does return
$ 

Otherwise it looks like the attribute is useless -- it looks like it can only be used for functions where GCC can determine the function does not return anyway. Which means it is redundant.

Quoted 10 lines · Alan Cox

Quoted 7 lines · On Thu, 20 Nov 2008 17:26:36 -0800 David Daney <[email protected]>…

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

Quoted 8 lines

Quoted 2 lines

There is a small problem in that we have to put a magic while(1); loop to fool GCC into really thinking it is noreturn.

That sounds like your __noreturn macro is wrong.

Try using __attribute__ ((__noreturn__))

if that works then fix up the __noreturn definitions for the MIPS and gcc you have.

Nope, gcc is too smart:

$ cat a.c

int f(void) __attribute__((__noreturn__));

int f(void)
{
}

$ gcc -c -Wall a.c
a.c: In function f:
a.c:6: warning: `noreturn' function does return
$ 

Quoted 27 lines · Geert Uytterhoeven

Quoted 13 lines · Alan Cox

Quoted 10 lines · On Thu, 20 Nov 2008 17:26:36 -0800 David Daney <[email protected]>…

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

There is a small problem in that we have to put a magic while(1); loop to
fool GCC into really thinking it is noreturn.

Quoted 6 lines

That sounds like your __noreturn macro is wrong.

Try using __attribute__ ((__noreturn__))

if that works then fix up the __noreturn definitions for the MIPS and gcc you have.

Nope, gcc is too smart:

$ cat a.c

int f(void) __attribute__((__noreturn__));

Quoted 8 lines

int f(void)
{
}

$ gcc -c -Wall a.c
a.c: In function f:
a.c:6: warning: `noreturn' function does return
$ 

That's right.

I was discussing this issue with my colleague Adam Nemet, and we came up with a couple of options:

1) Enhance the _builtin_trap() function so that we can specify the break code that is emitted. This would allow us to do something like:

static inline void __attribute__((noreturn)) BUG()

{
	__builtin_trap(0x200);
}

2) Create a new builtin '__builtin_noreturn()' that expands to nothing but has no CFG edges leaving it, which would allow:

static inline void __attribute__((noreturn)) BUG()

{
	__asm__ __volatile__("break %0" : : "i" (0x200));
	__builtin_noreturn();
}

Quoted 10 lines

up with a couple of options:

1) Enhance the _builtin_trap() function so that we can specify the break code that is emitted. This would allow us to do something like:

static inline void __attribute__((noreturn)) BUG()

{
	__builtin_trap(0x200);
}

Quoted 8 lines

2) Create a new builtin '__builtin_noreturn()' that expands to nothing but has no CFG edges leaving it, which would allow:

static inline void __attribute__((noreturn)) BUG()

{
	__asm__ __volatile__("break %0" : : "i" (0x200));
	__builtin_noreturn();
}

Now I remember, yes, __builtin_trap() is how we fixed it on m68k:

http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e8006b060f3982a969c5170aa869628d54dd30d8

Of course, if you need a different trap code than the default, you're in trouble.

MIPS ISA newer than MIPS I also have conditional break codes allowing something like this:

#define BUG_ON(condition)                                               \
do {                                                                    \
        __asm__ __volatile__("tne $0, %0, %1"                           \
                             : : "r" (condition), "i" (BRK_BUG));       \

} while (0)

that is test of condition and the trap as a single instruction. Note there are break and trap instructions on MIPS and they are basically doing the same job ...

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

There is a small problem in that we have to put a magic while(1); loop to fool GCC into really thinking it is noreturn. This makes the new BUG() function 3 instructions long instead of just 1, but I think it is worth it as it is now unnecessary to do extra work to silence the 'used uninitialized' warnings.

I also re-wrote BUG_ON so that if it is given a constant condition, it just does BUG() instead of loading a constant value in to a register and testing it.

Yup, this change will fix some compile warnings which will never be fixed in any other way for mips.

Review

Quoted 7 lines

(quoted diff) +7 -0

+static inline void __noreturn BUG(void)
+{
+	__asm__ __volatile__("break %0" : : "i" (BRK_BUG));
+	/* Fool GCC into thinking the function doesn't return. */
+	while (1)
+		;
+}

This kind of sucks, doesn't it? It adds instructions into the kernel text, very frequently on fast paths. Those instructions are never executed, and we're blowing away i-cache just to quash compiler warnings.

For example, this:

arch/x86/include/asm/bug.h renamed from arch/x86/include/asm/bug.h~a +0 -2

@@ -22,14 +22,12 @@ do {								\
 		     ".popsection"				\
 		     : : "i" (__FILE__), "i" (__LINE__),	\
 		     "i" (sizeof(struct bug_entry)));		\
-	for (;;) ;						\
 } while (0)
 
 #else
 #define BUG()							\
 do {								\
 	asm volatile("ud2");					\
-	for (;;) ;						\
 } while (0)
 #endif
 

_

reduces the size of i386 mm/vmalloc.o text by 56 bytes.

I wonder if there is any clever way in which we can do this without introducing additional runtime cost.

Review

Quoted 7 lines

(quoted diff) +7 -0

+static inline void __noreturn BUG(void)
+{
+	__asm__ __volatile__("break %0" : : "i" (BRK_BUG));
+	/* Fool GCC into thinking the function doesn't return. */
+	while (1)
+		;
+}

This kind of sucks, doesn't it? It adds instructions into the kernel text, very frequently on fast paths. Those instructions are never executed, and we're blowing away i-cache just to quash compiler warnings.

For example, this:

arch/x86/include/asm/bug.h renamed from arch/x86/include/asm/bug.h~a +0 -2

@@ -22,14 +22,12 @@ do {								\
 		     ".popsection"				\
 		     : : "i" (__FILE__), "i" (__LINE__),	\
 		     "i" (sizeof(struct bug_entry)));		\
-	for (;;) ;						\
 } while (0)
 
 #else
 #define BUG()							\
 do {								\
 	asm volatile("ud2");					\
-	for (;;) ;						\
 } while (0)
 #endif
 

_

reduces the size of i386 mm/vmalloc.o text by 56 bytes.

yes - the total image effect is significantly - recently looked at how much larger !CONFIG_BUG builds would get if we inserted an infinite loop into them - it was in the 50K text range (!).

but in the x86 ud2 case we could guarantee that we wont ever return from that exception. Mind sending a patch with a signoff, a description and an infinite loop in the u2d handler?

Quoted 29 lines · Andrew Morton

Review

Quoted 8 lines

(quoted diff) +7 -0

+static inline void __noreturn BUG(void)
+{
+	__asm__ __volatile__("break %0" : : "i" (BRK_BUG));
+	/* Fool GCC into thinking the function doesn't return. */
+	while (1)
+		;
+}

This kind of sucks, doesn't it? It adds instructions into the kernel text, very frequently on fast paths. Those instructions are never executed, and we're blowing away i-cache just to quash compiler warnings.

For example, this:

arch/x86/include/asm/bug.h renamed from arch/x86/include/asm/bug.h~a +0 -2

@@ -22,14 +22,12 @@ do {								\
 		     ".popsection"				\
 		     : : "i" (__FILE__), "i" (__LINE__),	\
 		     "i" (sizeof(struct bug_entry)));		\
-	for (;;) ;						\
 } while (0)
 
 #else
 #define BUG()							\
 do {								\
 	asm volatile("ud2");					\
-	for (;;) ;						\
 } while (0)
 #endif
 

Quoted 4 lines

_

reduces the size of i386 mm/vmalloc.o text by 56 bytes.

yes - the total image effect is significantly - recently looked at how much larger !CONFIG_BUG builds would get if we inserted an infinite loop into them - it was in the 50K text range (!).

but in the x86 ud2 case we could guarantee that we wont ever return from that exception. Mind sending a patch with a signoff, a description and an infinite loop in the u2d handler?

From: David Daney <[email protected]>
Date: Thu, 20 Nov 2008 17:26:36 -0800
To: linux-mips <[email protected]>
CC: [email protected]
Subject: [PATCH] MIPS: Make BUG() __noreturn.
Content-Type: text/plain; charset=ISO-8859-1; format=flowed

MIPS: Make BUG() __noreturn.

Often we do things like put BUG() in the default clause of a case statement. Since it was not declared __noreturn, this could sometimes lead to bogus compiler warnings that variables were used uninitialized.

There is a small problem in that we have to put a magic while(1); loop to fool GCC into really thinking it is noreturn. This makes the new BUG() function 3 instructions long instead of just 1, but I think it is worth it as it is now unnecessary to do extra work to silence the 'used uninitialized' warnings.

I also re-wrote BUG_ON so that if it is given a constant condition, it just does BUG() instead of loading a constant value in to a register and testing it.