RTX5里面提供的各种原子操作API，可以独立复制出来使用，含MDK，IAR和GCC

eric2013

复制出来开个帖子，方便以后查阅：

1. //  ==== Exclusive Access Operation ====
   
2. 
   
3. #if (EXCLUSIVE_ACCESS == 1)
   
4. 
   
5. //lint ++flb "Library Begin" [MISRA Note 12]
   
6. 
   
7. /// Atomic Access Operation: Write (8-bit)
   
8. /// \param[in]  mem             Memory address
   
9. /// \param[in]  val             Value to write
   
10. /// \return                     Previous value
    
11. #if defined(__CC_ARM)
    
12. static __asm    uint8_t atomic_wr8 (uint8_t *mem, uint8_t val) {
    
13.   mov    r2,r0
    
14. 1
    
15.   ldrexb r0,[r2]
    
16.   strexb r3,r1,[r2]
    
17.   cbz    r3,%F2
    
18.   b      %B1
    
19. 2
    
20.   bx     lr
    
21. }
    
22. #else
    
23. __STATIC_INLINE uint8_t atomic_wr8 (uint8_t *mem, uint8_t val) {
    
24. #ifdef  __ICCARM__
    
25. #pragma diag_suppress=Pe550
    
26. #endif
    
27.   register uint32_t res;
    
28. #ifdef  __ICCARM__
    
29. #pragma diag_default=Pe550
    
30. #endif
    
31.   register uint8_t  ret;
    
32. 
    
33.   __ASM volatile (
    
34. #ifndef __ICCARM__
    
35.   ".syntax unified\n\t"
    
36. #endif
    
37.   "1:\n\t"
    
38.     "ldrexb %[ret],[%[mem]]\n\t"
    
39.     "strexb %[res],%[val],[%[mem]]\n\t"
    
40.     "cbz    %[res],2f\n\t"
    
41.     "b       1b\n"
    
42.   "2:"
    
43.   : [ret] "=&l" (ret),
    
44.     [res] "=&l" (res)
    
45.   : [mem] "l"   (mem),
    
46.     [val] "l"   (val)
    
47.   : "memory"
    
48.   );
    
49. 
    
50.   return ret;
    
51. }
    
52. #endif
    
53. 
    
54. /// Atomic Access Operation: Set bits (32-bit)
    
55. /// \param[in]  mem             Memory address
    
56. /// \param[in]  bits            Bit mask
    
57. /// \return                     New value
    
58. #if defined(__CC_ARM)
    
59. static __asm    uint32_t atomic_set32 (uint32_t *mem, uint32_t bits) {
    
60.   mov   r2,r0
    
61. 1
    
62.   ldrex r0,[r2]
    
63.   orr   r0,r0,r1
    
64.   strex r3,r0,[r2]
    
65.   cbz   r3,%F2
    
66.   b     %B1
    
67. 2
    
68.   bx     lr
    
69. }
    
70. #else
    
71. __STATIC_INLINE uint32_t atomic_set32 (uint32_t *mem, uint32_t bits) {
    
72. #ifdef  __ICCARM__
    
73. #pragma diag_suppress=Pe550
    
74. #endif
    
75.   register uint32_t val, res;
    
76. #ifdef  __ICCARM__
    
77. #pragma diag_default=Pe550
    
78. #endif
    
79.   register uint32_t ret;
    
80. 
    
81.   __ASM volatile (
    
82. #ifndef __ICCARM__
    
83.   ".syntax unified\n\t"
    
84. #endif
    
85.   "1:\n\t"
    
86.     "ldrex %[val],[%[mem]]\n\t"
    
87. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
    
88.     "mov   %[ret],%[val]\n\t"
    
89.     "orrs  %[ret],%[bits]\n\t"
    
90. #else
    
91.     "orr   %[ret],%[val],%[bits]\n\t"
    
92. #endif
    
93.     "strex %[res],%[ret],[%[mem]]\n\t"
    
94.     "cbz   %[res],2f\n\t"
    
95.     "b     1b\n"
    
96.   "2:"
    
97.   : [ret]  "=&l" (ret),
    
98.     [val]  "=&l" (val),
    
99.     [res]  "=&l" (res)
    
100.   : [mem]  "l"   (mem),
     
101.     [bits] "l"   (bits)
     
102. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
103.   : "memory", "cc"
     
104. #else
     
105.   : "memory"
     
106. #endif
     
107.   );
     
108. 
     
109.   return ret;
     
110. }
     
111. #endif
     
112. 
     
113. /// Atomic Access Operation: Clear bits (32-bit)
     
114. /// \param[in]  mem             Memory address
     
115. /// \param[in]  bits            Bit mask
     
116. /// \return                     Previous value
     
117. #if defined(__CC_ARM)
     
