OSDN Git Service

PR target/53020
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / sync.md
1 ;; GCC machine description for i386 synchronization instructions.
2 ;; Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 ;; Free Software Foundation, Inc.
4 ;;
5 ;; This file is part of GCC.
6 ;;
7 ;; GCC is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 3, or (at your option)
10 ;; any later version.
11 ;;
12 ;; GCC is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 ;; GNU General Public License for more details.
16 ;;
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING3.  If not see
19 ;; <http://www.gnu.org/licenses/>.
20
21 (define_c_enum "unspec" [
22   UNSPEC_LFENCE
23   UNSPEC_SFENCE
24   UNSPEC_MFENCE
25   UNSPEC_MOVA   ; For __atomic support
26   UNSPEC_LDA
27   UNSPEC_STA
28 ])
29
30 (define_c_enum "unspecv" [
31   UNSPECV_CMPXCHG_1
32   UNSPECV_CMPXCHG_2
33   UNSPECV_CMPXCHG_3
34   UNSPECV_CMPXCHG_4
35   UNSPECV_XCHG
36   UNSPECV_LOCK
37 ])
38
39 (define_expand "sse2_lfence"
40   [(set (match_dup 0)
41         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
42   "TARGET_SSE2"
43 {
44   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
45   MEM_VOLATILE_P (operands[0]) = 1;
46 })
47
48 (define_insn "*sse2_lfence"
49   [(set (match_operand:BLK 0 "" "")
50         (unspec:BLK [(match_dup 0)] UNSPEC_LFENCE))]
51   "TARGET_SSE2"
52   "lfence"
53   [(set_attr "type" "sse")
54    (set_attr "length_address" "0")
55    (set_attr "atom_sse_attr" "lfence")
56    (set_attr "memory" "unknown")])
57
58 (define_expand "sse_sfence"
59   [(set (match_dup 0)
60         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
61   "TARGET_SSE || TARGET_3DNOW_A"
62 {
63   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
64   MEM_VOLATILE_P (operands[0]) = 1;
65 })
66
67 (define_insn "*sse_sfence"
68   [(set (match_operand:BLK 0 "" "")
69         (unspec:BLK [(match_dup 0)] UNSPEC_SFENCE))]
70   "TARGET_SSE || TARGET_3DNOW_A"
71   "sfence"
72   [(set_attr "type" "sse")
73    (set_attr "length_address" "0")
74    (set_attr "atom_sse_attr" "fence")
75    (set_attr "memory" "unknown")])
76
77 (define_expand "sse2_mfence"
78   [(set (match_dup 0)
79         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
80   "TARGET_SSE2"
81 {
82   operands[0] = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
83   MEM_VOLATILE_P (operands[0]) = 1;
84 })
85
86 (define_insn "mfence_sse2"
87   [(set (match_operand:BLK 0 "" "")
88         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))]
89   "TARGET_64BIT || TARGET_SSE2"
90   "mfence"
91   [(set_attr "type" "sse")
92    (set_attr "length_address" "0")
93    (set_attr "atom_sse_attr" "fence")
94    (set_attr "memory" "unknown")])
95
96 (define_insn "mfence_nosse"
97   [(set (match_operand:BLK 0 "" "")
98         (unspec:BLK [(match_dup 0)] UNSPEC_MFENCE))
99    (clobber (reg:CC FLAGS_REG))]
100   "!(TARGET_64BIT || TARGET_SSE2)"
101   "lock{%;} or{l}\t{$0, (%%esp)|DWORD PTR [esp], 0}"
102   [(set_attr "memory" "unknown")])
103
104 (define_expand "mem_thread_fence"
105   [(match_operand:SI 0 "const_int_operand" "")]         ;; model
106   ""
107 {
108   /* Unless this is a SEQ_CST fence, the i386 memory model is strong
109      enough not to require barriers of any kind.  */
110   if (INTVAL (operands[0]) == MEMMODEL_SEQ_CST)
111     {
112       rtx (*mfence_insn)(rtx);
113       rtx mem;
114
115       if (TARGET_64BIT || TARGET_SSE2)
116         mfence_insn = gen_mfence_sse2;
117       else
118         mfence_insn = gen_mfence_nosse;
119
120       mem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
121       MEM_VOLATILE_P (mem) = 1;
122
123       emit_insn (mfence_insn (mem));
124     }
125   DONE;
126 })
127
128 ;; ??? From volume 3 section 8.1.1 Guaranteed Atomic Operations,
129 ;; Only beginning at Pentium family processors do we get any guarantee of
130 ;; atomicity in aligned 64-bit quantities.  Beginning at P6, we get a
131 ;; guarantee for 64-bit accesses that do not cross a cacheline boundary.
132 ;;
133 ;; Note that the TARGET_CMPXCHG8B test below is a stand-in for "Pentium".
134 ;;
135 ;; Importantly, *no* processor makes atomicity guarantees for larger
136 ;; accesses.  In particular, there's no way to perform an atomic TImode
137 ;; move, despite the apparent applicability of MOVDQA et al.
138
139 (define_mode_iterator ATOMIC
140    [QI HI SI
141     (DI "TARGET_64BIT || (TARGET_CMPXCHG8B && (TARGET_80387 || TARGET_SSE))")
142    ])
143
144 (define_expand "atomic_load<mode>"
145   [(set (match_operand:ATOMIC 0 "register_operand" "")
146         (unspec:ATOMIC [(match_operand:ATOMIC 1 "memory_operand" "")
147                         (match_operand:SI 2 "const_int_operand" "")]
148                        UNSPEC_MOVA))]
149   ""
150 {
151   /* For DImode on 32-bit, we can use the FPU to perform the load.  */
152   if (<MODE>mode == DImode && !TARGET_64BIT)
153     emit_insn (gen_atomic_loaddi_fpu
154                (operands[0], operands[1],
155                 assign_386_stack_local (DImode,
156                                         (virtuals_instantiated
157                                          ? SLOT_TEMP : SLOT_VIRTUAL))));
158   else
159     emit_move_insn (operands[0], operands[1]);
160   DONE;
161 })
162
163 (define_insn_and_split "atomic_loaddi_fpu"
164   [(set (match_operand:DI 0 "nonimmediate_operand" "=x,m,?r")
165         (unspec:DI [(match_operand:DI 1 "memory_operand" "m,m,m")]
166                    UNSPEC_MOVA))
167    (clobber (match_operand:DI 2 "memory_operand" "=X,X,m"))
168    (clobber (match_scratch:DF 3 "=X,xf,xf"))]
169   "!TARGET_64BIT && (TARGET_80387 || TARGET_SSE)"
170   "#"
171   "&& reload_completed"
172   [(const_int 0)]
173 {
174   rtx dst = operands[0], src = operands[1];
175   rtx mem = operands[2], tmp = operands[3];
176
177   if (SSE_REG_P (dst))
178     emit_move_insn (dst, src);
179   else
180     {
181       if (MEM_P (dst))
182         mem = dst;
183
184       if (FP_REG_P (tmp))
185         {
186           emit_insn (gen_loaddi_via_fpu (tmp, src));
187           emit_insn (gen_storedi_via_fpu (mem, tmp));
188         }
189       else
190         {
191           adjust_reg_mode (tmp, DImode);
192           emit_move_insn (tmp, src);
193           emit_move_insn (mem, tmp);
194         }
195
196       if (mem != dst)
197         emit_move_insn (dst, mem);
198     }
199   DONE;
200 })
201
202 (define_expand "atomic_store<mode>"
203   [(set (match_operand:ATOMIC 0 "memory_operand" "")
204         (unspec:ATOMIC [(match_operand:ATOMIC 1 "register_operand" "")
205                         (match_operand:SI 2 "const_int_operand" "")]
206                        UNSPEC_MOVA))]
207   ""
208 {
209   enum memmodel model = (enum memmodel) INTVAL (operands[2]);
210
211   if (<MODE>mode == DImode && !TARGET_64BIT)
212     {
213       /* For DImode on 32-bit, we can use the FPU to perform the store.  */
214       /* Note that while we could perform a cmpxchg8b loop, that turns
215          out to be significantly larger than this plus a barrier.  */
216       emit_insn (gen_atomic_storedi_fpu
217                  (operands[0], operands[1],
218                   assign_386_stack_local (DImode,
219                                           (virtuals_instantiated
220                                            ? SLOT_TEMP : SLOT_VIRTUAL))));
221     }
222   else
223     {
224       /* For seq-cst stores, when we lack MFENCE, use XCHG.  */
225       if (model == MEMMODEL_SEQ_CST && !(TARGET_64BIT || TARGET_SSE2))
226         {
227           emit_insn (gen_atomic_exchange<mode> (gen_reg_rtx (<MODE>mode),
228                                                 operands[0], operands[1],
229                                                 operands[2]));
230           DONE;
231         }
232
233       /* Otherwise use a normal store.  */
234       emit_move_insn (operands[0], operands[1]);
235     }
236   /* ... followed by an MFENCE, if required.  */
237   if (model == MEMMODEL_SEQ_CST)
238     emit_insn (gen_mem_thread_fence (operands[2]));
239   DONE;
240 })
241
242 (define_insn_and_split "atomic_storedi_fpu"
243   [(set (match_operand:DI 0 "memory_operand" "=m,m,m")
244         (unspec:DI [(match_operand:DI 1 "register_operand" "x,m,?r")]
245                    UNSPEC_MOVA))
246    (clobber (match_operand:DI 2 "memory_operand" "=X,X,m"))
247    (clobber (match_scratch:DF 3 "=X,xf,xf"))]
248   "!TARGET_64BIT && (TARGET_80387 || TARGET_SSE)"
249   "#"
250   "&& reload_completed"
251   [(const_int 0)]
252 {
253   rtx dst = operands[0], src = operands[1];
254   rtx mem = operands[2], tmp = operands[3];
255
256   if (!SSE_REG_P (src))
257     {
258       if (REG_P (src))
259         {
260           emit_move_insn (mem, src);
261           src = mem;
262         }
263
264       if (FP_REG_P (tmp))
265         {
266           emit_insn (gen_loaddi_via_fpu (tmp, src));
267           emit_insn (gen_storedi_via_fpu (dst, tmp));
268           DONE;
269         }
270       else
271         {
272           adjust_reg_mode (tmp, DImode);
273           emit_move_insn (tmp, mem);
274           src = tmp;
275         }
276     }
277   emit_move_insn (dst, src);
278   DONE;
279 })
280
281 ;; ??? You'd think that we'd be able to perform this via FLOAT + FIX_TRUNC
282 ;; operations.  But the fix_trunc patterns want way more setup than we want
283 ;; to provide.  Note that the scratch is DFmode instead of XFmode in order
284 ;; to make it easy to allocate a scratch in either SSE or FP_REGs above.
285
286 (define_insn "loaddi_via_fpu"
287   [(set (match_operand:DF 0 "register_operand" "=f")
288         (unspec:DF [(match_operand:DI 1 "memory_operand" "m")] UNSPEC_LDA))]
289   "TARGET_80387"
290   "fild%Z1\t%1"
291   [(set_attr "type" "fmov")
292    (set_attr "mode" "DF")
293    (set_attr "fp_int_src" "true")])
294
295 (define_insn "storedi_via_fpu"
296   [(set (match_operand:DI 0 "memory_operand" "=m")
297         (unspec:DI [(match_operand:DF 1 "register_operand" "f")] UNSPEC_STA))]
298   "TARGET_80387"
299 {
300   gcc_assert (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != NULL_RTX);
301
302   return "fistp%Z0\t%0";
303 }
304   [(set_attr "type" "fmov")
305    (set_attr "mode" "DI")])
306
307 (define_expand "atomic_compare_and_swap<mode>"
308   [(match_operand:QI 0 "register_operand" "")           ;; bool success output
309    (match_operand:SWI124 1 "register_operand" "")       ;; oldval output
310    (match_operand:SWI124 2 "memory_operand" "")         ;; memory
311    (match_operand:SWI124 3 "register_operand" "")       ;; expected input
312    (match_operand:SWI124 4 "register_operand" "")       ;; newval input
313    (match_operand:SI 5 "const_int_operand" "")          ;; is_weak
314    (match_operand:SI 6 "const_int_operand" "")          ;; success model
315    (match_operand:SI 7 "const_int_operand" "")]         ;; failure model
316   "TARGET_CMPXCHG"
317 {
318   emit_insn (gen_atomic_compare_and_swap_single<mode>
319              (operands[1], operands[2], operands[3], operands[4]));
320   ix86_expand_setcc (operands[0], EQ, gen_rtx_REG (CCZmode, FLAGS_REG),
321                      const0_rtx);
322   DONE;
323 })
324
325 (define_mode_iterator CASMODE
326   [(DI "TARGET_64BIT || TARGET_CMPXCHG8B")
327    (TI "TARGET_64BIT && TARGET_CMPXCHG16B")])
328 (define_mode_iterator DCASMODE
329   [(DI "!TARGET_64BIT && TARGET_CMPXCHG8B && !flag_pic")
330    (TI "TARGET_64BIT && TARGET_CMPXCHG16B")])
331 (define_mode_attr doublemodesuffix [(DI "8") (TI "16")])
332 (define_mode_attr DCASHMODE [(DI "SI") (TI "DI")])
333
334 (define_expand "atomic_compare_and_swap<mode>"
335   [(match_operand:QI 0 "register_operand" "")           ;; bool success output
336    (match_operand:CASMODE 1 "register_operand" "")      ;; oldval output
337    (match_operand:CASMODE 2 "memory_operand" "")        ;; memory
338    (match_operand:CASMODE 3 "register_operand" "")      ;; expected input
339    (match_operand:CASMODE 4 "register_operand" "")      ;; newval input
340    (match_operand:SI 5 "const_int_operand" "")          ;; is_weak
341    (match_operand:SI 6 "const_int_operand" "")          ;; success model
342    (match_operand:SI 7 "const_int_operand" "")]         ;; failure model
343   "TARGET_CMPXCHG"
344 {
345   if (<MODE>mode == DImode && TARGET_64BIT)
346     {
347       emit_insn (gen_atomic_compare_and_swap_singledi
348                  (operands[1], operands[2], operands[3], operands[4]));
349     }
350   else
351     {
352       enum machine_mode hmode = <DCASHMODE>mode;
353       rtx lo_o, lo_e, lo_n, hi_o, hi_e, hi_n, mem;
354
355       lo_o = operands[1];
356       mem  = operands[2];
357       lo_e = operands[3];
358       lo_n = operands[4];
359       hi_o = gen_highpart (hmode, lo_o);
360       hi_e = gen_highpart (hmode, lo_e);
361       hi_n = gen_highpart (hmode, lo_n);
362       lo_o = gen_lowpart (hmode, lo_o);
363       lo_e = gen_lowpart (hmode, lo_e);
364       lo_n = gen_lowpart (hmode, lo_n);
365
366       if (<MODE>mode == DImode
367           && !TARGET_64BIT
368           && flag_pic
369           && !cmpxchg8b_pic_memory_operand (mem, DImode))
370         mem = replace_equiv_address (mem, force_reg (Pmode, XEXP (mem, 0)));
371
372       emit_insn (gen_atomic_compare_and_swap_double<mode>
373                  (lo_o, hi_o, mem, lo_e, hi_e, lo_n, hi_n));
374     }
375   ix86_expand_setcc (operands[0], EQ, gen_rtx_REG (CCZmode, FLAGS_REG),
376                      const0_rtx);
377   DONE;
378 })
379
380 (define_insn "atomic_compare_and_swap_single<mode>"
381   [(set (match_operand:SWI 0 "register_operand" "=a")
382         (unspec_volatile:SWI
383           [(match_operand:SWI 1 "memory_operand" "+m")
384            (match_operand:SWI 2 "register_operand" "0")
385            (match_operand:SWI 3 "register_operand" "<r>")]
386           UNSPECV_CMPXCHG_1))
387    (set (match_dup 1)
388         (unspec_volatile:SWI [(const_int 0)] UNSPECV_CMPXCHG_2))
389    (set (reg:CCZ FLAGS_REG)
390         (unspec_volatile:CCZ [(const_int 0)] UNSPECV_CMPXCHG_3))]
391   "TARGET_CMPXCHG"
392   "lock{%;} cmpxchg{<imodesuffix>}\t{%3, %1|%1, %3}")
393
394 ;; For double-word compare and swap, we are obliged to play tricks with
395 ;; the input newval (op5:op6) because the Intel register numbering does
396 ;; not match the gcc register numbering, so the pair must be CX:BX.
397 ;; That said, in order to take advantage of possible lower-subreg opts,
398 ;; treat all of the integral operands in the same way.
399 (define_insn "atomic_compare_and_swap_double<mode>"
400   [(set (match_operand:<DCASHMODE> 0 "register_operand" "=a")
401         (unspec_volatile:<DCASHMODE>
402           [(match_operand:DCASMODE 2 "memory_operand" "+m")
403            (match_operand:<DCASHMODE> 3 "register_operand" "0")
404            (match_operand:<DCASHMODE> 4 "register_operand" "1")
405            (match_operand:<DCASHMODE> 5 "register_operand" "b")
406            (match_operand:<DCASHMODE> 6 "register_operand" "c")]
407           UNSPECV_CMPXCHG_1))
408    (set (match_operand:<DCASHMODE> 1 "register_operand" "=d")
409         (unspec_volatile:<DCASHMODE> [(const_int 0)] UNSPECV_CMPXCHG_2))
410    (set (match_dup 2)
411         (unspec_volatile:DCASMODE [(const_int 0)] UNSPECV_CMPXCHG_3))
412    (set (reg:CCZ FLAGS_REG)
413         (unspec_volatile:CCZ [(const_int 0)] UNSPECV_CMPXCHG_4))]
414   ""
415   "lock{%;} cmpxchg<doublemodesuffix>b\t%2")
416
417 ;; Theoretically we'd like to use constraint "r" (any reg) for op5,
418 ;; but that includes ecx.  If op5 and op6 are the same (like when
419 ;; the input is -1LL) GCC might chose to allocate op5 to ecx, like
420 ;; op6.  This breaks, as the xchg will move the PIC register contents
421 ;; to %ecx then --> boom.  Operands 5 and 6 really need to be different
422 ;; registers, which in this case means op5 must not be ecx.  Instead
423 ;; of playing tricks with fake early clobbers or the like we just
424 ;; enumerate all regs possible here, which (as this is !TARGET_64BIT)
425 ;; are just esi and edi.
426 (define_insn "*atomic_compare_and_swap_doubledi_pic"
427   [(set (match_operand:SI 0 "register_operand" "=a")
428         (unspec_volatile:SI
429           [(match_operand:DI 2 "cmpxchg8b_pic_memory_operand" "+m")
430            (match_operand:SI 3 "register_operand" "0")
431            (match_operand:SI 4 "register_operand" "1")
432            (match_operand:SI 5 "register_operand" "SD")
433            (match_operand:SI 6 "register_operand" "c")]
434           UNSPECV_CMPXCHG_1))
435    (set (match_operand:SI 1 "register_operand" "=d")
436         (unspec_volatile:SI [(const_int 0)] UNSPECV_CMPXCHG_2))
437    (set (match_dup 2)
438         (unspec_volatile:DI [(const_int 0)] UNSPECV_CMPXCHG_3))
439    (set (reg:CCZ FLAGS_REG)
440         (unspec_volatile:CCZ [(const_int 0)] UNSPECV_CMPXCHG_4))]
441   "!TARGET_64BIT && TARGET_CMPXCHG8B && flag_pic"
442   "xchg{l}\t%%ebx, %5\;lock{%;} cmpxchg8b\t%2\;xchg{l}\t%%ebx, %5")
443
444 ;; For operand 2 nonmemory_operand predicate is used instead of
445 ;; register_operand to allow combiner to better optimize atomic
446 ;; additions of constants.
447 (define_insn "atomic_fetch_add<mode>"
448   [(set (match_operand:SWI 0 "register_operand" "=<r>")
449         (unspec_volatile:SWI
450           [(match_operand:SWI 1 "memory_operand" "+m")
451            (match_operand:SI 3 "const_int_operand" "")]         ;; model
452           UNSPECV_XCHG))
453    (set (match_dup 1)
454         (plus:SWI (match_dup 1)
455                   (match_operand:SWI 2 "nonmemory_operand" "0")))
456    (clobber (reg:CC FLAGS_REG))]
457   "TARGET_XADD"
458   "lock{%;} xadd{<imodesuffix>}\t{%0, %1|%1, %0}")
459
460 ;; This peephole2 and following insn optimize
461 ;; __sync_fetch_and_add (x, -N) == N into just lock {add,sub,inc,dec}
462 ;; followed by testing of flags instead of lock xadd and comparisons.
463 (define_peephole2
464   [(set (match_operand:SWI 0 "register_operand" "")
465         (match_operand:SWI 2 "const_int_operand" ""))
466    (parallel [(set (match_dup 0)
467                    (unspec_volatile:SWI
468                      [(match_operand:SWI 1 "memory_operand" "")
469                       (match_operand:SI 4 "const_int_operand" "")]
470                      UNSPECV_XCHG))
471               (set (match_dup 1)
472                    (plus:SWI (match_dup 1)
473                              (match_dup 0)))
474               (clobber (reg:CC FLAGS_REG))])
475    (set (reg:CCZ FLAGS_REG)
476         (compare:CCZ (match_dup 0)
477                      (match_operand:SWI 3 "const_int_operand" "")))]
478   "peep2_reg_dead_p (3, operands[0])
479    && (unsigned HOST_WIDE_INT) INTVAL (operands[2])
480       == -(unsigned HOST_WIDE_INT) INTVAL (operands[3])
481    && !reg_overlap_mentioned_p (operands[0], operands[1])"
482   [(parallel [(set (reg:CCZ FLAGS_REG)
483                    (compare:CCZ
484                      (unspec_volatile:SWI [(match_dup 1) (match_dup 4)]
485                                           UNSPECV_XCHG)
486                      (match_dup 3)))
487               (set (match_dup 1)
488                    (plus:SWI (match_dup 1)
489                              (match_dup 2)))])])
490
491 (define_insn "*atomic_fetch_add_cmp<mode>"
492   [(set (reg:CCZ FLAGS_REG)
493         (compare:CCZ (unspec_volatile:SWI
494                        [(match_operand:SWI 0 "memory_operand" "+m")
495                         (match_operand:SI 3 "const_int_operand" "")]
496                        UNSPECV_XCHG)
497                      (match_operand:SWI 2 "const_int_operand" "i")))
498    (set (match_dup 0)
499         (plus:SWI (match_dup 0)
500                   (match_operand:SWI 1 "const_int_operand" "i")))]
501   "(unsigned HOST_WIDE_INT) INTVAL (operands[1])
502    == -(unsigned HOST_WIDE_INT) INTVAL (operands[2])"
503 {
504   if (TARGET_USE_INCDEC)
505     {
506       if (operands[1] == const1_rtx)
507         return "lock{%;} inc{<imodesuffix>}\t%0";
508       if (operands[1] == constm1_rtx)
509         return "lock{%;} dec{<imodesuffix>}\t%0";
510     }
511
512   if (x86_maybe_negate_const_int (&operands[1], <MODE>mode))
513     return "lock{%;} sub{<imodesuffix>}\t{%1, %0|%0, %1}";
514
515   return "lock{%;} add{<imodesuffix>}\t{%1, %0|%0, %1}";
516 })
517
518 ;; Recall that xchg implicitly sets LOCK#, so adding it again wastes space.
519 ;; In addition, it is always a full barrier, so we can ignore the memory model.
520 (define_insn "atomic_exchange<mode>"
521   [(set (match_operand:SWI 0 "register_operand" "=<r>")         ;; output
522         (unspec_volatile:SWI
523           [(match_operand:SWI 1 "memory_operand" "+m")          ;; memory
524            (match_operand:SI 3 "const_int_operand" "")]         ;; model
525           UNSPECV_XCHG))
526    (set (match_dup 1)
527         (match_operand:SWI 2 "register_operand" "0"))]          ;; input
528   ""
529   "xchg{<imodesuffix>}\t{%1, %0|%0, %1}")
530
531 (define_insn "atomic_add<mode>"
532   [(set (match_operand:SWI 0 "memory_operand" "+m")
533         (unspec_volatile:SWI
534           [(plus:SWI (match_dup 0)
535                      (match_operand:SWI 1 "nonmemory_operand" "<r><i>"))
536            (match_operand:SI 2 "const_int_operand" "")]         ;; model
537           UNSPECV_LOCK))
538    (clobber (reg:CC FLAGS_REG))]
539   ""
540 {
541   if (TARGET_USE_INCDEC)
542     {
543       if (operands[1] == const1_rtx)
544         return "lock{%;} inc{<imodesuffix>}\t%0";
545       if (operands[1] == constm1_rtx)
546         return "lock{%;} dec{<imodesuffix>}\t%0";
547     }
548
549   if (x86_maybe_negate_const_int (&operands[1], <MODE>mode))
550     return "lock{%;} sub{<imodesuffix>}\t{%1, %0|%0, %1}";
551
552   return "lock{%;} add{<imodesuffix>}\t{%1, %0|%0, %1}";
553 })
554
555 (define_insn "atomic_sub<mode>"
556   [(set (match_operand:SWI 0 "memory_operand" "+m")
557         (unspec_volatile:SWI
558           [(minus:SWI (match_dup 0)
559                       (match_operand:SWI 1 "nonmemory_operand" "<r><i>"))
560            (match_operand:SI 2 "const_int_operand" "")]         ;; model
561           UNSPECV_LOCK))
562    (clobber (reg:CC FLAGS_REG))]
563   ""
564 {
565   if (TARGET_USE_INCDEC)
566     {
567       if (operands[1] == const1_rtx)
568         return "lock{%;} dec{<imodesuffix>}\t%0";
569       if (operands[1] == constm1_rtx)
570         return "lock{%;} inc{<imodesuffix>}\t%0";
571     }
572
573   if (x86_maybe_negate_const_int (&operands[1], <MODE>mode))
574     return "lock{%;} add{<imodesuffix>}\t{%1, %0|%0, %1}";
575
576   return "lock{%;} sub{<imodesuffix>}\t{%1, %0|%0, %1}";
577 })
578
579 (define_insn "atomic_<logic><mode>"
580   [(set (match_operand:SWI 0 "memory_operand" "+m")
581         (unspec_volatile:SWI
582           [(any_logic:SWI (match_dup 0)
583                           (match_operand:SWI 1 "nonmemory_operand" "<r><i>"))
584            (match_operand:SI 2 "const_int_operand" "")]         ;; model
585           UNSPECV_LOCK))
586    (clobber (reg:CC FLAGS_REG))]
587   ""
588   "lock{%;} <logic>{<imodesuffix>}\t{%1, %0|%0, %1}")