Branch data     Line data    Source code

       1                 :            : /* tnum: tracked (or tristate) numbers
       2                 :            :  *
       3                 :            :  * A tnum tracks knowledge about the bits of a value.  Each bit can be either
       4                 :            :  * known (0 or 1), or unknown (x).  Arithmetic operations on tnums will
       5                 :            :  * propagate the unknown bits such that the tnum result represents all the
       6                 :            :  * possible results for possible values of the operands.
       7                 :            :  */
       8                 :            : 
       9                 :            : #ifndef _LINUX_TNUM_H
      10                 :            : #define _LINUX_TNUM_H
      11                 :            : 
      12                 :            : #include <linux/types.h>
      13                 :            : 
      14                 :            : struct tnum {
      15                 :            :         u64 value;
      16                 :            :         u64 mask;
      17                 :            : };
      18                 :            : 
      19                 :            : /* Constructors */
      20                 :            : /* Represent a known constant as a tnum. */
      21                 :            : struct tnum tnum_const(u64 value);
      22                 :            : /* A completely unknown value */
      23                 :            : extern const struct tnum tnum_unknown;
      24                 :            : /* A value that's unknown except that @min <= value <= @max */
      25                 :            : struct tnum tnum_range(u64 min, u64 max);
      26                 :            : 
      27                 :            : /* Arithmetic and logical ops */
      28                 :            : /* Shift a tnum left (by a fixed shift) */
      29                 :            : struct tnum tnum_lshift(struct tnum a, u8 shift);
      30                 :            : /* Shift (rsh) a tnum right (by a fixed shift) */
      31                 :            : struct tnum tnum_rshift(struct tnum a, u8 shift);
      32                 :            : /* Shift (arsh) a tnum right (by a fixed min_shift) */
      33                 :            : struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness);
      34                 :            : /* Add two tnums, return @a + @b */
      35                 :            : struct tnum tnum_add(struct tnum a, struct tnum b);
      36                 :            : /* Subtract two tnums, return @a - @b */
      37                 :            : struct tnum tnum_sub(struct tnum a, struct tnum b);
      38                 :            : /* Bitwise-AND, return @a & @b */
      39                 :            : struct tnum tnum_and(struct tnum a, struct tnum b);
      40                 :            : /* Bitwise-OR, return @a | @b */
      41                 :            : struct tnum tnum_or(struct tnum a, struct tnum b);
      42                 :            : /* Bitwise-XOR, return @a ^ @b */
      43                 :            : struct tnum tnum_xor(struct tnum a, struct tnum b);
      44                 :            : /* Multiply two tnums, return @a * @b */
      45                 :            : struct tnum tnum_mul(struct tnum a, struct tnum b);
      46                 :            : 
      47                 :            : /* Return a tnum representing numbers satisfying both @a and @b */
      48                 :            : struct tnum tnum_intersect(struct tnum a, struct tnum b);
      49                 :            : 
      50                 :            : /* Return @a with all but the lowest @size bytes cleared */
      51                 :            : struct tnum tnum_cast(struct tnum a, u8 size);
      52                 :            : 
      53                 :            : /* Returns true if @a is a known constant */
      54                 :            : static inline bool tnum_is_const(struct tnum a)
      55                 :            : {
      56                 :      14544 :         return !a.mask;
      57                 :            : }
      58                 :            : 
      59                 :            : /* Returns true if @a == tnum_const(@b) */
      60                 :            : static inline bool tnum_equals_const(struct tnum a, u64 b)
      61                 :            : {
      62   [ +  -  -  +  :      24240 :         return tnum_is_const(a) && a.value == b;
          #  #  #  #  +  
          -  +  +  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      63                 :            : }
      64                 :            : 
      65                 :            : /* Returns true if @a is completely unknown */
      66                 :            : static inline bool tnum_is_unknown(struct tnum a)
      67                 :            : {
      68                 :            :         return !~a.mask;
      69                 :            : }
      70                 :            : 
      71                 :            : /* Returns true if @a is known to be a multiple of @size.
      72                 :            :  * @size must be a power of two.
      73                 :            :  */
      74                 :            : bool tnum_is_aligned(struct tnum a, u64 size);
      75                 :            : 
      76                 :            : /* Returns true if @b represents a subset of @a. */
      77                 :            : bool tnum_in(struct tnum a, struct tnum b);
      78                 :            : 
      79                 :            : /* Formatting functions.  These have snprintf-like semantics: they will write
      80                 :            :  * up to @size bytes (including the terminating NUL byte), and return the number
      81                 :            :  * of bytes (excluding the terminating NUL) which would have been written had
      82                 :            :  * sufficient space been available.  (Thus tnum_sbin always returns 64.)
      83                 :            :  */
      84                 :            : /* Format a tnum as a pair of hex numbers (value; mask) */
      85                 :            : int tnum_strn(char *str, size_t size, struct tnum a);
      86                 :            : /* Format a tnum as tristate binary expansion */
      87                 :            : int tnum_sbin(char *str, size_t size, struct tnum a);
      88                 :            : 
      89                 :            : #endif /* _LINUX_TNUM_H */