118. static __asm    uint32_t atomic_clr32 (uint32_t *mem, uint32_t bits) {
     
119.   push  {r4,lr}
     
120.   mov   r2,r0
     
121. 1
     
122.   ldrex r0,[r2]
     
123.   bic   r4,r0,r1
     
124.   strex r3,r4,[r2]
     
125.   cbz   r3,%F2
     
126.   b     %B1
     
127. 2
     
128.   pop   {r4,pc}
     
129. }
     
130. #else
     
131. __STATIC_INLINE uint32_t atomic_clr32 (uint32_t *mem, uint32_t bits) {
     
132. #ifdef  __ICCARM__
     
133. #pragma diag_suppress=Pe550
     
134. #endif
     
135.   register uint32_t val, res;
     
136. #ifdef  __ICCARM__
     
137. #pragma diag_default=Pe550
     
138. #endif
     
139.   register uint32_t ret;
     
140. 
     
141.   __ASM volatile (
     
142. #ifndef __ICCARM__
     
143.   ".syntax unified\n\t"
     
144. #endif
     
145.   "1:\n\t"
     
146.     "ldrex %[ret],[%[mem]]\n\t"
     
147. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
148.     "mov   %[val],%[ret]\n\t"
     
149.     "bics  %[val],%[bits]\n\t"
     
150. #else
     
151.     "bic   %[val],%[ret],%[bits]\n\t"
     
152. #endif
     
153.     "strex %[res],%[val],[%[mem]]\n\t"
     
154.     "cbz   %[res],2f\n\t"
     
155.     "b     1b\n"
     
156.   "2:"
     
157.   : [ret]  "=&l" (ret),
     
158.     [val]  "=&l" (val),
     
159.     [res]  "=&l" (res)
     
160.   : [mem]  "l"   (mem),
     
161.     [bits] "l"   (bits)
     
162. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
163.   : "memory", "cc"
     
164. #else
     
165.   : "memory"
     
166. #endif
     
167.   );
     
168. 
     
169.   return ret;
     
170. }
     
171. #endif
     
172. 
     
173. /// Atomic Access Operation: Check if all specified bits (32-bit) are active and clear them
     
174. /// \param[in]  mem             Memory address
     
175. /// \param[in]  bits            Bit mask
     
176. /// \return                     Active bits before clearing or 0 if not active
     
177. #if defined(__CC_ARM)
     
178. static __asm    uint32_t atomic_chk32_all (uint32_t *mem, uint32_t bits) {
     
179.   push  {r4,lr}
     
180.   mov   r2,r0
     
181. 1
     
182.   ldrex r0,[r2]
     
183.   and   r4,r0,r1
     
184.   cmp   r4,r1
     
185.   beq   %F2
     
186.   clrex
     
187.   movs  r0,#0
     
188.   pop   {r4,pc}
     
189. 2
     
190.   bic   r4,r0,r1
     
191.   strex r3,r4,[r2]
     
192.   cbz   r3,%F3
     
193.   b     %B1
     
194. 3
     
195.   pop   {r4,pc}
     
196. }
     
197. #else
     
198. __STATIC_INLINE uint32_t atomic_chk32_all (uint32_t *mem, uint32_t bits) {
     
199. #ifdef  __ICCARM__
     
200. #pragma diag_suppress=Pe550
     
201. #endif
     
202.   register uint32_t val, res;
     
203. #ifdef  __ICCARM__
     
204. #pragma diag_default=Pe550
     
205. #endif
     
206.   register uint32_t ret;
     
207. 
     
208.   __ASM volatile (
     
209. #ifndef __ICCARM__
     
210.   ".syntax unified\n\t"
     
211. #endif
     
212.   "1:\n\t"
     
213.     "ldrex %[ret],[%[mem]]\n\t"
     
214. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
215.     "mov   %[val],%[ret]\n\t"
     
216.     "ands  %[val],%[bits]\n\t"
     
217. #else
     
218.     "and   %[val],%[ret],%[bits]\n\t"
     
219. #endif
     
220.     "cmp   %[val],%[bits]\n\t"
     
221.     "beq   2f\n\t"
     
222.     "clrex\n\t"
     
223.     "movs  %[ret],#0\n\t"
     
224.     "b     3f\n"
     
225.   "2:\n\t"
     
226. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
227.     "mov   %[val],%[ret]\n\t"
     
228.     "bics  %[val],%[bits]\n\t"
     
229. #else
     
230.     "bic   %[val],%[ret],%[bits]\n\t"
     
231. #endif
     
232.     "strex %[res],%[val],[%[mem]]\n\t"
     
233.     "cbz   %[res],3f\n\t"
     
234.     "b     1b\n"
     
235.   "3:"
     
236.   : [ret]  "=&l" (ret),
     
237.     [val]  "=&l" (val),
     
238.     [res]  "=&l" (res)
     
239.   : [mem]  "l"   (mem),
     
240.     [bits] "l"   (bits)
     
241.   : "cc", "memory"
     
242.   );
     
243. 
     
244.   return ret;
     
245. }
     
246. #endif
     
247. 
     
248. /// Atomic Access Operation: Check if any specified bits (32-bit) are active and clear them
     
