FM / asm-generic

/usr/src/linux-headers-5.15.0-181/include/asm-generic/

/usr/src/linux-headers-5.15.0-181/include/asm-generic

Name	Size	Mode	Actions
bitops/	-	0755	rm
vdso/	-	0755	rm
asm-offsets.h	35	0644	edit dl rm
asm-prototypes.h	507	0644	edit dl rm
atomic.h	3569	0644	edit dl rm
atomic64.h	2549	0644	edit dl rm
audit_change_attr.h	484	0644	edit dl rm
audit_dir_write.h	528	0644	edit dl rm
audit_read.h	241	0644	edit dl rm
audit_signal.h	36	0644	edit dl rm
audit_write.h	461	0644	edit dl rm
barrier.h	6518	0644	edit dl rm
bitops.h	1197	0644	edit dl rm
bitsperlong.h	1207	0644	edit dl rm
bug.h	6939	0644	edit dl rm
cache.h	384	0644	edit dl rm
cacheflush.h	2401	0644	edit dl rm
checksum.h	1634	0644	edit dl rm
cmpxchg-local.h	1464	0644	edit dl rm
cmpxchg.h	2440	0644	edit dl rm
compat.h	1190	0644	edit dl rm
current.h	256	0644	edit dl rm
delay.h	1157	0644	edit dl rm
device.h	245	0644	edit dl rm
div64.h	7437	0644	edit dl rm
dma-mapping.h	248	0644	edit dl rm
dma.h	553	0644	edit dl rm
early_ioremap.h	1501	0644	edit dl rm
emergency-restart.h	248	0644	edit dl rm
error-injection.h	1162	0644	edit dl rm
exec.h	460	0644	edit dl rm
export.h	2344	0644	edit dl rm
extable.h	802	0644	edit dl rm
fb.h	271	0644	edit dl rm
fixmap.h	2932	0644	edit dl rm
flat.h	610	0644	edit dl rm
ftrace.h	314	0644	edit dl rm
futex.h	2669	0644	edit dl rm
getorder.h	1262	0644	edit dl rm
gpio.h	4537	0644	edit dl rm
hardirq.h	568	0644	edit dl rm
hugetlb.h	3030	0644	edit dl rm
hw_irq.h	270	0644	edit dl rm
hyperv-tlfs.h	19828	0644	edit dl rm
ide_iops.h	791	0644	edit dl rm
int-ll64.h	863	0644	edit dl rm
io.h	23436	0644	edit dl rm
ioctl.h	506	0644	edit dl rm
iomap.h	4019	0644	edit dl rm
irq.h	403	0644	edit dl rm
irqflags.h	1543	0644	edit dl rm
irq_regs.h	773	0644	edit dl rm
irq_work.h	194	0644	edit dl rm
Kbuild	1643	0644	edit dl rm
kdebug.h	182	0644	edit dl rm
kmap_size.h	263	0644	edit dl rm
kprobes.h	833	0644	edit dl rm
kvm_para.h	549	0644	edit dl rm
kvm_types.h	113	0644	edit dl rm
linkage.h	225	0644	edit dl rm
local.h	2282	0644	edit dl rm
local64.h	3887	0644	edit dl rm
logic_io.h	2402	0644	edit dl rm
mcs_spinlock.h	260	0644	edit dl rm
memory_model.h	1441	0644	edit dl rm
mmiowb.h	1764	0644	edit dl rm
mmiowb_types.h	249	0644	edit dl rm
mmu.h	449	0644	edit dl rm
mmu_context.h	1654	0644	edit dl rm
mm_hooks.h	753	0644	edit dl rm
module.h	1118	0644	edit dl rm
module.lds.h	278	0644	edit dl rm
mshyperv.h	7727	0644	edit dl rm
msi.h	1053	0644	edit dl rm
nommu_context.h	420	0644	edit dl rm
numa.h	1642	0644	edit dl rm
page.h	2351	0644	edit dl rm
param.h	367	0644	edit dl rm
parport.h	604	0644	edit dl rm
pci.h	401	0644	edit dl rm
pci_iomap.h	1920	0644	edit dl rm
percpu.h	12957	0644	edit dl rm
pgalloc.h	4747	0644	edit dl rm
pgtable-nop4d.h	1758	0644	edit dl rm
pgtable-nopmd.h	1980	0644	edit dl rm
pgtable-nopud.h	1995	0644	edit dl rm
pgtable_uffd.h	1052	0644	edit dl rm
preempt.h	1995	0644	edit dl rm
qrwlock.h	3859	0644	edit dl rm
qrwlock_types.h	682	0644	edit dl rm
qspinlock.h	3354	0644	edit dl rm
qspinlock_types.h	2134	0644	edit dl rm
resource.h	1100	0644	edit dl rm
rwonce.h	2932	0644	edit dl rm
seccomp.h	1187	0644	edit dl rm
sections.h	6104	0644	edit dl rm
serial.h	345	0644	edit dl rm
set_memory.h	362	0644	edit dl rm
shmparam.h	207	0644	edit dl rm
signal.h	308	0644	edit dl rm
simd.h	436	0644	edit dl rm
softirq_stack.h	286	0644	edit dl rm
spinlock.h	329	0644	edit dl rm
statfs.h	169	0644	edit dl rm
string.h	281	0644	edit dl rm
switch_to.h	755	0644	edit dl rm
syscall.h	5735	0644	edit dl rm
syscalls.h	739	0644	edit dl rm
termios-base.h	2164	0644	edit dl rm
termios.h	2877	0644	edit dl rm
timex.h	508	0644	edit dl rm
tlb.h	19264	0644	edit dl rm
tlbflush.h	485	0644	edit dl rm
topology.h	2219	0644	edit dl rm
trace_clock.h	391	0644	edit dl rm
uaccess.h	6508	0644	edit dl rm
unaligned.h	2886	0644	edit dl rm
user.h	242	0644	edit dl rm
vermagic.h	179	0644	edit dl rm
vga.h	587	0644	edit dl rm
vmlinux.lds.h	32881	0644	edit dl rm
vtime.h	52	0644	edit dl rm
word-at-a-time.h	2826	0644	edit dl rm
xor.h	13560	0644	edit dl rm

