RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-03-02 17:41:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
c0e2ff202b
haproxy/include/common/compiler.h

204 lines
6.3 KiB
C
Raw Normal View History

[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
/*
* include/common/compiler.h
* This files contains some compiler-specific settings.
*
* Copyright (C) 2000-2009 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
CLEANUP: ebtree: clarify licence and update to 6.0.6 (from ebtree 6.0.6) This version is mainly aimed at clarifying the fact that the ebtree license is LGPL. Some files used to indicate LGPL and other ones GPL, while the goal clearly is to have it LGPL. A LICENSE file has also been added. No code is affected, but it's better to have the local tree in sync anyway. (cherry picked from commit 24dc7cca051f081600fe8232f33e55ed30e88425)
2011-07-25 09:38:17 +00:00
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
*/
#ifndef _COMMON_COMPILER_H
#define _COMMON_COMPILER_H
/*
* Gcc before 3.0 needs [0] to declare a variable-size array
*/
#ifndef VAR_ARRAY
#if __GNUC__ < 3
#define VAR_ARRAY 0
#else
#define VAR_ARRAY
#endif
#endif
/* By default, gcc does not inline large chunks of code, but we want it to
* respect our choices.
*/
#if !defined(forceinline)
#if __GNUC__ < 3
#define forceinline inline
#else
#define forceinline inline __attribute__((always_inline))
#endif
#endif
BUILD: compiler: add a new type modifier __maybe_unused While gcc only emits warnings about unused static functions, Clang also emits such a warning when the functions are inlined. This is a bit annoying at certain places where functions are provided to manipulate multiple data types and are not yet used. Let's have a type modifier "__maybe_unused" which sets the "unused" attribute like the Linux kernel does. It's elegant as it allows the code author to indicate that it knows that this element might be unused. It works on variables as well, which is convenient to remove ifdefs around local variables in certain functions, but doesn't work on labels.
2017-11-20 20:22:17 +00:00
/* silence the "unused" warnings without having to place painful #ifdefs.
* For use with variables or functions.
*/
#define __maybe_unused __attribute__((unused))
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
BUILD: compiler: add a new statement "__unreachable()" This statement is used as a hint for the compiler so that it knows that the location where it's placed cannot be reached. It will mostly be used after longjmp() or equivalent statements that deal with error processing and that the compiler doesn't know will not return on certain conditions, so that it doesn't complain about null dereferences on error paths.
2018-10-15 09:53:34 +00:00
/* This allows gcc to know that some locations are never reached, for example
* after a longjmp() in the Lua code, hence that some errors caught by such
* methods cannot propagate further. This is important with gcc versions 6 and
* above which can more aggressively detect null dereferences. The builtin
* below was introduced in gcc 4.5, and before it we didn't care.
*/
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
BUILD: compiler: rename __unreachable() to my_unreachable() Olivier reported that on FreeBSD __unreachable is already defined and causes build warnings. Let's rename it then.
2018-10-20 15:45:48 +00:00
#define my_unreachable() __builtin_unreachable()
BUILD: compiler: add a new statement "__unreachable()" This statement is used as a hint for the compiler so that it knows that the location where it's placed cannot be reached. It will mostly be used after longjmp() or equivalent statements that deal with error processing and that the compiler doesn't know will not return on certain conditions, so that it doesn't complain about null dereferences on error paths.
2018-10-15 09:53:34 +00:00
#else
BUILD: compiler: rename __unreachable() to my_unreachable() Olivier reported that on FreeBSD __unreachable is already defined and causes build warnings. Let's rename it then.
2018-10-20 15:45:48 +00:00
#define my_unreachable()
BUILD: compiler: add a new statement "__unreachable()" This statement is used as a hint for the compiler so that it knows that the location where it's placed cannot be reached. It will mostly be used after longjmp() or equivalent statements that deal with error processing and that the compiler doesn't know will not return on certain conditions, so that it doesn't complain about null dereferences on error paths.
2018-10-15 09:53:34 +00:00
#endif
MINOR: compiler: add a new macro ALREADY_CHECKED() This macro may be used to block constant propagation that lets the compiler detect a possible NULL dereference on a variable resulting from an explicit assignment in an impossible check. Sometimes a function is called which does safety checks and returns NULL if safe conditions are not met. The place where it's called cannot hit this condition and dereferencing the pointer without first checking it will make the compiler emit a warning about a "potential null pointer dereference" which is hard to work around. This macro "washes" the pointer and prevents the compiler from emitting tests branching to undefined instructions. It may only be used when the developer is absolutely certain that the conditions are guaranteed and that the pointer passed in argument cannot be NULL by design. A typical use case is a top-level function doing this : if (frame->type == HEADERS) parse_frame(frame); Then parse_frame() does this : void parse_frame(struct frame *frame) { const char *frame_hdr; frame_hdr = frame_hdr_start(frame); if (*frame_hdr == FRAME_HDR_BEGIN) process_frame(frame); } and : const char *frame_hdr_start(const struct frame *frame) { if (frame->type == HEADERS) return frame->data; else return NULL; } Above parse_frame() is only called for frame->type == HEADERS so it will never get a NULL in return from frame_hdr_start(). Thus it's always safe to dereference *frame_hdr since the check was already performed above. It's then safe to address it this way instead of inventing dummy error code paths that may create real bugs : void parse_frame(struct frame *frame) { const char *frame_hdr; frame_hdr = frame_hdr_start(frame); ALREADY_CHECKED(frame_hdr); if (*frame_hdr == FRAME_HDR_BEGIN) process_frame(frame); }
2018-12-08 14:20:43 +00:00
/* This macro may be used to block constant propagation that lets the compiler
* detect a possible NULL dereference on a variable resulting from an explicit
* assignment in an impossible check. Sometimes a function is called which does
* safety checks and returns NULL if safe conditions are not met. The place
* where it's called cannot hit this condition and dereferencing the pointer
* without first checking it will make the compiler emit a warning about a
* "potential null pointer dereference" which is hard to work around. This
* macro "washes" the pointer and prevents the compiler from emitting tests
* branching to undefined instructions. It may only be used when the developer
* is absolutely certain that the conditions are guaranteed and that the
* pointer passed in argument cannot be NULL by design.
*/
#define ALREADY_CHECKED(p) do { asm("" : "=rm"(p) : "0"(p)); } while (0)
MINOR: debug: add a new DISGUISE() macro to pass a value as identity This does exactly the same as ALREADY_CHECKED() but does it inline, returning an identical copy of the scalar variable without letting the compiler know how it might have been transformed. This can forcefully disable certain null-pointer checks or result checks when known undesirable. Typically forcing a crash with *(DISGUISE(NULL))=0 will not cause a null-deref warning.
2020-03-14 09:42:26 +00:00
/* same as above but to be used to pass the input value to the output but
* without letting the compiler know about its initial properties.
*/
#define DISGUISE(v) ({ typeof(v) __v = (v); ALREADY_CHECKED(__v); __v; })
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
/*
MINOR: compiler: drop special cases of likely/unlikely for older compilers We used to special-case the likely()/unlikely() macros for a series of early gcc 4.x compilers which used to produce very bad code when using __builtin_expect(x,1), which basically used to build an integer (0 or 1) from a condition then compare it to integer 1. This was already fixed in 5.x, but even now, looking at the code produced by various flavors of 4.x this bad behavior couldn't be witnessed anymore. So let's consider it as fixed by now, which will allow to get rid of some ugly tricks at some specific places. A test on 4.7.4 shows that the code shrinks by about 3kB now, thanks to some tests being inlined closer to the call place and the unlikely case being moved to real functions. See the link below for more background on this. Link: https://www.mail-archive.com/haproxy@formilux.org/msg36392.html
2020-02-25 06:14:43 +00:00
* Gcc >= 3 provides the ability for the program to give hints to the
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
* compiler about what branch of an if is most likely to be taken. This
* helps the compiler produce the most compact critical paths, which is
* generally better for the cache and to reduce the number of jumps.
*/
#if !defined(likely)
#if __GNUC__ < 3
#define __builtin_expect(x,y) (x)
#define likely(x) (x)
#define unlikely(x) (x)
MINOR: compiler: drop special cases of likely/unlikely for older compilers We used to special-case the likely()/unlikely() macros for a series of early gcc 4.x compilers which used to produce very bad code when using __builtin_expect(x,1), which basically used to build an integer (0 or 1) from a condition then compare it to integer 1. This was already fixed in 5.x, but even now, looking at the code produced by various flavors of 4.x this bad behavior couldn't be witnessed anymore. So let's consider it as fixed by now, which will allow to get rid of some ugly tricks at some specific places. A test on 4.7.4 shows that the code shrinks by about 3kB now, thanks to some tests being inlined closer to the call place and the unlikely case being moved to real functions. See the link below for more background on this. Link: https://www.mail-archive.com/haproxy@formilux.org/msg36392.html
2020-02-25 06:14:43 +00:00
#else
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
#define likely(x) (__builtin_expect((x) != 0, 1))
#define unlikely(x) (__builtin_expect((x) != 0, 0))
#endif
#endif
MINOR: compiler: introduce offsetoff(). Add a offsetof() macro, if it is no there already.
2018-01-24 17:17:06 +00:00
#ifndef __GNUC_PREREQ__
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
#define __GNUC_PREREQ__(ma, mi) \
(__GNUC__ > (ma) || __GNUC__ == (ma) && __GNUC_MINOR__ >= (mi))
#else
#define __GNUC_PREREQ__(ma, mi) 0
#endif
#endif
#ifndef offsetof
#if __GNUC_PREREQ__(4, 1)
#define offsetof(type, field) __builtin_offsetof(type, field)
#else
#define offsetof(type, field) \
BUILD/MINOR: compiler: fix offsetof() on older compilers An offsetof() macro was introduced with commit 928fbfa ("MINOR: compiler: introduce offsetoff().") with a fallback for older compilers. But this breaks gcc 3.4 because __size_t and __uintptr_t are not defined there. However size_t and uintptr_t are, so let's fix it this way. No backport needed.
2018-07-30 09:47:35 +00:00
((size_t)(uintptr_t)((const volatile void *)&((type *)0)->field))
MINOR: compiler: introduce offsetoff(). Add a offsetof() macro, if it is no there already.
2018-01-24 17:17:06 +00:00
#endif
#endif
MINOR: compiler: move CPU capabilities definition from config.h and complete them These ones are irrelevant to the config but rather to the platform, and as such are better placed in compiler.h. Here we take the opportunity for declaring a few extra capabilities: - HA_UNALIGNED : CPU supports unaligned accesses - HA_UNALIGNED_LE : CPU supports unaligned accesses in little endian - HA_UNALIGNED_FAST : CPU supports fast unaligned accesses - HA_UNALIGNED_ATOMIC : CPU supports unaligned accesses in atomics This will help remove a number of #ifdefs with arch-specific statements.
2020-02-21 14:40:58 +00:00
/* Some architectures have a double-word CAS, sometimes even dual-8 bytes.
* Some architectures support unaligned accesses, others are fine with them
* but only for non-atomic operations. Also mention those supporting unaligned
* accesses and being little endian, and those where unaligned accesses are
* known to be fast (almost as fast as aligned ones).
*/
#if defined(__x86_64__)
#define HA_UNALIGNED
#define HA_UNALIGNED_LE
#define HA_UNALIGNED_LE64
#define HA_UNALIGNED_FAST
#define HA_UNALIGNED_ATOMIC
#define HA_HAVE_CAS_DW
#define HA_CAS_IS_8B
#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__)
#define HA_UNALIGNED
#define HA_UNALIGNED_LE
#define HA_UNALIGNED_ATOMIC
#elif defined (__aarch64__) || defined(__ARM_ARCH_8A)
#define HA_UNALIGNED
#define HA_UNALIGNED_LE
#define HA_UNALIGNED_LE64
#define HA_UNALIGNED_FAST
#define HA_HAVE_CAS_DW
#define HA_CAS_IS_8B
#elif defined(__arm__) && (defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__))
#define HA_UNALIGNED
#define HA_UNALIGNED_LE
#define HA_UNALIGNED_FAST
#define HA_HAVE_CAS_DW
#endif
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
MINOR: compiler: add new alignment macros This commit adds ALWAYS_ALIGN(), MAYBE_ALIGN() and ATOMIC_ALIGN() to be placed as delimitors inside structures to force alignment to a given size. These depend on the architecture's capabilities so that it is possible to always align, align only on archs not supporting unaligned accesses at all, or only on those not supporting them for atomic accesses (e.g. before a lock).
2020-02-22 14:51:39 +00:00
/* sets alignment for current field or variable */
#ifndef ALIGNED
#define ALIGNED(x) __attribute__((aligned(x)))
#endif
/* sets alignment only on architectures preventing unaligned atomic accesses */
#ifndef MAYBE_ALIGNED
#ifndef HA_UNALIGNED
#define MAYBE_ALIGNED(x) ALIGNED(x)
#else
#define MAYBE_ALIGNED(x)
#endif
#endif
/* sets alignment only on architectures preventing unaligned atomic accesses */
#ifndef ATOMIC_ALIGNED
#ifndef HA_UNALIGNED_ATOMIC
#define ATOMIC_ALIGNED(x) ALIGNED(x)
#else
#define ATOMIC_ALIGNED(x)
#endif
#endif
/* add a mandatory alignment for next fields in a structure */
#ifndef ALWAYS_ALIGN
#define ALWAYS_ALIGN(x) union { } ALIGNED(x)
#endif
/* add an optional alignment for next fields in a structure, only for archs
* which do not support unaligned accesses.
*/
#ifndef MAYBE_ALIGN
#ifndef HA_UNALIGNED
#define MAYBE_ALIGN(x) union { } ALIGNED(x)
#else
#define MAYBE_ALIGN(x)
#endif
#endif
/* add an optional alignment for next fields in a structure, only for archs
* which do not support unaligned accesses for atomic operations.
*/
#ifndef ATOMIC_ALIGN
#ifndef HA_UNALIGNED_ATOMIC
#define ATOMIC_ALIGN(x) union { } ALIGNED(x)
#else
#define ATOMIC_ALIGN(x)
#endif
#endif
[BUG] definitely fix regparm issues between haproxy core and ebtree It's a pain to enable regparm because ebtree is built in its corner and does not depend on the rest of the config. This causes no problem except that if the regparm settings are not exactly similar, then we can get inconsistent function interfaces and crashes. One solution realized in this patch consists in externalizing all compiler settings and changing CONFIG_XXX_REGPARM into CONFIG_REGPARM so that we ensure that any sub-component uses the same setting. Since ebtree used a value here and not a boolean, haproxy's config has been set to use a number too. Both haproxy's core and ebtree currently use the same copy of the compiler.h file. That way we don't have any issue anymore when one setting changes somewhere.
2009-10-27 20:40:18 +00:00
#endif /* _COMMON_COMPILER_H */
Reference in New Issue Copy Permalink