249. /// \param[in]  mem             Memory address
     
250. /// \param[in]  bits            Bit mask
     
251. /// \return                     Active bits before clearing or 0 if not active
     
252. #if defined(__CC_ARM)
     
253. static __asm    uint32_t atomic_chk32_any (uint32_t *mem, uint32_t bits) {
     
254.   push  {r4,lr}
     
255.   mov   r2,r0
     
256. 1
     
257.   ldrex r0,[r2]
     
258.   tst   r0,r1
     
259.   bne   %F2
     
260.   clrex
     
261.   movs  r0,#0
     
262.   pop   {r4,pc}
     
263. 2
     
264.   bic   r4,r0,r1
     
265.   strex r3,r4,[r2]
     
266.   cbz   r3,%F3
     
267.   b     %B1
     
268. 3
     
269.   pop   {r4,pc}
     
270. }
     
271. #else
     
272. __STATIC_INLINE uint32_t atomic_chk32_any (uint32_t *mem, uint32_t bits) {
     
273. #ifdef  __ICCARM__
     
274. #pragma diag_suppress=Pe550
     
275. #endif
     
276.   register uint32_t val, res;
     
277. #ifdef  __ICCARM__
     
278. #pragma diag_default=Pe550
     
279. #endif
     
280.   register uint32_t ret;
     
281. 
     
282.   __ASM volatile (
     
283. #ifndef __ICCARM__
     
284.   ".syntax unified\n\t"
     
285. #endif
     
286.   "1:\n\t"
     
287.     "ldrex %[ret],[%[mem]]\n\t"
     
288.     "tst   %[ret],%[bits]\n\t"
     
289.     "bne   2f\n\t"
     
290.     "clrex\n\t"
     
291.     "movs  %[ret],#0\n\t"
     
292.     "b     3f\n"
     
293.   "2:\n\t"
     
294. #if (defined(__ARM_ARCH_8M_BASE__) && (__ARM_ARCH_8M_BASE__ != 0))
     
295.     "mov   %[val],%[ret]\n\t"
     
296.     "bics  %[val],%[bits]\n\t"
     
297. #else
     
298.     "bic   %[val],%[ret],%[bits]\n\t"
     
299. #endif
     
300.     "strex %[res],%[val],[%[mem]]\n\t"
     
301.     "cbz   %[res],3f\n\t"
     
302.     "b     1b\n"
     
303.   "3:"
     
304.   : [ret]  "=&l" (ret),
     
305.     [val]  "=&l" (val),
     
306.     [res]  "=&l" (res)
     
307.   : [mem]  "l"   (mem),
     
308.     [bits] "l"   (bits)
     
309.   : "cc", "memory"
     
310.   );
     
311. 
     
312.   return ret;
     
313. }
     
314. #endif
     
315. 
     
316. /// Atomic Access Operation: Increment (32-bit)
     
317. /// \param[in]  mem             Memory address
     
318. /// \return                     Previous value
     
319. #if defined(__CC_ARM)
     
320. static __asm    uint32_t atomic_inc32 (uint32_t *mem) {
     
321.   mov   r2,r0
     
322. 1
     
323.   ldrex r0,[r2]
     
324.   adds  r1,r0,#1
     
325.   strex r3,r1,[r2]
     
326.   cbz   r3,%F2
     
327.   b     %B1
     
328. 2
     
329.   bx     lr
     
330. }
     
331. #else
     
332. __STATIC_INLINE uint32_t atomic_inc32 (uint32_t *mem) {
     
333. #ifdef  __ICCARM__
     
334. #pragma diag_suppress=Pe550
     
335. #endif
     
336.   register uint32_t val, res;
     
337. #ifdef  __ICCARM__
     
338. #pragma diag_default=Pe550
     
339. #endif
     
340.   register uint32_t ret;
     
341. 
     
342.   __ASM volatile (
     
343. #ifndef __ICCARM__
     
344.   ".syntax unified\n\t"
     
345. #endif
     
346.   "1:\n\t"
     
347.     "ldrex %[ret],[%[mem]]\n\t"
     
348.     "adds  %[val],%[ret],#1\n\t"
     
349.     "strex %[res],%[val],[%[mem]]\n\t"
     
350.     "cbz   %[res],2f\n\t"
     
351.     "b     1b\n"
     
352.   "2:"
     
353.   : [ret] "=&l" (ret),
     
354.     [val] "=&l" (val),
     
355.     [res] "=&l" (res)
     
356.   : [mem] "l"   (mem)
     
357.   : "cc", "memory"
     
358.   );
     
359. 
     
360.   return ret;
     
361. }
     
362. #endif
     
363. 
     
364. /// Atomic Access Operation: Increment (16-bit) if Less Than
     
365. /// \param[in]  mem             Memory address
     
366. /// \param[in]  max             Maximum value
     
367. /// \return                     Previous value
     
368. #if defined(__CC_ARM)
     
