GCC提供的几个內建函数

参考

https://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Other-Builtins.html#Other-Builtins

https://en.wikipedia.org/wiki/Find_first_set#CTZ

Tool/library	Name	Type	Input type(s)	Notes	Result for zero input
POSIX.1 compliant libc 4.3BSD libc OS X 10.3 libc^[2]^[21]	`ffs`	Library function	int	Includes glibc. POSIX does not supply the complementary log base 2 / clz.	0
FreeBSD 5.3 libc OS X 10.4 libc^[22]	`ffsl` `fls` `flsl`	Library function	int, long	fls ("find last set") computes (log base 2) + 1.	0
FreeBSD 7.1 libc^[23]	`ffsll` `flsll`	Library function	long long		0
GCC	`__builtin_ffs[l,ll,imax]`	Built-in functions	unsigned int, unsigned long, unsigned long long, uintmax_t		0
GCC 3.4.0^[24]^[25] Clang 5.x ^[26]^[27]	`__builtin_clz[l,ll,imax]` `__builtin_ctz[l,ll,imax]`	Built-in functions			undefined
Visual Studio 2005	`_BitScanForward`^[28] `_BitScanReverse`^[29]	Compiler intrinsics	unsigned long, unsigned __int64	Separate return value to indicate zero input	0
Visual Studio 2008	`__lzcnt`^[30]	Compiler intrinsic	unsigned short, unsigned int, unsigned __int64	Relies on x64-only lzcnt instruction	Input size in bits
Intel C++ Compiler	`_bit_scan_forward` `_bit_scan_reverse`^[31]	Compiler intrinsics	int		undefined
NVIDIA CUDA^[32]	`__clz`	Functions	32-bit, 64-bit	Compiles to fewer instructions on the GeForce 400 Series	32
NVIDIA CUDA^[32]	`__ffs`	Functions	32-bit, 64-bit	Compiles to fewer instructions on the GeForce 400 Series	0
LLVM	`llvm.ctlz.` `llvm.cttz.`^[33]	Intrinsic	8, 16, 32, 64, 256	LLVM assembly language	Input size if arg 2 is 0, else undefined
GHC 7.10 (base 4.8), in `Data.Bits`	`countLeadingZeros` `countTrailingZeros`	Library function	`FiniteBits b => b`	Haskell programming language	Input size in bits

— Built-in Function: int __builtin_ffs (unsigned int x)

　　Returns one plus the index of the least significant 1-bit of x, or if x is zero, returns zero.

　　右起第一个1的位置

— Built-in Function: int __builtin_clz (unsigned int x)

　　Returns the number of leading 0-bits in x, starting at the most significant bit position. If x is 0, the result is undefined.

　　左起0的个数

— Built-in Function: int __builtin_ctz (unsigned int x)

　　Returns the number of trailing 0-bits in x, starting at the least significant bit position. If x is 0, the result is undefined。

　　右起0的个数

— Built-in Function: int __builtin_popcount (unsigned int x)

　　Returns the number of 1-bits in x.

　　x中1的个数

— Built-in Function: int __builtin_parity (unsigned int x)

　　Returns the parity of x, i.e. the number of 1-bits in x modulo 2.

　　x中1的个数的奇偶

上面函数都有long，long long版本[-l, -ll]。按上面表格看，也有-imax（eg, -i32 for uint32_t）

— Built-in Function: int32_t __builtin_bswap32 (int32_t x)

翻转32位数各字节

Returns x with the order of the bytes reversed; for example, 0xaabbccdd becomes 0xddccbbaa. Byte here always means exactly 8 bits.

— Built-in Function: int64_t __builtin_bswap64 (int64_t x)

翻转64位数各字节

Similar to __builtin_bswap32, except the argument and return types are 64-bit.

— Built-in Function: long __builtin_expect (long exp, long c)

分支预测

You may use __builtin_expect to provide the compiler with branch prediction information. In general, you should prefer to use actual profile feedback for this (-fprofile-arcs), as programmers are notoriously bad at predicting how their programs actually perform. However, there are applications in which this data is hard to collect.

