RE: [PATCH] perf/x86/amd/power: Use div64_u64 onstead of do_div()

[David Laight <David.Laight@ACULAB.COM>]

From: Linus Torvalds
> Sent: 03 May 2024 00:00
> 
> On Thu, 2 May 2024 at 15:19, David Laight <David.Laight@aculab.com> wrote:
> >
> > Somewhen it must have got changed from a simple asm wrapper for divl.
> 
> It's never been a simple wrapper for divl. For the simple reason that
> 'divl' doesn't do a full 64/32 divide returning a full 64-bit result.

I'd thought (before I'd looked) that it only returned a 32bit result.
After all that is what a lot of code wants.

I was thinking of something like (see https://godbolt.org/z/h8oj7h4sd):

#define divu(a, b) ({ \
    u64 _a = a, _b = b, _q; \
    u32 _alo = _a, _blo = _b; \
    u32 _ahi = _a >> 32, _bhi = _b >> 32; \
    if (_bhi) { \
        _q = div64(_a, _b); \
    } else { \
        u32 _qhi = 0; \
        if (_ahi >= _blo) { \
            _qhi = _ahi / _blo; \
            _ahi = _ahi % _blo; \
        } \
        asm( "divl %2" : "+a" (_alo), "+d" (_ahi) : "r" (_blo)); \
        asm( "" : "=A" (_q) : "a" (_alo), "d" (_qhi)); \
    } \
    _q; \
})

Which will call out for a large divisor, but will do inlined divides
otherwise - so is reasonably sane whatever the types (even 32 by 32).
Modern gcc/clang also tracks values (to some extent) so will detect
_ahi and _bhi being compile-time zero even if the types are 64bit.

I've ignored the remainder for clarity.
But I'd add a 'u64 *rem' parameter and do a compile-time NULL check.

Fortunately the kernel doesn't let gcc use the xmm regsiters.
It has a nasty habit of bloating the code by trying to use them
for 64bit integers.

	David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
Registration No: 1397386 (Wales)