369. static __asm    uint16_t atomic_inc16_lt (uint16_t *mem, uint16_t max) {
     
370.   push   {r4,lr}
     
371.   mov    r2,r0
     
372. 1
     
373.   ldrexh r0,[r2]
     
374.   cmp    r1,r0
     
375.   bhi    %F2
     
376.   clrex
     
377.   pop    {r4,pc}
     
378. 2
     
379.   adds   r4,r0,#1
     
380.   strexh r3,r4,[r2]
     
381.   cbz    r3,%F3
     
382.   b      %B1
     
383. 3
     
384.   pop    {r4,pc}
     
385. }
     
386. #else
     
387. __STATIC_INLINE uint16_t atomic_inc16_lt (uint16_t *mem, uint16_t max) {
     
388. #ifdef  __ICCARM__
     
389. #pragma diag_suppress=Pe550
     
390. #endif
     
391.   register uint32_t val, res;
     
392. #ifdef  __ICCARM__
     
393. #pragma diag_default=Pe550
     
394. #endif
     
395.   register uint16_t ret;
     
396. 
     
397.   __ASM volatile (
     
398. #ifndef __ICCARM__
     
399.   ".syntax unified\n\t"
     
400. #endif
     
401.   "1:\n\t"
     
402.     "ldrexh %[ret],[%[mem]]\n\t"
     
403.     "cmp    %[max],%[ret]\n\t"
     
404.     "bhi    2f\n\t"
     
405.     "clrex\n\t"
     
406.     "b      3f\n"
     
407.   "2:\n\t"
     
408.     "adds   %[val],%[ret],#1\n\t"
     
409.     "strexh %[res],%[val],[%[mem]]\n\t"
     
410.     "cbz    %[res],3f\n\t"
     
411.     "b      1b\n"
     
412.   "3:"
     
413.   : [ret] "=&l" (ret),
     
414.     [val] "=&l" (val),
     
415.     [res] "=&l" (res)
     
416.   : [mem] "l"   (mem),
     
417.     [max] "l"   (max)
     
418.   : "cc", "memory"
     
419.   );
     
420. 
     
421.   return ret;
     
422. }
     
423. #endif
     
424. 
     
425. /// Atomic Access Operation: Increment (16-bit) and clear on Limit
     
426. /// \param[in]  mem             Memory address
     
427. /// \param[in]  max             Maximum value
     
428. /// \return                     Previous value
     
429. #if defined(__CC_ARM)
     
430. static __asm    uint16_t atomic_inc16_lim (uint16_t *mem, uint16_t lim) {
     
431.   push   {r4,lr}
     
432.   mov    r2,r0
     
433. 1
     
434.   ldrexh r0,[r2]
     
435.   adds   r4,r0,#1
     
436.   cmp    r1,r4
     
437.   bhi    %F2
     
438.   movs   r4,#0
     
439. 2
     
440.   strexh r3,r4,[r2]
     
441.   cbz    r3,%F3
     
442.   b      %B1
     
443. 3
     
444.   pop    {r4,pc}
     
445. }
     
446. #else
     
447. __STATIC_INLINE uint16_t atomic_inc16_lim (uint16_t *mem, uint16_t lim) {
     
448. #ifdef  __ICCARM__
     
449. #pragma diag_suppress=Pe550
     
450. #endif
     
451.   register uint32_t val, res;
     
452. #ifdef  __ICCARM__
     
453. #pragma diag_default=Pe550
     
454. #endif
     
455.   register uint16_t ret;
     
456. 
     
457.   __ASM volatile (
     
458. #ifndef __ICCARM__
     
459.   ".syntax unified\n\t"
     
460. #endif
     
461.   "1:\n\t"
     
462.     "ldrexh %[ret],[%[mem]]\n\t"
     
463.     "adds   %[val],%[ret],#1\n\t"
     
464.     "cmp    %[lim],%[val]\n\t"
     
465.     "bhi    2f\n\t"
     
466.     "movs   %[val],#0\n"
     
467.   "2:\n\t"
     
468.     "strexh %[res],%[val],[%[mem]]\n\t"
     
469.     "cbz    %[res],3f\n\t"
     
470.     "b      1b\n"
     
471.   "3:"
     
472.   : [ret] "=&l" (ret),
     
473.     [val] "=&l" (val),
     
474.     [res] "=&l" (res)
     
475.   : [mem] "l"   (mem),
     
476.     [lim] "l"   (lim)
     
477.   : "cc", "memory"
     
478.   );
     
479. 
     
480.   return ret;
     
481. }
     
482. #endif
     
483. 
     
484. /// Atomic Access Operation: Decrement (32-bit)
     
485. /// \param[in]  mem             Memory address
     
486. /// \return                     Previous value
     
487. #if defined(__CC_ARM)
     
488. static __asm    uint32_t atomic_dec32 (uint32_t *mem) {
     
489.   mov   r2,r0
     
490. 1
     
491.   ldrex r0,[r2]
     
492.   subs  r1,r0,#1
     
493.   strex r3,r1,[r2]
     
494.   cbz   r3,%F2
     
495.   b     %B1
     
496. 2
     
497.   bx     lr
     
498. }
     