Edit: /usr/src/linux-headers-5.15.0-181/include/asm-generic/div64.h (7437B)

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_GENERIC_DIV64_H
#define _ASM_GENERIC_DIV64_H
/*
 * Copyright (C) 2003 Bernardo Innocenti <bernie@develer.com>
 * Based on former asm-ppc/div64.h and asm-m68knommu/div64.h
 *
 * Optimization for constant divisors on 32-bit machines:
 * Copyright (C) 2006-2015 Nicolas Pitre
 *
 * The semantics of do_div() is, in C++ notation, observing that the name
 * is a function-like macro and the n parameter has the semantics of a C++
 * reference:
 *
 * uint32_t do_div(uint64_t &n, uint32_t base)
 * {
 * 	uint32_t remainder = n % base;
 * 	n = n / base;
 * 	return remainder;
 * }
 *
 * NOTE: macro parameter n is evaluated multiple times,
 *       beware of side effects!
 */

#include <linux/types.h>
#include <linux/compiler.h>

#if BITS_PER_LONG == 64

/**
 * do_div - returns 2 values: calculate remainder and update new dividend
 * @n: uint64_t dividend (will be updated)
 * @base: uint32_t divisor
 *
 * Summary:
 * ``uint32_t remainder = n % base;``
 * ``n = n / base;``
 *
 * Return: (uint32_t)remainder
 *
 * NOTE: macro parameter @n is evaluated multiple times,
 * beware of side effects!
 */
# define do_div(n,base) ({					\
	uint32_t __base = (base);				\
	uint32_t __rem;						\
	__rem = ((uint64_t)(n)) % __base;			\
	(n) = ((uint64_t)(n)) / __base;				\
	__rem;							\
 })

#elif BITS_PER_LONG == 32

#include <linux/log2.h>

/*
 * If the divisor happens to be constant, we determine the appropriate
 * inverse at compile time to turn the division into a few inline
 * multiplications which ought to be much faster.
 *
 * (It is unfortunate that gcc doesn't perform all this internally.)
 */

