2005-04-16 16:20:36 -06:00
|
|
|
#ifndef __LINUX_COMPILER_H
|
|
|
|
#define __LINUX_COMPILER_H
|
|
|
|
|
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
|
|
|
#ifdef __CHECKER__
|
|
|
|
# define __user __attribute__((noderef, address_space(1)))
|
2009-10-29 07:34:15 -06:00
|
|
|
# define __kernel __attribute__((address_space(0)))
|
2005-04-16 16:20:36 -06:00
|
|
|
# define __safe __attribute__((safe))
|
|
|
|
# define __force __attribute__((force))
|
|
|
|
# define __nocast __attribute__((nocast))
|
|
|
|
# define __iomem __attribute__((noderef, address_space(2)))
|
2012-12-17 17:03:24 -07:00
|
|
|
# define __must_hold(x) __attribute__((context(x,1,1)))
|
2006-10-01 00:28:21 -06:00
|
|
|
# define __acquires(x) __attribute__((context(x,0,1)))
|
|
|
|
# define __releases(x) __attribute__((context(x,1,0)))
|
|
|
|
# define __acquire(x) __context__(x,1)
|
|
|
|
# define __release(x) __context__(x,-1)
|
2006-09-29 03:01:03 -06:00
|
|
|
# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)
|
2009-10-29 07:34:15 -06:00
|
|
|
# define __percpu __attribute__((noderef, address_space(3)))
|
2010-04-28 15:39:09 -06:00
|
|
|
#ifdef CONFIG_SPARSE_RCU_POINTER
|
|
|
|
# define __rcu __attribute__((noderef, address_space(4)))
|
|
|
|
#else
|
2010-05-11 17:13:14 -06:00
|
|
|
# define __rcu
|
2010-04-28 15:39:09 -06:00
|
|
|
#endif
|
2007-07-26 10:35:29 -06:00
|
|
|
extern void __chk_user_ptr(const volatile void __user *);
|
|
|
|
extern void __chk_io_ptr(const volatile void __iomem *);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
# define __user
|
|
|
|
# define __kernel
|
|
|
|
# define __safe
|
|
|
|
# define __force
|
|
|
|
# define __nocast
|
|
|
|
# define __iomem
|
|
|
|
# define __chk_user_ptr(x) (void)0
|
|
|
|
# define __chk_io_ptr(x) (void)0
|
|
|
|
# define __builtin_warning(x, y...) (1)
|
2012-12-17 17:03:24 -07:00
|
|
|
# define __must_hold(x)
|
2005-04-16 16:20:36 -06:00
|
|
|
# define __acquires(x)
|
|
|
|
# define __releases(x)
|
|
|
|
# define __acquire(x) (void)0
|
|
|
|
# define __release(x) (void)0
|
2006-09-29 03:01:03 -06:00
|
|
|
# define __cond_lock(x,c) (c)
|
2009-10-29 07:34:15 -06:00
|
|
|
# define __percpu
|
2010-05-11 17:13:14 -06:00
|
|
|
# define __rcu
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2012-11-21 19:00:25 -07:00
|
|
|
/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
|
|
|
|
#define ___PASTE(a,b) a##b
|
|
|
|
#define __PASTE(a,b) ___PASTE(a,b)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
2009-01-02 10:23:03 -07:00
|
|
|
#ifdef __GNUC__
|
|
|
|
#include <linux/compiler-gcc.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2008-08-14 20:47:18 -06:00
|
|
|
#define notrace __attribute__((no_instrument_function))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Intel compiler defines __GNUC__. So we will overwrite implementations
|
|
|
|
* coming from above header files here
|
|
|
|
*/
|
|
|
|
#ifdef __INTEL_COMPILER
|
|
|
|
# include <linux/compiler-intel.h>
|
|
|
|
#endif
|
|
|
|
|
2012-11-20 14:13:10 -07:00
|
|
|
/* Clang compiler defines __GNUC__. So we will overwrite implementations
|
|
|
|
* coming from above header files here
|
|
|
|
*/
|
|
|
|
#ifdef __clang__
|
|
|
|
#include <linux/compiler-clang.h>
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Generic compiler-dependent macros required for kernel
|
|
|
|
* build go below this comment. Actual compiler/compiler version
|
|
|
|
* specific implementations come from the above header files
|
|
|
|
*/
|
|
|
|
|
2008-11-12 13:24:24 -07:00
|
|
|
struct ftrace_branch_data {
|
2008-11-11 22:14:39 -07:00
|
|
|
const char *func;
|
|
|
|
const char *file;
|
|
|
|
unsigned line;
|
2008-11-20 23:30:54 -07:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
unsigned long correct;
|
|
|
|
unsigned long incorrect;
|
|
|
|
};
|
|
|
|
struct {
|
|
|
|
unsigned long miss;
|
|
|
|
unsigned long hit;
|
|
|
|
};
|
2009-03-17 14:15:44 -06:00
|
|
|
unsigned long miss_hit[2];
|
2008-11-20 23:30:54 -07:00
|
|
|
};
|
2008-11-11 22:14:39 -07:00
|
|
|
};
|
2008-11-12 13:24:24 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
|
|
|
|
* to disable branch tracing on a per file basis.
|
|
|
|
*/
|
2009-04-05 08:20:02 -06:00
|
|
|
#if defined(CONFIG_TRACE_BRANCH_PROFILING) \
|
|
|
|
&& !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
|
2008-11-12 13:24:24 -07:00
|
|
|
void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
|
2008-11-11 22:14:39 -07:00
|
|
|
|
|
|
|
#define likely_notrace(x) __builtin_expect(!!(x), 1)
|
|
|
|
#define unlikely_notrace(x) __builtin_expect(!!(x), 0)
|
|
|
|
|
2008-11-20 22:40:40 -07:00
|
|
|
#define __branch_check__(x, expect) ({ \
|
2008-11-11 22:14:39 -07:00
|
|
|
int ______r; \
|
2008-11-12 13:24:24 -07:00
|
|
|
static struct ftrace_branch_data \
|
2008-11-11 22:14:39 -07:00
|
|
|
__attribute__((__aligned__(4))) \
|
2008-11-20 22:40:40 -07:00
|
|
|
__attribute__((section("_ftrace_annotated_branch"))) \
|
2008-11-11 22:14:39 -07:00
|
|
|
______f = { \
|
|
|
|
.func = __func__, \
|
|
|
|
.file = __FILE__, \
|
|
|
|
.line = __LINE__, \
|
|
|
|
}; \
|
|
|
|
______r = likely_notrace(x); \
|
2008-11-20 22:40:40 -07:00
|
|
|
ftrace_likely_update(&______f, ______r, expect); \
|
2008-11-11 22:14:39 -07:00
|
|
|
______r; \
|
|
|
|
})
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Using __builtin_constant_p(x) to ignore cases where the return
|
|
|
|
* value is always the same. This idea is taken from a similar patch
|
|
|
|
* written by Daniel Walker.
|
|
|
|
*/
|
|
|
|
# ifndef likely
|
2008-11-20 22:40:40 -07:00
|
|
|
# define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
|
2008-11-11 22:14:39 -07:00
|
|
|
# endif
|
|
|
|
# ifndef unlikely
|
2008-11-20 22:40:40 -07:00
|
|
|
# define unlikely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
|
2008-11-11 22:14:39 -07:00
|
|
|
# endif
|
2008-11-20 23:30:54 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILE_ALL_BRANCHES
|
|
|
|
/*
|
|
|
|
* "Define 'is'", Bill Clinton
|
|
|
|
* "Define 'if'", Steven Rostedt
|
|
|
|
*/
|
2009-04-07 08:59:41 -06:00
|
|
|
#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
|
|
|
|
#define __trace_if(cond) \
|
|
|
|
if (__builtin_constant_p((cond)) ? !!(cond) : \
|
2008-11-20 23:30:54 -07:00
|
|
|
({ \
|
|
|
|
int ______r; \
|
|
|
|
static struct ftrace_branch_data \
|
|
|
|
__attribute__((__aligned__(4))) \
|
|
|
|
__attribute__((section("_ftrace_branch"))) \
|
|
|
|
______f = { \
|
|
|
|
.func = __func__, \
|
|
|
|
.file = __FILE__, \
|
|
|
|
.line = __LINE__, \
|
|
|
|
}; \
|
|
|
|
______r = !!(cond); \
|
2009-03-17 14:15:44 -06:00
|
|
|
______f.miss_hit[______r]++; \
|
2008-11-20 23:30:54 -07:00
|
|
|
______r; \
|
|
|
|
}))
|
|
|
|
#endif /* CONFIG_PROFILE_ALL_BRANCHES */
|
|
|
|
|
2008-11-11 22:14:39 -07:00
|
|
|
#else
|
|
|
|
# define likely(x) __builtin_expect(!!(x), 1)
|
|
|
|
# define unlikely(x) __builtin_expect(!!(x), 0)
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Optimization barrier */
|
|
|
|
#ifndef barrier
|
|
|
|
# define barrier() __memory_barrier()
|
|
|
|
#endif
|
|
|
|
|
2009-12-04 18:44:50 -07:00
|
|
|
/* Unreachable code */
|
|
|
|
#ifndef unreachable
|
|
|
|
# define unreachable() do { } while (1)
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifndef RELOC_HIDE
|
|
|
|
# define RELOC_HIDE(ptr, off) \
|
|
|
|
({ unsigned long __ptr; \
|
|
|
|
__ptr = (unsigned long) (ptr); \
|
|
|
|
(typeof(ptr)) (__ptr + (off)); })
|
|
|
|
#endif
|
|
|
|
|
2013-11-25 17:00:41 -07:00
|
|
|
#ifndef OPTIMIZER_HIDE_VAR
|
|
|
|
#define OPTIMIZER_HIDE_VAR(var) barrier()
|
|
|
|
#endif
|
|
|
|
|
2012-11-21 19:00:25 -07:00
|
|
|
/* Not-quite-unique ID. */
|
|
|
|
#ifndef __UNIQUE_ID
|
|
|
|
# define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
2006-05-02 03:41:25 -06:00
|
|
|
#ifdef __KERNEL__
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Allow us to mark functions as 'deprecated' and have gcc emit a nice
|
|
|
|
* warning for each use, in hopes of speeding the functions removal.
|
|
|
|
* Usage is:
|
|
|
|
* int __deprecated foo(void)
|
|
|
|
*/
|
|
|
|
#ifndef __deprecated
|
|
|
|
# define __deprecated /* unimplemented */
|
|
|
|
#endif
|
|
|
|
|
2005-05-01 09:59:03 -06:00
|
|
|
#ifdef MODULE
|
|
|
|
#define __deprecated_for_modules __deprecated
|
|
|
|
#else
|
|
|
|
#define __deprecated_for_modules
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifndef __must_check
|
|
|
|
#define __must_check
|
|
|
|
#endif
|
|
|
|
|
2006-08-14 23:43:18 -06:00
|
|
|
#ifndef CONFIG_ENABLE_MUST_CHECK
|
|
|
|
#undef __must_check
|
|
|
|
#define __must_check
|
|
|
|
#endif
|
2007-10-25 02:06:13 -06:00
|
|
|
#ifndef CONFIG_ENABLE_WARN_DEPRECATED
|
|
|
|
#undef __deprecated
|
|
|
|
#undef __deprecated_for_modules
|
|
|
|
#define __deprecated
|
|
|
|
#define __deprecated_for_modules
|
|
|
|
#endif
|
2006-08-14 23:43:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Allow us to avoid 'defined but not used' warnings on functions and data,
|
|
|
|
* as well as force them to be emitted to the assembly file.
|
|
|
|
*
|
2007-05-09 03:35:27 -06:00
|
|
|
* As of gcc 3.4, static functions that are not marked with attribute((used))
|
|
|
|
* may be elided from the assembly file. As of gcc 3.4, static data not so
|
2005-04-16 16:20:36 -06:00
|
|
|
* marked will not be elided, but this may change in a future gcc version.
|
|
|
|
*
|
2007-05-09 03:35:27 -06:00
|
|
|
* NOTE: Because distributions shipped with a backported unit-at-a-time
|
|
|
|
* compiler in gcc 3.3, we must define __used to be __attribute__((used))
|
|
|
|
* for gcc >=3.3 instead of 3.4.
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* In prior versions of gcc, such functions and data would be emitted, but
|
|
|
|
* would be warned about except with attribute((unused)).
|
2007-05-09 03:35:27 -06:00
|
|
|
*
|
|
|
|
* Mark functions that are referenced only in inline assembly as __used so
|
|
|
|
* the code is emitted even though it appears to be unreferenced.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-05-09 03:35:27 -06:00
|
|
|
#ifndef __used
|
|
|
|
# define __used /* unimplemented */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef __maybe_unused
|
|
|
|
# define __maybe_unused /* unimplemented */
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2009-11-01 17:50:52 -07:00
|
|
|
#ifndef __always_unused
|
|
|
|
# define __always_unused /* unimplemented */
|
|
|
|
#endif
|
|
|
|
|
2006-05-03 17:41:02 -06:00
|
|
|
#ifndef noinline
|
|
|
|
#define noinline
|
|
|
|
#endif
|
|
|
|
|
2008-03-04 15:28:40 -07:00
|
|
|
/*
|
|
|
|
* Rather then using noinline to prevent stack consumption, use
|
2012-02-23 05:42:30 -07:00
|
|
|
* noinline_for_stack instead. For documentation reasons.
|
2008-03-04 15:28:40 -07:00
|
|
|
*/
|
|
|
|
#define noinline_for_stack noinline
|
|
|
|
|
2006-05-03 17:41:02 -06:00
|
|
|
#ifndef __always_inline
|
|
|
|
#define __always_inline inline
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* From the GCC manual:
|
|
|
|
*
|
|
|
|
* Many functions do not examine any values except their arguments,
|
|
|
|
* and have no effects except the return value. Basically this is
|
|
|
|
* just slightly more strict class than the `pure' attribute above,
|
|
|
|
* since function is not allowed to read global memory.
|
|
|
|
*
|
|
|
|
* Note that a function that has pointer arguments and examines the
|
|
|
|
* data pointed to must _not_ be declared `const'. Likewise, a
|
|
|
|
* function that calls a non-`const' function usually must not be
|
|
|
|
* `const'. It does not make sense for a `const' function to return
|
|
|
|
* `void'.
|
|
|
|
*/
|
|
|
|
#ifndef __attribute_const__
|
|
|
|
# define __attribute_const__ /* unimplemented */
|
|
|
|
#endif
|
|
|
|
|
2007-07-21 09:10:00 -06:00
|
|
|
/*
|
|
|
|
* Tell gcc if a function is cold. The compiler will assume any path
|
|
|
|
* directly leading to the call is unlikely.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __cold
|
|
|
|
#define __cold
|
|
|
|
#endif
|
|
|
|
|
2008-01-20 10:54:48 -07:00
|
|
|
/* Simple shorthand for a section definition */
|
|
|
|
#ifndef __section
|
|
|
|
# define __section(S) __attribute__ ((__section__(#S)))
|
|
|
|
#endif
|
|
|
|
|
2012-09-17 15:09:15 -06:00
|
|
|
#ifndef __visible
|
|
|
|
#define __visible
|
|
|
|
#endif
|
|
|
|
|
2009-06-12 21:46:56 -06:00
|
|
|
/* Are two types/vars the same type (ignoring qualifiers)? */
|
|
|
|
#ifndef __same_type
|
|
|
|
# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
|
|
|
|
#endif
|
|
|
|
|
2013-11-06 06:57:36 -07:00
|
|
|
/* Is this type a native word size -- useful for atomic operations */
|
|
|
|
#ifndef __native_word
|
|
|
|
# define __native_word(t) (sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
|
|
|
|
#endif
|
|
|
|
|
2009-09-26 06:33:01 -06:00
|
|
|
/* Compile time object size, -1 for unknown */
|
|
|
|
#ifndef __compiletime_object_size
|
|
|
|
# define __compiletime_object_size(obj) -1
|
|
|
|
#endif
|
2009-09-30 05:05:23 -06:00
|
|
|
#ifndef __compiletime_warning
|
|
|
|
# define __compiletime_warning(message)
|
|
|
|
#endif
|
2009-10-02 08:50:50 -06:00
|
|
|
#ifndef __compiletime_error
|
|
|
|
# define __compiletime_error(message)
|
compiler.h, bug.h: prevent double error messages with BUILD_BUG{,_ON}
Prior to the introduction of __attribute__((error("msg"))) in gcc 4.3,
creating compile-time errors required a little trickery.
BUILD_BUG{,_ON} uses this attribute when available to generate
compile-time errors, but also uses the negative-sized array trick for
older compilers, resulting in two error messages in some cases. The
reason it's "some" cases is that as of gcc 4.4, the negative-sized array
will not create an error in some situations, like inline functions.
This patch replaces the negative-sized array code with the new
__compiletime_error_fallback() macro which expands to the same thing
unless the the error attribute is available, in which case it expands to
do{}while(0), resulting in exactly one compile-time error on all
versions of gcc.
Note that we are not changing the negative-sized array code for the
unoptimized version of BUILD_BUG_ON, since it has the potential to catch
problems that would be disabled in later versions of gcc were
__compiletime_error_fallback used. The reason is that that an
unoptimized build can't always remove calls to an error-attributed
function call (like we are using) that should effectively become dead
code if it were optimized. However, using a negative-sized array with a
similar value will not result in an false-positive (error). The only
caveat being that it will also fail to catch valid conditions, which we
should be expecting in an unoptimized build anyway.
Signed-off-by: Daniel Santos <daniel.santos@pobox.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Joe Perches <joe@perches.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-21 17:41:54 -07:00
|
|
|
# define __compiletime_error_fallback(condition) \
|
bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG
Introduce compiletime_assert to compiler.h, which moves the details of
how to break a build and emit an error message for a specific compiler
to the headers where these details should be. Following in the
tradition of the POSIX assert macro, compiletime_assert creates a
build-time error when the supplied condition is *false*.
Next, we add BUILD_BUG_ON_MSG to bug.h which simply wraps
compiletime_assert, inverting the logic, so that it fails when the
condition is *true*, consistent with the language "build bug on." This
macro allows you to specify the error message you want emitted when the
supplied condition is true.
Finally, we remove all other code from bug.h that mucks with these
details (BUILD_BUG & BUILD_BUG_ON), and have them all call
BUILD_BUG_ON_MSG. This not only reduces source code bloat, but also
prevents the possibility of code being changed for one macro and not for
the other (which was previously the case for BUILD_BUG and
BUILD_BUG_ON).
Since __compiletime_error_fallback is now only used in compiler.h, I'm
considering it a private macro and removing the double negation that's
now extraneous.
[akpm@linux-foundation.org: checkpatch fixes]
Signed-off-by: Daniel Santos <daniel.santos@pobox.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Joe Perches <joe@perches.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-21 17:41:55 -07:00
|
|
|
do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
|
compiler.h, bug.h: prevent double error messages with BUILD_BUG{,_ON}
Prior to the introduction of __attribute__((error("msg"))) in gcc 4.3,
creating compile-time errors required a little trickery.
BUILD_BUG{,_ON} uses this attribute when available to generate
compile-time errors, but also uses the negative-sized array trick for
older compilers, resulting in two error messages in some cases. The
reason it's "some" cases is that as of gcc 4.4, the negative-sized array
will not create an error in some situations, like inline functions.
This patch replaces the negative-sized array code with the new
__compiletime_error_fallback() macro which expands to the same thing
unless the the error attribute is available, in which case it expands to
do{}while(0), resulting in exactly one compile-time error on all
versions of gcc.
Note that we are not changing the negative-sized array code for the
unoptimized version of BUILD_BUG_ON, since it has the potential to catch
problems that would be disabled in later versions of gcc were
__compiletime_error_fallback used. The reason is that that an
unoptimized build can't always remove calls to an error-attributed
function call (like we are using) that should effectively become dead
code if it were optimized. However, using a negative-sized array with a
similar value will not result in an false-positive (error). The only
caveat being that it will also fail to catch valid conditions, which we
should be expecting in an unoptimized build anyway.
Signed-off-by: Daniel Santos <daniel.santos@pobox.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Joe Perches <joe@perches.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-21 17:41:54 -07:00
|
|
|
#else
|
|
|
|
# define __compiletime_error_fallback(condition) do { } while (0)
|
2009-10-02 08:50:50 -06:00
|
|
|
#endif
|
compiler.h, bug.h: prevent double error messages with BUILD_BUG{,_ON}
Prior to the introduction of __attribute__((error("msg"))) in gcc 4.3,
creating compile-time errors required a little trickery.
BUILD_BUG{,_ON} uses this attribute when available to generate
compile-time errors, but also uses the negative-sized array trick for
older compilers, resulting in two error messages in some cases. The
reason it's "some" cases is that as of gcc 4.4, the negative-sized array
will not create an error in some situations, like inline functions.
This patch replaces the negative-sized array code with the new
__compiletime_error_fallback() macro which expands to the same thing
unless the the error attribute is available, in which case it expands to
do{}while(0), resulting in exactly one compile-time error on all
versions of gcc.
Note that we are not changing the negative-sized array code for the
unoptimized version of BUILD_BUG_ON, since it has the potential to catch
problems that would be disabled in later versions of gcc were
__compiletime_error_fallback used. The reason is that that an
unoptimized build can't always remove calls to an error-attributed
function call (like we are using) that should effectively become dead
code if it were optimized. However, using a negative-sized array with a
similar value will not result in an false-positive (error). The only
caveat being that it will also fail to catch valid conditions, which we
should be expecting in an unoptimized build anyway.
Signed-off-by: Daniel Santos <daniel.santos@pobox.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Joe Perches <joe@perches.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-21 17:41:54 -07:00
|
|
|
|
bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG
Introduce compiletime_assert to compiler.h, which moves the details of
how to break a build and emit an error message for a specific compiler
to the headers where these details should be. Following in the
tradition of the POSIX assert macro, compiletime_assert creates a
build-time error when the supplied condition is *false*.
Next, we add BUILD_BUG_ON_MSG to bug.h which simply wraps
compiletime_assert, inverting the logic, so that it fails when the
condition is *true*, consistent with the language "build bug on." This
macro allows you to specify the error message you want emitted when the
supplied condition is true.
Finally, we remove all other code from bug.h that mucks with these
details (BUILD_BUG & BUILD_BUG_ON), and have them all call
BUILD_BUG_ON_MSG. This not only reduces source code bloat, but also
prevents the possibility of code being changed for one macro and not for
the other (which was previously the case for BUILD_BUG and
BUILD_BUG_ON).
Since __compiletime_error_fallback is now only used in compiler.h, I'm
considering it a private macro and removing the double negation that's
now extraneous.
[akpm@linux-foundation.org: checkpatch fixes]
Signed-off-by: Daniel Santos <daniel.santos@pobox.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Joe Perches <joe@perches.com>
Cc: Josh Triplett <josh@joshtriplett.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-21 17:41:55 -07:00
|
|
|
#define __compiletime_assert(condition, msg, prefix, suffix) \
|
|
|
|
do { \
|
|
|
|
bool __cond = !(condition); \
|
|
|
|
extern void prefix ## suffix(void) __compiletime_error(msg); \
|
|
|
|
if (__cond) \
|
|
|
|
prefix ## suffix(); \
|
|
|
|
__compiletime_error_fallback(__cond); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define _compiletime_assert(condition, msg, prefix, suffix) \
|
|
|
|
__compiletime_assert(condition, msg, prefix, suffix)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* compiletime_assert - break build and emit msg if condition is false
|
|
|
|
* @condition: a compile-time constant condition to check
|
|
|
|
* @msg: a message to emit if condition is false
|
|
|
|
*
|
|
|
|
* In tradition of POSIX assert, this macro will break the build if the
|
|
|
|
* supplied condition is *false*, emitting the supplied error message if the
|
|
|
|
* compiler has support to do so.
|
|
|
|
*/
|
|
|
|
#define compiletime_assert(condition, msg) \
|
|
|
|
_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
|
|
|
|
|
2013-11-06 06:57:36 -07:00
|
|
|
#define compiletime_assert_atomic_type(t) \
|
|
|
|
compiletime_assert(__native_word(t), \
|
|
|
|
"Need native word sized stores/loads for atomicity.")
|
|
|
|
|
2008-05-10 20:51:16 -06:00
|
|
|
/*
|
|
|
|
* Prevent the compiler from merging or refetching accesses. The compiler
|
|
|
|
* is also forbidden from reordering successive instances of ACCESS_ONCE(),
|
|
|
|
* but only when the compiler is aware of some particular ordering. One way
|
|
|
|
* to make the compiler aware of ordering is to put the two invocations of
|
|
|
|
* ACCESS_ONCE() in different C statements.
|
|
|
|
*
|
|
|
|
* This macro does absolutely -nothing- to prevent the CPU from reordering,
|
2008-08-17 13:50:36 -06:00
|
|
|
* merging, or refetching absolutely anything at any time. Its main intended
|
|
|
|
* use is to mediate communication between process-level code and irq/NMI
|
|
|
|
* handlers, all running on the same CPU.
|
2008-05-10 20:51:16 -06:00
|
|
|
*/
|
|
|
|
#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
|
|
|
|
|
2013-04-04 04:40:50 -06:00
|
|
|
/* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
|
|
|
|
#ifdef CONFIG_KPROBES
|
|
|
|
# define __kprobes __attribute__((__section__(".kprobes.text")))
|
|
|
|
#else
|
|
|
|
# define __kprobes
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* __LINUX_COMPILER_H */
|