499. #else
     
500. __STATIC_INLINE uint32_t atomic_dec32 (uint32_t *mem) {
     
501. #ifdef  __ICCARM__
     
502. #pragma diag_suppress=Pe550
     
503. #endif
     
504.   register uint32_t val, res;
     
505. #ifdef  __ICCARM__
     
506. #pragma diag_default=Pe550
     
507. #endif
     
508.   register uint32_t ret;
     
509. 
     
510.   __ASM volatile (
     
511. #ifndef __ICCARM__
     
512.   ".syntax unified\n\t"
     
513. #endif
     
514.   "1:\n\t"
     
515.     "ldrex %[ret],[%[mem]]\n\t"
     
516.     "subs  %[val],%[ret],#1\n\t"
     
517.     "strex %[res],%[val],[%[mem]]\n\t"
     
518.     "cbz   %[res],2f\n\t"
     
519.     "b     1b\n"
     
520.   "2:"
     
521.   : [ret] "=&l" (ret),
     
522.     [val] "=&l" (val),
     
523.     [res] "=&l" (res)
     
524.   : [mem] "l"   (mem)
     
525.   : "cc", "memory"
     
526.   );
     
527. 
     
528.   return ret;
     
529. }
     
530. #endif
     
531. 
     
532. /// Atomic Access Operation: Decrement (32-bit) if Not Zero
     
533. /// \param[in]  mem             Memory address
     
534. /// \return                     Previous value
     
535. #if defined(__CC_ARM)
     
536. static __asm    uint32_t atomic_dec32_nz (uint32_t *mem) {
     
537.   mov   r2,r0
     
538. 1
     
539.   ldrex r0,[r2]
     
540.   cbnz  r0,%F2
     
541.   clrex
     
542.   bx    lr
     
543. 2
     
544.   subs  r1,r0,#1
     
545.   strex r3,r1,[r2]
     
546.   cbz   r3,%F3
     
547.   b     %B1
     
548. 3
     
549.   bx     lr
     
550. }
     
551. #else
     
552. __STATIC_INLINE uint32_t atomic_dec32_nz (uint32_t *mem) {
     
553. #ifdef  __ICCARM__
     
554. #pragma diag_suppress=Pe550
     
555. #endif
     
556.   register uint32_t val, res;
     
557. #ifdef  __ICCARM__
     
558. #pragma diag_default=Pe550
     
559. #endif
     
560.   register uint32_t ret;
     
561. 
     
562.   __ASM volatile (
     
563. #ifndef __ICCARM__
     
564.   ".syntax unified\n\t"
     
565. #endif
     
566.   "1:\n\t"
     
567.     "ldrex %[ret],[%[mem]]\n\t"
     
568.     "cbnz  %[ret],2f\n\t"
     
569.     "clrex\n\t"
     
570.     "b     3f\n"
     
571.   "2:\n\t"
     
572.     "subs  %[val],%[ret],#1\n\t"
     
573.     "strex %[res],%[val],[%[mem]]\n\t"
     
574.     "cbz   %[res],3f\n\t"
     
575.     "b     1b\n"
     
576.   "3:"
     
577.   : [ret] "=&l" (ret),
     
578.     [val] "=&l" (val),
     
579.     [res] "=&l" (res)
     
580.   : [mem] "l"   (mem)
     
581.   : "cc", "memory"
     
582.   );
     
583. 
     
584.   return ret;
     
585. }
     
586. #endif
     
587. 
     
588. /// Atomic Access Operation: Decrement (16-bit) if Not Zero
     
589. /// \param[in]  mem             Memory address
     
590. /// \return                     Previous value
     
591. #if defined(__CC_ARM)
     
592. static __asm    uint16_t atomic_dec16_nz (uint16_t *mem) {
     
593.   mov    r2,r0
     
594. 1
     
595.   ldrexh r0,[r2]
     
596.   cbnz   r0,%F2
     
597.   clrex
     
598.   bx     lr
     
599. 2
     
600.   subs   r1,r0,#1
     
601.   strexh r3,r1,[r2]
     
602.   cbz    r3,%F3
     
603.   b      %B1
     
604. 3
     
605.   bx      lr
     
606. }
     
607. #else
     