#define __div64_const32(n, ___b)					\
({									\
	/*								\
	 * Multiplication by reciprocal of b: n / b = n * (p / b) / p	\
	 *								\
	 * We rely on the fact that most of this code gets optimized	\
	 * away at compile time due to constant propagation and only	\
	 * a few multiplication instructions should remain.		\
	 * Hence this monstrous macro (static inline doesn't always	\
	 * do the trick here).						\
	 */								\
	uint64_t ___res, ___x, ___t, ___m, ___n = (n);			\
	uint32_t ___p, ___bias;						\
									\
	/* determine MSB of b */					\
	___p = 1 << ilog2(___b);					\
									\
	/* compute m = ((p << 64) + b - 1) / b */			\
	___m = (~0ULL / ___b) * ___p;					\
	___m += (((~0ULL % ___b + 1) * ___p) + ___b - 1) / ___b;	\
									\
	/* one less than the dividend with highest result */		\
	___x = ~0ULL / ___b * ___b - 1;					\
									\
	/* test our ___m with res = m * x / (p << 64) */		\
	___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;							\
									\
	/* Now sanitize and optimize what we've got. */			\
	if (~0ULL % (___b / (___b & -___b)) == 0) {			\
		/* special case, can be simplified to ... */		\
		___n /= (___b & -___b);					\
		___m = ~0ULL / (___b / (___b & -___b));			\
		___p = 1;						\
		___bias = 1;						\
	} else if (___res != ___x / ___b) {				\
		/*							\
		 * We can't get away without a bias to compensate	\
		 * for bit truncation errors.  To avoid it we'd need an	\
		 * additional bit to represent m which would overflow	\
		 * a 64-bit variable.					\
		 *							\
		 * Instead we do m = p / b and n / b = (n * m + m) / p.	\
		 */							\
		___bias = 1;						\
		/* Compute m = (p << 64) / b */				\
		___m = (~0ULL / ___b) * ___p;				\
		___m += ((~0ULL % ___b + 1) * ___p) / ___b;		\
	} else {							\
		/*							\
		 * Reduce m / p, and try to clear bit 31 of m when	\
		 * possible, otherwise that'll need extra overflow	\
		 * handling later.					\
		 */							\
		uint32_t ___bits = -(___m & -___m);			\
		___bits |= ___m >> 32;					\
		___bits = (~___bits) << 1;				\
		/*							\
		 * If ___bits == 0 then setting bit 31 is  unavoidable.	\
		 * Simply apply the maximum possible reduction in that	\
		 * case. Otherwise the MSB of ___bits indicates the	\
		 * best reduction we should apply.			\
		 */							\
		if (!___bits) {						\
			___p /= (___m & -___m);				\
			___m /= (___m & -___m);				\
		} else {						\
			___p >>= ilog2(___bits);			\
			___m >>= ilog2(___bits);			\
		}							\
		/* No bias needed. */					\
		___bias = 0;						\
	}								\
									\
	/*								\
	 * Now we have a combination of 2 conditions:			\
	 *								\
	 * 1) whether or not we need to apply a bias, and		\
	 *								\
	 * 2) whether or not there might be an overflow in the cross	\
	 *    product determined by (___m & ((1 << 63) | (1 << 31))).	\
	 *								\
	 * Select the best way to do (m_bias + m * n) / (1 << 64).	\
	 * From now on there will be actual runtime code generated.	\
	 */								\
	___res = __arch_xprod_64(___m, ___n, ___bias);			\
									\
	___res /= ___p;							\
})

#ifndef __arch_xprod_64
/*
 * Default C implementation for __arch_xprod_64()
 *
 * Prototype: uint64_t __arch_xprod_64(const uint64_t m, uint64_t n, bool bias)
 * Semantic:  retval = ((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.
 */
static inline uint64_t __arch_xprod_64(const uint64_t m, uint64_t n, bool bias)
{
	uint32_t m_lo = m;
	uint32_t m_hi = m >> 32;
	uint32_t n_lo = n;
	uint32_t n_hi = n >> 32;
	uint64_t res;
	uint32_t res_lo, res_hi, tmp;

if (!bias) {
		res = ((uint64_t)m_lo * n_lo) >> 32;
	} else if (!(m & ((1ULL << 63) | (1ULL << 31)))) {
		/* there can't be any overflow here */
		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)))) {
		/* there can't be any overflow here */
		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

#ifndef __div64_32
extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
#endif

/* The unnecessary pointer compare is there
 * to check for type safety (n must be 64bit)
 */
# define do_div(n,base) ({				\
	uint32_t __base = (base);			\
	uint32_t __rem;					\
	(void)(((typeof((n)) *)0) == ((uint64_t *)0));	\
	if (__builtin_constant_p(__base) &&		\
	    is_power_of_2(__base)) {			\
		__rem = (n) & (__base - 1);		\
		(n) >>= ilog2(__base);			\
	} else if (__builtin_constant_p(__base) &&	\
		   __base != 0) {			\
		uint32_t __res_lo, __n_lo = (n);	\
		(n) = __div64_const32(n, __base);	\
		/* the remainder can be computed with 32-bit regs */ \
		__res_lo = (n);				\
		__rem = __n_lo - __res_lo * __base;	\
	} else if (likely(((n) >> 32) == 0)) {		\
		__rem = (uint32_t)(n) % __base;		\
		(n) = (uint32_t)(n) / __base;		\
	} else {					\
		__rem = __div64_32(&(n), __base);	\
	}						\
	__rem;						\
 })

#else /* BITS_PER_LONG == ?? */

# error do_div() does not yet support the C64

#endif /* BITS_PER_LONG */

#endif /* _ASM_GENERIC_DIV64_H */

cmd: