This is an automated email from the ASF dual-hosted git repository. xiaoxiang781216 pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/nuttx.git
commit 0e52f1da3bd11a44055574c3c075ba164b88aedf Author: wangzhi16 <[email protected]> AuthorDate: Wed Jun 11 22:10:19 2025 +0800 include/nuttx: fix compile error. Convert umul64_const() and div64_const32() from macros to static inline functions. The old macros expanded LOG2_FLOOR() at every use site and produced enormous tokens (see e.g. nxglib/nxglib_setpixel_1bpp.c), which made the compiler disable column-tracking and fail with -Wmisleading-indentation errors. umul64_const() now returns the 64-bit result instead of assigning it through an output parameter. It has no callers outside math32.h. Assisted-By: mimo-v2.6-pro Co-authored-by: ouyangxiangzhen <[email protected]> Signed-off-by: wangzhi16 <[email protected]> Signed-off-by: ouyangxiangzhen <[email protected]> --- include/nuttx/lib/math32.h | 228 +++++++++++++++++++++++---------------------- 1 file changed, 115 insertions(+), 113 deletions(-) diff --git a/include/nuttx/lib/math32.h b/include/nuttx/lib/math32.h index c1b7e79ed5e..1832013141c 100644 --- a/include/nuttx/lib/math32.h +++ b/include/nuttx/lib/math32.h @@ -195,125 +195,127 @@ extern "C" /* Default C implementation for umul64_const() * - * Prototype: uint64_t umul64_const(uint64_t retval, uint64_t m, - * uint64_t n, bool bias); - * Semantic: retval = ((bias ? m : 0) + m * n) >> 64 + * Prototype: uint64_t umul64_const(uint64_t m, uint64_t n, int bias); + * Semantic: return ((bias ? m : 0) + m * n) >> 64 * * The product is a 128-bit value, scaled down to 64 bits. * Assuming constant propagation to optimize away unused conditional code. * Architectures may provide their own optimized assembly implementation. */ -# ifdef up_umul64_const -# define umul64_const(res, m, n, bias) \ - (res) = up_umul64_const(m, n, bias) -# else -# define umul64_const(res, m, n, bias) \ - do \ - { \ - uint32_t __m_lo = (m) & 0xffffffff; \ - uint32_t __m_hi = (m) >> 32; \ - uint32_t __n_lo = (n) & 0xffffffff; \ - uint32_t __n_hi = (n) >> 32; \ - uint32_t __res_lo; \ - uint32_t __res_hi; \ - uint32_t __tmp; \ - \ - if (!(bias)) \ - { \ - (res) = ((uint64_t)__m_lo * __n_lo) >> 32; \ - } \ - else if (!((m) & ((1ULL << 63) | (1ULL << 31)))) \ - { \ - (res) = ((m) + (uint64_t)__m_lo * __n_lo) >> 32; \ - } \ - else \ - { \ - (res) = (m) + (uint64_t)__m_lo * __n_lo; \ - __res_lo = (res) >> 32; \ - __res_hi = (__res_lo < __m_hi); \ - (res) = __res_lo | ((uint64_t)__res_hi << 32); \ - } \ - \ - if (!((m) & ((1ULL << 63) | (1ULL << 31)))) \ - { \ - (res) += (uint64_t)__m_lo * __n_hi; \ - (res) += (uint64_t)__m_hi * __n_lo; \ - (res) >>= 32; \ - } \ - else \ - { \ - (res) += (uint64_t)__m_lo * __n_hi; \ - __tmp = (res) >> 32; \ - (res) += (uint64_t)__m_hi * __n_lo; \ - __res_lo = (res) >> 32; \ - __res_hi = (__res_lo < __tmp); \ - (res) = __res_lo | ((uint64_t)__res_hi << 32); \ - } \ - \ - (res) += (uint64_t)__m_hi * __n_hi; \ - } \ - while (0) -# endif +/* Due to compilation issues, use inline functions instead of macros. */ -# define div64_const32(n, b) \ - do \ - { \ - uint64_t ___res; \ - uint64_t ___x; \ - uint64_t ___t; \ - uint64_t ___m; \ - uint64_t ___n = (n); \ - uint32_t ___p; \ - uint32_t ___bias; \ - uint32_t ___b = (b); \ - ___p = 1 << LOG2_FLOOR(___b); \ - ___m = (~0ULL / ___b) * ___p; \ - ___m += (((~0ULL % ___b + 1) * ___p) + ___b - 1) / ___b; \ - ___x = ~0ULL / ___b * ___b - 1; \ - ___res = ((___m & 0xffffffff) * (___x & 0xffffffff)) >> 32; \ - ___t = ___res += (___m & 0xffffffff) * (___x >> 32); \ - ___res += (___x & 0xffffffff) * (___m >> 32); \ - ___t = (___res < ___t) ? (1ULL << 32) : 0; \ - ___res = (___res >> 32) + ___t; \ - ___res += (___m >> 32) * (___x >> 32); \ - ___res /= ___p; \ - if (~0ULL % (___b / (___b & -___b)) == 0) \ - { \ - ___n /= (___b & -___b); \ - ___m = ~0ULL / (___b / (___b & -___b)); \ - ___p = 1; \ - ___bias = 1; \ - } \ - else if (___res != ___x / ___b) \ - { \ - ___bias = 1; \ - ___m = (~0ULL / ___b) * ___p; \ - ___m += ((~0ULL % ___b + 1) * ___p) / ___b; \ - } \ - else \ - { \ - uint32_t ___bits = -(___m & -___m); \ - ___bits |= ___m >> 32; \ - ___bits = (~___bits) << 1; \ - if (!___bits) \ - { \ - ___p /= (___m & -___m); \ - ___m /= (___m & -___m); \ - } \ - else \ - { \ - ___p >>= LOG2_FLOOR(___bits); \ - ___m >>= LOG2_FLOOR(___bits); \ - } \ - ___bias = 0; \ - } \ - umul64_const(___res, ___m, ___n, ___bias); \ - \ - ___res /= ___p; \ - (n) = ___res; \ - } \ - while (0) +#ifdef up_umul64_const +# define umul64_const(m, n, bias) up_umul64_const(m, n, bias) +#else +static inline_function uint64_t umul64_const(uint64_t m, uint64_t n, + int bias) +{ + uint32_t m_lo = (m) & 0xffffffff; + uint32_t m_hi = (m) >> 32; + uint32_t n_lo = (n) & 0xffffffff; + uint32_t n_hi = (n) >> 32; + uint32_t res_lo; + uint32_t res_hi; + uint32_t tmp; + uint64_t res; + + if (!(bias)) + { + res = ((uint64_t)m_lo * n_lo) >> 32; + } + else if (!((m) & ((1ULL << 63) | (1ULL << 31)))) + { + res = ((m) + (uint64_t)m_lo * n_lo) >> 32; + } + else + { + res = (m) + (uint64_t)m_lo * n_lo; + res_lo = res >> 32; + res_hi = (res_lo < m_hi); + res = res_lo | ((uint64_t)res_hi << 32); + } + + if (!((m) & ((1ULL << 63) | (1ULL << 31)))) + { + res += (uint64_t)m_lo * n_hi; + res += (uint64_t)m_hi * n_lo; + res >>= 32; + } + else + { + res += (uint64_t)m_lo * n_hi; + tmp = res >> 32; + res += (uint64_t)m_hi * n_lo; + res_lo = res >> 32; + res_hi = (res_lo < tmp); + res = res_lo | ((uint64_t)res_hi << 32); + } + + res += (uint64_t)m_hi * n_hi; + + return res; +} +#endif + +static inline_function uint64_t div64_const32(uint64_t n, uint32_t b) +{ + uint64_t res; + uint64_t x; + uint64_t t; + uint64_t m; + uint32_t p; + uint32_t bias; + + p = 1 << LOG2_FLOOR(b); + m = (~0ULL / b) * p; + m += (((~0ULL % b + 1) * p) + b - 1) / b; + x = ~0ULL / b * b - 1; + res = ((m & 0xffffffff) * (x & 0xffffffff)) >> 32; + t = res += (m & 0xffffffff) * (x >> 32); + res += (x & 0xffffffff) * (m >> 32); + t = (res < t) ? (1ULL << 32) : 0; + res = (res >> 32) + t; + res += (m >> 32) * (x >> 32); + res /= p; + + if (~0ULL % (b / (b & -b)) == 0) + { + n /= (b & -b); + m = ~0ULL / (b / (b & -b)); + p = 1; + bias = 1; + } + else if (res != x / b) + { + bias = 1; + m = (~0ULL / b) * p; + m += ((~0ULL % b + 1) * p) / b; + } + else + { + uint32_t bits = -(m & -m); + bits |= m >> 32; + bits = (~bits) << 1; + if (!bits) + { + p /= (m & -m); + m /= (m & -m); + } + else + { + p >>= LOG2_FLOOR(bits); + m >>= LOG2_FLOOR(bits); + } + + bias = 0; + } + + res = umul64_const(m, n, bias); + res /= p; + + return res; +} static inline_function uint64_t div64_const(uint64_t n, uint32_t base) { @@ -323,7 +325,7 @@ static inline_function uint64_t div64_const(uint64_t n, uint32_t base) } else if (UINTPTR_MAX == UINT32_MAX) { - div64_const32(n, base); + n = div64_const32(n, base); } else {