608. __STATIC_INLINE uint16_t atomic_dec16_nz (uint16_t *mem) {
     
609. #ifdef  __ICCARM__
     
610. #pragma diag_suppress=Pe550
     
611. #endif
     
612.   register uint32_t val, res;
     
613. #ifdef  __ICCARM__
     
614. #pragma diag_default=Pe550
     
615. #endif
     
616.   register uint16_t ret;
     
617. 
     
618.   __ASM volatile (
     
619. #ifndef __ICCARM__
     
620.   ".syntax unified\n\t"
     
621. #endif
     
622.   "1:\n\t"
     
623.     "ldrexh %[ret],[%[mem]]\n\t"
     
624.     "cbnz   %[ret],2f\n\t"
     
625.     "clrex\n\t"
     
626.     "b      3f\n"
     
627.   "2:\n\t"
     
628.     "subs   %[val],%[ret],#1\n\t"
     
629.     "strexh %[res],%[val],[%[mem]]\n\t"
     
630.     "cbz    %[res],3f\n\t"
     
631.     "b      1b\n"
     
632.   "3:"
     
633.   : [ret] "=&l" (ret),
     
634.     [val] "=&l" (val),
     
635.     [res] "=&l" (res)
     
636.   : [mem] "l"   (mem)
     
637.   : "cc", "memory"
     
638.   );
     
639. 
     
640.   return ret;
     
641. }
     
642. #endif
     
643. 
     
644. /// Atomic Access Operation: Link Get
     
645. /// \param[in]  root            Root address
     
646. /// \return                     Link
     
647. #if defined(__CC_ARM)
     
648. static __asm    void *atomic_link_get (void **root) {
     
649.   mov   r2,r0
     
650. 1
     
651.   ldrex r0,[r2]
     
652.   cbnz  r0,%F2
     
653.   clrex
     
654.   bx    lr
     
655. 2
     
656.   ldr   r1,[r0]
     
657.   strex r3,r1,[r2]
     
658.   cbz   r3,%F3
     
659.   b     %B1
     
660. 3
     
661.   bx     lr
     
662. }
     
663. #else
     
664. __STATIC_INLINE void *atomic_link_get (void **root) {
     
665. #ifdef  __ICCARM__
     
666. #pragma diag_suppress=Pe550
     
667. #endif
     
668.   register uint32_t val, res;
     
669. #ifdef  __ICCARM__
     
670. #pragma diag_default=Pe550
     
671. #endif
     
672.   register void    *ret;
     
673. 
     
674.   __ASM volatile (
     
675. #ifndef __ICCARM__
     
676.   ".syntax unified\n\t"
     
677. #endif
     
678.   "1:\n\t"
     
679.     "ldrex %[ret],[%[root]]\n\t"
     
680.     "cbnz  %[ret],2f\n\t"
     
681.     "clrex\n\t"
     
682.     "b     3f\n"
     
683.   "2:\n\t"
     
684.     "ldr   %[val],[%[ret]]\n\t"
     
685.     "strex %[res],%[val],[%[root]]\n\t"
     
686.     "cbz   %[res],3f\n\t"
     
687.     "b     1b\n"
     
688.   "3:"
     
689.   : [ret]  "=&l" (ret),
     
690.     [val]  "=&l" (val),
     
691.     [res]  "=&l" (res)
     
692.   : [root] "l"   (root)
     
693.   : "cc", "memory"
     
694.   );
     
695. 
     
696.   return ret;
     
697. }
     
698. #endif
     
699. 
     
700. /// Atomic Access Operation: Link Put
     
701. /// \param[in]  root            Root address
     
702. /// \param[in]  lnk             Link
     
703. #if defined(__CC_ARM)
     
704. static __asm    void atomic_link_put (void **root, void *link) {
     
705. 1
     
706.   ldr   r2,[r0]
     
707.   str   r2,[r1]
     
708.   dmb
     
709.   ldrex r2,[r0]
     
710.   ldr   r3,[r1]
     
711.   cmp   r3,r2
     
712.   bne   %B1
     
713.   strex r3,r1,[r0]
     
714.   cbz   r3,%F2
     
715.   b     %B1
     
716. 2
     
717.   bx    lr
     
718. }
     
719. #else
     
720. __STATIC_INLINE void atomic_link_put (void **root, void *link) {
     
721. #ifdef  __ICCARM__
     
722. #pragma diag_suppress=Pe550
     
723. #endif
     
724.   register uint32_t val1, val2, res;
     
725. #ifdef  __ICCARM__
     
726. #pragma diag_default=Pe550
     
727. #endif
     
728. 
     
729.   __ASM volatile (
     
730. #ifndef __ICCARM__
     
731.   ".syntax unified\n\t"
     
732. #endif
     
733.   "1:\n\t"
     
734.     "ldr   %[val1],[%[root]]\n\t"
     
735.     "str   %[val1],[%[link]]\n\t"
     
736.     "dmb\n\t"
     
737.     "ldrex %[val1],[%[root]]\n\t"
     
738.     "ldr   %[val2],[%[link]]\n\t"
     
739.     "cmp   %[val2],%[val1]\n\t"
     
740.     "bne   1b\n\t"
     
741.     "strex %[res],%[link],[%[root]]\n\t"
     
742.     "cbz   %[res],2f\n\t"
     
743.     "b     1b\n"
     
744.   "2:"
     
745.   : [val1] "=&l" (val1),
     
746.     [val2] "=&l" (val2),
     
747.     [res]  "=&l" (res)
     
748.   : [root] "l"   (root),
     
749.     [link] "l"   (link)
     
750.   : "cc", "memory"
     
751.   );
     
752. }
     