The return value is the value of exp, which should be an integral expression. The semantics of the built-in are that it is expected that exp == c. For example:
          if (__builtin_expect (x, 0))
            foo ();
     
would indicate that we do not expect to call foo, since we expect x to be zero. Since you are limited to integral expressions for exp, you should use constructions such as
          if (__builtin_expect (ptr != NULL, 1))
            error ();
     
when testing pointer or floating-point values.

— Built-in Function: void __builtin_prefetch (const void *addr, ...)

预取

This function is used to minimize cache-miss latency by moving data into a cache before it is accessed. You can insert calls to __builtin_prefetch into code for which you know addresses of data in memory that is likely to be accessed soon. If the target supports them, data prefetch instructions will be generated. If the prefetch is done early enough before the access then the data will be in the cache by the time it is accessed.

The value of addr is the address of the memory to prefetch. There are two optional arguments, rw and locality. The value of rw is a compile-time constant one or zero; one means that the prefetch is preparing for a write to the memory address and zero, the default, means that the prefetch is preparing for a read. The value locality must be a compile-time constant integer between zero and three. A value of zero means that the data has no temporal locality, so it need not be left in the cache after the access. A value of three means that the data has a high degree of temporal locality and should be left in all levels of cache possible. Values of one and two mean, respectively, a low or moderate degree of temporal locality. The default is three.
          for (i = 0; i < n; i++)
            {
              a[i] = a[i] + b[i];
              __builtin_prefetch (&a[i+j], 1, 1);
              __builtin_prefetch (&b[i+j], 0, 1);
              /* ... */
            }
     
Data prefetch does not generate faults if addr is invalid, but the address expression itself must be valid. For example, a prefetch of p->next will not fault if p->next is not a valid address, but evaluation will fault if p is not a valid address.

If the target does not support data prefetch, the address expression is evaluated if it includes side effects but no other code is generated and GCC does not issue a warning.

__builtin_return_address(LEVEL)

—This function returns the return address of the current function,or of one of its callers. The LEVEL argument is number of frames to scan up the call stack. A value of ‘0’ yields the return address of the current function,a value of ‘1’ yields the return address of the caller of the current function,and so forth.

__builtin_alloca (https://linux.die.net/man/3/alloca)

alloca - allocate memory that is automatically freed
Synopsis
#include <alloca.h>
void *alloca(size_t size);

Description
The alloca() function allocates size bytes of space in the stack frame of the caller. This temporary space is automatically freed when the function that called alloca() returns to its caller.
Return Value

The alloca() function returns a pointer to the beginning of the allocated space. If the allocation causes stack overflow, program behavior is undefined.
Conforming to
This function is not in POSIX.1-2001.
There is evidence that the alloca() function appeared in 32V, PWB, PWB.2, 3BSD, and 4BSD. There is a man page for it in 4.3BSD. Linux uses the GNU version.

Notes
The alloca() function is machine- and compiler-dependent. For certain applications, its use can improve efficiency compared to the use of malloc(3) plus free(3). In certain cases, it can also simplify memory deallocation in applications that use longjmp(3) or siglongjmp(3). Otherwise, its use is discouraged.
Because the space allocated by alloca() is allocated within the stack frame, that space is automatically freed if the function return is jumped over by a call to longjmp(3) or siglongjmp(3).

Do not attempt to free(3) space allocated by alloca()!

Notes on the GNU version
Normally, gcc(1) translates calls to alloca() with inlined code. This is not done when either the -ansi, -std=c89, -std=c99, or the -fno-builtin option is given (and the header <alloca.h> is not included). But beware! By default the glibc version of <stdlib.h> includes <alloca.h> and that contains the line:
#define alloca(size)   __builtin_alloca (size)
with messy consequences if one has a private version of this function.
The fact that the code is inlined means that it is impossible to take the address of this function, or to change its behavior by linking with a different library.

The inlined code often consists of a single instruction adjusting the stack pointer, and does not check for stack overflow. Thus, there is no NULL error return.