1 /* 2 * Copyright (c) 2016-2018, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #ifndef UTILS_DEF_H 8 #define UTILS_DEF_H 9 10 /* Compute the number of elements in the given array */ 11 #define ARRAY_SIZE(a) \ 12 (sizeof(a) / sizeof((a)[0])) 13 14 #define IS_POWER_OF_TWO(x) \ 15 (((x) & ((x) - 1)) == 0) 16 17 #define SIZE_FROM_LOG2_WORDS(n) (4 << (n)) 18 19 #define BIT_32(nr) (U(1) << (nr)) 20 #define BIT_64(nr) (ULL(1) << (nr)) 21 22 #ifdef AARCH32 23 #define BIT BIT_32 24 #else 25 #define BIT BIT_64 26 #endif 27 28 /* 29 * Create a contiguous bitmask starting at bit position @l and ending at 30 * position @h. For example 31 * GENMASK_64(39, 21) gives us the 64bit vector 0x000000ffffe00000. 32 */ 33 #define GENMASK_32(h, l) \ 34 (((~UINT32_C(0)) << (l)) & (~UINT32_C(0) >> (32 - 1 - (h)))) 35 36 #define GENMASK_64(h, l) \ 37 (((~UINT64_C(0)) << (l)) & (~UINT64_C(0) >> (64 - 1 - (h)))) 38 39 #ifdef AARCH32 40 #define GENMASK GENMASK_32 41 #else 42 #define GENMASK GENMASK_64 43 #endif 44 45 /* 46 * This variant of div_round_up can be used in macro definition but should not 47 * be used in C code as the `div` parameter is evaluated twice. 48 */ 49 #define DIV_ROUND_UP_2EVAL(n, d) (((n) + (d) - 1) / (d)) 50 51 #define div_round_up(val, div) __extension__ ({ \ 52 __typeof__(div) _div = (div); \ 53 ((val) + _div - (__typeof__(div)) 1) / _div; \ 54 }) 55 56 #define MIN(x, y) __extension__ ({ \ 57 __typeof__(x) _x = (x); \ 58 __typeof__(y) _y = (y); \ 59 (void)(&_x == &_y); \ 60 _x < _y ? _x : _y; \ 61 }) 62 63 #define MAX(x, y) __extension__ ({ \ 64 __typeof__(x) _x = (x); \ 65 __typeof__(y) _y = (y); \ 66 (void)(&_x == &_y); \ 67 _x > _y ? _x : _y; \ 68 }) 69 70 /* 71 * The round_up() macro rounds up a value to the given boundary in a 72 * type-agnostic yet type-safe manner. The boundary must be a power of two. 73 * In other words, it computes the smallest multiple of boundary which is 74 * greater than or equal to value. 75 * 76 * round_down() is similar but rounds the value down instead. 77 */ 78 #define round_boundary(value, boundary) \ 79 ((__typeof__(value))((boundary) - 1)) 80 81 #define round_up(value, boundary) \ 82 ((((value) - 1) | round_boundary(value, boundary)) + 1) 83 84 #define round_down(value, boundary) \ 85 ((value) & ~round_boundary(value, boundary)) 86 87 /* 88 * Evaluates to 1 if (ptr + inc) overflows, 0 otherwise. 89 * Both arguments must be unsigned pointer values (i.e. uintptr_t). 90 */ 91 #define check_uptr_overflow(_ptr, _inc) \ 92 ((_ptr) > (UINTPTR_MAX - (_inc))) 93 94 /* 95 * Evaluates to 1 if (u32 + inc) overflows, 0 otherwise. 96 * Both arguments must be 32-bit unsigned integers (i.e. effectively uint32_t). 97 */ 98 #define check_u32_overflow(_u32, _inc) \ 99 ((_u32) > (UINT32_MAX - (_inc))) 100 101 /* 102 * For those constants to be shared between C and other sources, apply a 'U', 103 * 'UL', 'ULL', 'L' or 'LL' suffix to the argument only in C, to avoid 104 * undefined or unintended behaviour. 105 * 106 * The GNU assembler and linker do not support these suffixes (it causes the 107 * build process to fail) therefore the suffix is omitted when used in linker 108 * scripts and assembler files. 109 */ 110 #if defined(__LINKER__) || defined(__ASSEMBLY__) 111 # define U(_x) (_x) 112 # define UL(_x) (_x) 113 # define ULL(_x) (_x) 114 # define L(_x) (_x) 115 # define LL(_x) (_x) 116 #else 117 # define U(_x) (_x##U) 118 # define UL(_x) (_x##UL) 119 # define ULL(_x) (_x##ULL) 120 # define L(_x) (_x##L) 121 # define LL(_x) (_x##LL) 122 #endif 123 124 /* Register size of the current architecture. */ 125 #ifdef AARCH32 126 #define REGSZ U(4) 127 #else 128 #define REGSZ U(8) 129 #endif 130 131 /* 132 * Test for the current architecture version to be at least the version 133 * expected. 134 */ 135 #define ARM_ARCH_AT_LEAST(_maj, _min) \ 136 ((ARM_ARCH_MAJOR > (_maj)) || \ 137 ((ARM_ARCH_MAJOR == (_maj)) && (ARM_ARCH_MINOR >= (_min)))) 138 139 /* 140 * Import an assembly or linker symbol as a C expression with the specified 141 * type 142 */ 143 #define IMPORT_SYM(type, sym, name) \ 144 extern char sym[];\ 145 static const __attribute__((unused)) type name = (type) sym; 146 147 /* 148 * When the symbol is used to hold a pointer, its alignment can be asserted 149 * with this macro. For example, if there is a linker symbol that is going to 150 * be used as a 64-bit pointer, the value of the linker symbol must also be 151 * aligned to 64 bit. This macro makes sure this is the case. 152 */ 153 #define ASSERT_SYM_PTR_ALIGN(sym) assert(((size_t)(sym) % __alignof__(*(sym))) == 0) 154 155 156 #endif /* UTILS_DEF_H */ 157