~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/include/asm/div64.h

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /arch/x86/include/asm/div64.h (Architecture sparc) and /arch/alpha/include/asm-alpha/div64.h (Architecture alpha)


  1 /* SPDX-License-Identifier: GPL-2.0 */              1 
  2 #ifndef _ASM_X86_DIV64_H                          
  3 #define _ASM_X86_DIV64_H                          
  4                                                   
  5 #ifdef CONFIG_X86_32                              
  6                                                   
  7 #include <linux/types.h>                          
  8 #include <linux/log2.h>                           
  9                                                   
 10 /*                                                
 11  * do_div() is NOT a C function. It wants to r    
 12  * two values (the quotient and the remainder)    
 13  * since that doesn't work very well in C, wha    
 14  * does is:                                       
 15  *                                                
 16  * - modifies the 64-bit dividend _in_place_      
 17  * - returns the 32-bit remainder                 
 18  *                                                
 19  * This ends up being the most efficient "call    
 20  * convention" on x86.                            
 21  */                                               
 22 #define do_div(n, base)                           
 23 ({                                                
 24         unsigned long __upper, __low, __high,     
 25         __base = (base);                          
 26         if (__builtin_constant_p(__base) && is    
 27                 __mod = n & (__base - 1);         
 28                 n >>= ilog2(__base);              
 29         } else {                                  
 30                 asm("" : "=a" (__low), "=d" (_    
 31                 __upper = __high;                 
 32                 if (__high) {                     
 33                         __upper = __high % (__    
 34                         __high = __high / (__b    
 35                 }                                 
 36                 asm("divl %2" : "=a" (__low),     
 37                         : "rm" (__base), "" (_    
 38                 asm("" : "=A" (n) : "a" (__low    
 39         }                                         
 40         __mod;                                    
 41 })                                                
 42                                                   
 43 static inline u64 div_u64_rem(u64 dividend, u3    
 44 {                                                 
 45         union {                                   
 46                 u64 v64;                          
 47                 u32 v32[2];                       
 48         } d = { dividend };                       
 49         u32 upper;                                
 50                                                   
 51         upper = d.v32[1];                         
 52         d.v32[1] = 0;                             
 53         if (upper >= divisor) {                   
 54                 d.v32[1] = upper / divisor;       
 55                 upper %= divisor;                 
 56         }                                         
 57         asm ("divl %2" : "=a" (d.v32[0]), "=d"    
 58                 "rm" (divisor), "" (d.v32[0]),    
 59         return d.v64;                             
 60 }                                                 
 61 #define div_u64_rem     div_u64_rem               
 62                                                   
 63 static inline u64 mul_u32_u32(u32 a, u32 b)       
 64 {                                                 
 65         u32 high, low;                            
 66                                                   
 67         asm ("mull %[b]" : "=a" (low), "=d" (h    
 68                          : [a] "a" (a), [b] "r    
 69                                                   
 70         return low | ((u64)high) << 32;           
 71 }                                                 
 72 #define mul_u32_u32 mul_u32_u32                   
 73                                                   
 74 /*                                                
 75  * __div64_32() is never called on x86, so pre    
 76  * generic definition from getting built.         
 77  */                                               
 78 #define __div64_32                                
 79                                                   
 80 #else                                             
 81 # include <asm-generic/div64.h>                   
 82                                                   
 83 /*                                                
 84  * Will generate an #DE when the result doesn'    
 85  * __ex_table[] entry when it becomes an issue    
 86  */                                               
 87 static inline u64 mul_u64_u64_div_u64(u64 a, u    
 88 {                                                 
 89         u64 q;                                    
 90                                                   
 91         asm ("mulq %2; divq %3" : "=a" (q)        
 92                                 : "a" (a), "rm    
 93                                 : "rdx");         
 94                                                   
 95         return q;                                 
 96 }                                                 
 97 #define mul_u64_u64_div_u64 mul_u64_u64_div_u6    
 98                                                   
 99 static inline u64 mul_u64_u32_div(u64 a, u32 m    
100 {                                                 
101         return mul_u64_u64_div_u64(a, mul, div    
102 }                                                 
103 #define mul_u64_u32_div mul_u64_u32_div           
104                                                   
105 #endif /* CONFIG_X86_32 */                        
106                                                   
107 #endif /* _ASM_X86_DIV64_H */                     
108                                                   

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php