Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
14struct tnum {
15 u64 value;
16 u64 mask;
17};
18
19/* Constructors */
20/* Represent a known constant as a tnum. */
21struct tnum tnum_const(u64 value);
22/* A completely unknown value */
23extern const struct tnum tnum_unknown;
24/* An unknown value that is a superset of @min <= value <= @max.
25 *
26 * Could include values outside the range of [@min, @max].
27 * For example tnum_range(0, 2) is represented by {0, 1, 2, *3*},
28 * rather than the intended set of {0, 1, 2}.
29 */
30struct tnum tnum_range(u64 min, u64 max);
31
32/* Arithmetic and logical ops */
33/* Shift a tnum left (by a fixed shift) */
34struct tnum tnum_lshift(struct tnum a, u8 shift);
35/* Shift (rsh) a tnum right (by a fixed shift) */
36struct tnum tnum_rshift(struct tnum a, u8 shift);
37/* Shift (arsh) a tnum right (by a fixed min_shift) */
38struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness);
39/* Add two tnums, return @a + @b */
40struct tnum tnum_add(struct tnum a, struct tnum b);
41/* Subtract two tnums, return @a - @b */
42struct tnum tnum_sub(struct tnum a, struct tnum b);
43/* Neg of a tnum, return 0 - @a */
44struct tnum tnum_neg(struct tnum a);
45/* Bitwise-AND, return @a & @b */
46struct tnum tnum_and(struct tnum a, struct tnum b);
47/* Bitwise-OR, return @a | @b */
48struct tnum tnum_or(struct tnum a, struct tnum b);
49/* Bitwise-XOR, return @a ^ @b */
50struct tnum tnum_xor(struct tnum a, struct tnum b);
51/* Multiply two tnums, return @a * @b */
52struct tnum tnum_mul(struct tnum a, struct tnum b);
53
54/* Return a tnum representing numbers satisfying both @a and @b */
55struct tnum tnum_intersect(struct tnum a, struct tnum b);
56
57/* Return @a with all but the lowest @size bytes cleared */
58struct tnum tnum_cast(struct tnum a, u8 size);
59
60/* Returns true if @a is a known constant */
61static inline bool tnum_is_const(struct tnum a)
62{
63 return !a.mask;
64}
65
66/* Returns true if @a == tnum_const(@b) */
67static inline bool tnum_equals_const(struct tnum a, u64 b)
68{
69 return tnum_is_const(a) && a.value == b;
70}
71
72/* Returns true if @a is completely unknown */
73static inline bool tnum_is_unknown(struct tnum a)
74{
75 return !~a.mask;
76}
77
78/* Returns true if @a is known to be a multiple of @size.
79 * @size must be a power of two.
80 */
81bool tnum_is_aligned(struct tnum a, u64 size);
82
83/* Returns true if @b represents a subset of @a.
84 *
85 * Note that using tnum_range() as @a requires extra cautions as tnum_in() may
86 * return true unexpectedly due to tnum limited ability to represent tight
87 * range, e.g.
88 *
89 * tnum_in(tnum_range(0, 2), tnum_const(3)) == true
90 *
91 * As a rule of thumb, if @a is explicitly coded rather than coming from
92 * reg->var_off, it should be in form of tnum_const(), tnum_range(0, 2**n - 1),
93 * or tnum_range(2**n, 2**(n+1) - 1).
94 */
95bool tnum_in(struct tnum a, struct tnum b);
96
97/* Formatting functions. These have snprintf-like semantics: they will write
98 * up to @size bytes (including the terminating NUL byte), and return the number
99 * of bytes (excluding the terminating NUL) which would have been written had
100 * sufficient space been available. (Thus tnum_sbin always returns 64.)
101 */
102/* Format a tnum as a pair of hex numbers (value; mask) */
103int tnum_strn(char *str, size_t size, struct tnum a);
104/* Format a tnum as tristate binary expansion */
105int tnum_sbin(char *str, size_t size, struct tnum a);
106
107/* Returns the 32-bit subreg */
108struct tnum tnum_subreg(struct tnum a);
109/* Returns the tnum with the lower 32-bit subreg cleared */
110struct tnum tnum_clear_subreg(struct tnum a);
111/* Returns the tnum with the lower 32-bit subreg in *reg* set to the lower
112 * 32-bit subreg in *subreg*
113 */
114struct tnum tnum_with_subreg(struct tnum reg, struct tnum subreg);
115/* Returns the tnum with the lower 32-bit subreg set to value */
116struct tnum tnum_const_subreg(struct tnum a, u32 value);
117/* Returns true if 32-bit subreg @a is a known constant*/
118static inline bool tnum_subreg_is_const(struct tnum a)
119{
120 return !(tnum_subreg(a)).mask;
121}
122
123#endif /* _LINUX_TNUM_H */