| /kernel/linux/linux-5.10/arch/hexagon/mm/ |
| D | strnlen_user.S | 39 P0 = cmp.eq(mod8,#0); define
42 if (P0.new) jump:t dw_loop; /* fire up the oven */
50 P0 = cmp.eq(tmp1,#0); define
51 if (P0.new) jump:nt exit_found;
57 P0 = cmp.eq(mod8,#0); define
60 if (!P0) jump alignment_loop;
71 P0 = vcmpb.eq(dbuf,dcmp); define
74 tmp1 = P0;
75 P0 = cmp.gtu(end,start); define
80 if (!P0) jump end_check;
[all …]
|
| /kernel/linux/linux-5.10/tools/memory-model/litmus-tests/ |
| D | ISA2+pooncerelease+poacquirerelease+poacquireonce.litmus | 7 * to order P0()'s initial write against P2()'s final read. The reason
9 * case (P2() to P0()), each process reads from the preceding process's
16 P0(int *x, int *y)
|
| D | Z6.0+pooncerelease+poacquirerelease+fencembonceonce.litmus | 9 * P0's write, which means that there are two non-rf links: P1() to P2()
11 * to P0() is a read-to-write link (AKA a "from-reads" or just "fr" link).
19 P0(int *x, int *y)
|
| D | S+poonceonces.litmus | 6 * Starting with a two-process release-acquire chain ordering P0()'s
14 P0(int *x, int *y)
|
| D | ISA2+pooncelock+pooncelock+pombonce.litmus | 7 * (in P0() and P1()) is visible to external process P2().
12 P0(int *x, int *y, spinlock_t *mylock)
|
| D | README | 184 P0(int *x, int *y)
208 P0()'s WRITE_ONCE() is read by its first READ_ONCE(), which is a
209 reads-from link (rf) and internal to the P0() process. This is
215 P0()'s second access is a READ_ONCE(), as opposed to (for example)
218 P0()'s third access is also a READ_ONCE(), but to y rather than x.
219 This is related to P0()'s second access by program order ("po"),
221 The resulting descriptor is "PodRR". Because P0()'s third access is
224 A from-read ("fre") relation links P0()'s third to P1()'s first
229 The remainder of P1() is similar to P0(), which means we add
231 P0()'s first access, which is WRITE_ONCE(), so we add "Fre Once".
|
| D | CoWW+poonceonce.litmus | 12 P0(int *x)
|
| D | CoRR+poonceonce+Once.litmus | 12 P0(int *x)
|
| D | MP+poonceonces.litmus | 12 P0(int *x, int *y)
|
| D | MP+pooncerelease+poacquireonce.litmus | 13 P0(int *x, int *y)
|
| D | LB+poonceonces.litmus | 12 P0(int *x, int *y)
|
| D | S+fencewmbonceonce+poacquireonce.litmus | 12 P0(int *x, int *y)
|
| D | CoWR+poonceonce+Once.litmus | 12 P0(int *x)
|
| D | CoRW+poonceonce+Once.litmus | 12 P0(int *x)
|
| D | R+poonceonces.litmus | 13 P0(int *x, int *y)
|
| D | LB+poacquireonce+pooncerelease.litmus | 13 P0(int *x, int *y)
|
| D | MP+fencewmbonceonce+fencermbonceonce.litmus | 13 P0(int *x, int *y)
|
| D | SB+poonceonces.litmus | 13 P0(int *x, int *y)
|
| D | SB+rfionceonce-poonceonces.litmus | 11 P0(int *x, int *y)
|
| /kernel/linux/linux-5.10/drivers/ata/ |
| D | ata_piix.c | 105 P0 = 0, /* port 0 */ enumerator
343 { P0, NA, P1, NA }, /* 000b */
344 { P1, NA, P0, NA }, /* 001b */
347 { P0, P1, IDE, IDE }, /* 100b */
348 { P1, P0, IDE, IDE }, /* 101b */
349 { IDE, IDE, P0, P1 }, /* 110b */
350 { IDE, IDE, P1, P0 }, /* 111b */
359 { P0, P2, P1, P3 }, /* 00b */
361 { P0, P2, IDE, IDE }, /* 10b */
376 { P0, P2, NA, NA }, /* 00b */
[all …]
|
| /kernel/linux/linux-5.10/arch/hexagon/kernel/ |
| D | vm_entry.S | 284 P0 = tstbit(R0, #HVM_VMEST_UM_SFT); define
285 if (!P0.new) jump:nt restore_all;
307 P0 = cmp.eq(R0, #0); if (!P0.new) jump:nt check_work_pending; define
368 P0 = cmp.eq(R24, #0); define
372 if (P0) jump check_work_pending
|
| /kernel/linux/linux-5.10/arch/c6x/lib/ |
| D | mpyll.S | 18 ;; P0 = X0*Y0
22 ;; result = (P2 << 64) + (P1 << 32) + P0
|
| /kernel/linux/linux-5.10/tools/memory-model/Documentation/ |
| D | explanation.txt | 115 P0()
131 Here the P0() function represents the interrupt handler running on one
134 Thus, P0 stores the data in buf and then sets flag. Meanwhile, P1
162 instance, P1 might run entirely before P0 begins, in which case r1 and
163 r2 will both be 0 at the end. Or P0 might run entirely before P1
167 routines run concurrently. One possibility is that P1 runs after P0's
196 Since r1 = 1, P0 must store 1 to flag before P1 loads 1 from
202 P1 must load 0 from buf before P0 stores 1 to it; otherwise r2
206 P0 stores 1 to buf before storing 1 to flag, since it executes
209 Since an instruction (in this case, P0's store to flag) cannot
[all …]
|
| D | litmus-tests.txt | 72 5 P0(int *x, int *y)
114 The name of the first process is "P0" and that of the second "P1".
123 names are significant. The fact that both P0() and P1() have a formal
125 same global variable, also named "x". So the "int *x, int *y" on P0()
128 by reference, hence "P0(int *x, int *y)", but *never* "P0(int x, int y)".
130 P0() has no local variables, but P1() has two of them named "r0" and "r1".
145 The P0() process does "WRITE_ONCE(*x, 1)" on line 7. Because "x" is a
146 pointer in P0()'s parameter list, this does an unordered store to global
148 is also in P0()'s parameter list, this does a release store to global
156 reference the same global variables that are used by P0().
[all …]
|
| /kernel/linux/linux-5.10/Documentation/litmus-tests/atomic/ |
| D | Atomic-RMW-ops-are-atomic-WRT-atomic_set.litmus | 14 P0(atomic_t *v)
|