753. #endif
     
754. 
     
755. //lint --flb "Library End" [MISRA Note 12]
     
756. 
     
757. #endif  // (EXCLUSIVE_ACCESS == 1)

复制代码

morning_enr6U

登云钓月

看不懂 一脸懵

eric2013

登云钓月 发表于 2021-11-29 00:11
看不懂 一脸懵

就是这个API函数，直接调用就行。

gallop020142

请问32位的变量赋值操作，怎么用这些函数呢？谢谢

eric2013

gallop020142 发表于 2022-1-6 10:31
请问32位的变量赋值操作，怎么用这些函数呢？谢谢

直接调用提供的32bit 操作即可，不是有注释。

gallop020142

eric2013 发表于 2022-1-6 11:26
直接调用提供的32bit 操作即可，不是有注释。

在rtx_thread.c里面，是这样用atomic_set32的：
thread_flags = atomic_set32(&thread->thread_flags, flags);
对着注释看半天，还是不太明白怎么使用。

比如我想把 int32_t（或者uint32_t）的变量a赋值为b，请问是不是这样写：
#include "rtx_core_cm.h"
atomic_set32( &a, b);

谢谢

eric2013

gallop020142 发表于 2022-1-24 20:28
在rtx_thread.c里面，是这样用atomic_set32的：
thread_flags = atomic_set32(&thread->thread_flags, f ...

就是这样的，你操作是否正常。

gallop020142

eric2013 发表于 2022-1-25 00:12
就是这样的，你操作是否正常。

感谢回复
有两个小问题：
1. rtx_core_cm.h 这个文件工程里面找不到。我从c盘  AppData\Local\Arm\Packs\ARM\CMSIS\5.7.0\CMSIS\RTOS2\RTX\Source 复制出来到工程目录的，不知道正确的操作添加方式是什么。
2. 出来警告 warning: passing 'int32_t *' (aka 'int *') to parameter of type 'uint32_t *''
如果强制类型转换，写成如下，您觉得会改变本意吗？
atomic_set32((uint32_t*)(&a), b)

谢谢

eric2013

gallop020142 发表于 2022-1-25 10:38
感谢回复
有两个小问题：
1. rtx_core_cm.h 这个文件工程里面找不到。我从c盘  AppData\Local\Arm\Pack ...

直接单步调试看执行流程就行，执行了相应代码就没问题。

gallop020142

eric2013 发表于 2022-1-25 10:50
直接单步调试看执行流程就行，执行了相应代码就没问题。

好的，我先试试，谢谢

gallop020142

eric2013 发表于 2022-1-25 10:50
直接单步调试看执行流程就行，执行了相应代码就没问题。

试过了，结果不对，有空时请帮忙看看哈。谢谢。
我测试的代码大意如下，其中b是一个变化的数
int32_t a = 0, c = 0;
//一个任务里面赋值
atomic_set((uint32_t*)&a, b);
c = b;

//在另一个任务里面打印
printf("%d vs atomic %d\r\n", c, a);

结果：c跟随b变化，但是a是与b不相关的值，从15, 63, 1023 ... 到最后是-1

WZH

gallop020142 发表于 2022-1-25 22:11
试过了，结果不对，有空时请帮忙看看哈。谢谢。
我测试的代码大意如下，其中b是一个变化的数
int32_t a ...

atomic_set32是设置位的，将原有的结果进行或操作，等价于a|=b

gallop020142

WZH 发表于 2022-2-19 12:03
atomic_set32是设置位的，将原有的结果进行或操作，等价于a|=b

感谢回复，请问赋值操作（不是自增自减），该用哪个函数呢？

tovinz

像 atomic_set32 置位，复位操作我懂，因为需要读改写三步走。但为什么要有 atomic_wr8 , 这个函数应该是直接写一个字节的数据把

eric2013

tovinz 发表于 2022-5-10 09:50
像 atomic_set32 置位，复位操作我懂，因为需要读改写三步走。但为什么要有 atomic_wr8 , 这个函数应该是直 ...

对啊，这个也需要原子操作。

tovinz

难道arm的处理器不能直接以字节的形式访问内存吗, 只能是16bit和32bit的形式。我的意思是 atomic_wr8 不就是直接往内存里写一个字节， 仅仅就一个写操作，需要原子操作吗

eric2013

tovinz 发表于 2022-5-10 11:16
难道arm的处理器不能直接以字节的形式访问内存吗, 只能是16bit和32bit的形式。我的意思是 atomic_wr8 不就 ...

是的，因为他必须先读到的寄存器才可以往对应地址写。数值不能没有CPU的参与情况下直接往地址里面写，所以它不是原子操作，除非DMA之类的。
不知道你是不是这个意思。
ps：ldrexb是字节操作，ldrex是字操作。

tovinz

eric2013 发表于 2022-5-10 11:33
是的，因为他必须先读到的寄存器才可以往对应地址写。数值不能没有CPU的参与情况下直接往地址里面写，所 ...

一语点醒梦中人，读写变量还要经CPU转一手

cheng_5230

学到了

eric2013

ST的库也开始带了一些原子操作API

LeslieChia

没懂啊，硬汉哥，这些函数调用时不会被中断打断吗？

eric2013

LeslieChia 发表于 2022-9-29 21:57
没懂啊，硬汉哥，这些函数调用时不会被中断打断吗？

不影响，随意被中断。原子操作保证的是你对这个变量操作的原子性。

hpdell

eric2013 发表于 2022-9-30 00:43
不影响，随意被中断。原子操作保证的是你对这个变量操作的原子性。

• static __asm    uint8_t atomic_wr8 (uint8_t *mem, uint8_t val) {
•   mov    r2,r0
• 1
•   ldrexb r0,[r2]
•   strexb r3,r1,[r2]
•   cbz    r3,%F2
•   b      %B1
• 2
•   bx     lr
• }
  

请教下，这个函数里面  mem, val 2个参数也木有看到被调用啊 ？？？

eric2013

hpdell 发表于 2022-9-30 10:54

static __asm    uint8_t atomic_wr8 (uint8_t *mem, uint8_t val) {

  mov    r2,r0

1

MDK调试进入这个函数，会看到两个参数被传递给寄存器了。

hpdell

eric2013 发表于 2022-9-30 11:06
MDK调试进入这个函数，会看到两个参数被传递给寄存器了。

比较神器的函数 哟

雷鹏

都是汇编语言吧

eric2013

雷鹏 发表于 2022-9-30 11:26
都是汇编语言吧

对，就是C嵌入汇编的方式，方便调用。

eric2013

hpdell 发表于 2022-9-30 11:23
比较神器的函数 哟

这个是那个AAPCS规约要求的，形参使用寄存器，有固定使用那个的。

hpdell

eric2013 发表于 2022-9-30 15:46
这个是那个AAPCS规约要求的，形参使用寄存器，有固定使用那个的。

感觉蛮高大上的，只可惜不懂哟

LeslieChia

eric2013 发表于 2022-9-30 00:43
不影响，随意被中断。原子操作保证的是你对这个变量操作的原子性。

硬汉哥，我还是不太理解它的原理，比如我执行atomic_set32函数操作A变量，执行到一半时，中断来了也调用atomic_set32函数操作A变量，这样不会冲突吗？

eric2013

LeslieChia 发表于 2022-10-10 14:11
硬汉哥，我还是不太理解它的原理，比如我执行atomic_set32函数操作A变量，执行到一半时，中断来了也调用a ...

这个调用的是互斥指令ldrex和strex

wy_nb

楼主好！我是一个初学者刷到这个帖子，想请问一下：

__asm uint8_t atomic_wr8(uint8_t *mem, uint8_t val)
{
  mov    r2,r0
1
  ldrexb r0,[r2]           // r0 = *mem，r0 的值并没有用到，即读出的值无意义
  strexb r3,r1,[r2]       // *mem = val，若写操作成功，r3 值为 0
  cbz    r3,%F2           // r3 为 0，则向前跳转到2，函数返回
  b      %B1               // r3 不为0，则向后跳转到1，重复操作
2
  bx     lr                  
}

从程序上是不是可以理解成这并不是一个"读-修改-写"操作，而仅仅是一个8位数据的写操作？
下面这个函数是否也可以完成同样的功能？
__asm uint8_t wr8(uint8_t *mem, uint8_t val)
{
  strb   r1, [r0]     // *mem = val
}

请问楼主，下面这个函数的执行不是原子操作吗？

wy_nb

wy_nb 发表于 2023-2-28 14:58
楼主好！我是一个初学者刷到这个帖子，想请问一下：

__asm uint8_t atomic_wr8(uint8_t *mem, uint8_t v ...

不好意思，我理解错了，我没注意函数的返回值；atomic_wr8 函数返回的是读出值，这个函数是一个“读-修改-写”的操作！

tcs_stm32

搜索了下这两条指令，就明白什么原理了.
(25条消息) ARM平台下独占访问指令LDREX和STREX的原理与使用详解_ldrex用法_Roland_Sun的博客-CSDN博客

saii

想请问一下__CC_ARM这个macro是GCC吗

eric2013

saii 发表于 2023-4-13 07:52
想请问一下__CC_ARM这个macro是GCC吗

__GNUC__          GCC
__CC_ARM          MDK
__ICCARM__       IAR

黄毅7789

请教下您，原子变量能否会被中断打断？比如，在线程中对变量a进行读，在中断中对变量a进行写，是否能够实现在线程读变量a时，中断会等待变量a读完再对变量a进行写？

关于对32为变量修改还是不明白，能否做一个降低的示例？先“atomic_clr32”清零，再“atomic_set32 ”写入？在清零完成之后写入之前是否还是原子状态？