Lines Matching refs:that
17 bugs due to games that compilers and DEC Alpha can play.
21 DEC Alpha can load a pointer, dereference that pointer, and
22 return data preceding initialization that preceded the store of
34 takes on the role of the lockless_dereference() primitive that
40 There are a very few exceptions, namely that you can temporarily
44 bits of that pointer. This clearly means that the pointer
57 rights to substitute zero for this sort of expression, so that
62 and "b" are integers that happen to be equal, the expression
66 - If you are using RCU to protect JITed functions, so that the
71 using the same memory that was used by an earlier JITed function.
87 As before, the reason this is buggy is that relational operators
103 Because the compiler now knows that the value of "p" is exactly
112 can now be speculated, such that it might happen before the
118 compiler knows that the pointer is NULL, you had better
131 Note that if the pointer comparison is done outside
142 - The comparison is against a pointer that references memory
143 that was initialized "a long time ago." The reason
144 this is safe is that even if misordering occurs, the
145 misordering will not affect the accesses that follow
157 - During some prior acquisition of the lock that
163 kernel's wide array of primitives that cause code to
178 so that a control dependency preserves the needed ordering.
185 pointer. Note that the volatile cast in rcu_dereference()
188 However, please note that if the compiler knows that the
190 comparison will provide exactly the information that the
193 - Disable any value-speculation optimizations that your compiler
195 optimizations that take data collected from prior runs. Such
199 optimizations that leverage the branch-prediction hardware are
249 /* The compiler decides that q->c is same as p->c. */
255 You might be surprised that the outcome (r1 == 143 && r2 == 44) is possible,
258 that it loaded into "r2". The fact that this same result can occur due
261 But suppose that the reader needs a consistent view?
307 /* The compiler decides that q->c is same as p->c. */
323 from carrying out optimizations that otherwise might destroy the ordering
324 guarantees that RCU depends on. And the volatile cast in rcu_dereference()
360 Because the compiler can see all stores to "gp", it knows that the only
378 second argument with a constant value of 1 (or true, for that matter).
379 With that caution out of the way, here is some guidance for which
385 using rcu_read_lock(), anything that disables bottom halves,
386 anything that disables interrupts, or anything that disables
405 4. If the access is on the update side, so that it is always protected
415 to this code, that is the rare case when rcu_dereference_raw()
418 complex, except that a better approach in that case might be to