Branch data Line data Source code
1 : : ;; GCC machine description for MMX and 3dNOW! instructions
2 : : ;; Copyright (C) 2005-2024 Free Software Foundation, Inc.
3 : : ;;
4 : : ;; This file is part of GCC.
5 : : ;;
6 : : ;; GCC is free software; you can redistribute it and/or modify
7 : : ;; it under the terms of the GNU General Public License as published by
8 : : ;; the Free Software Foundation; either version 3, or (at your option)
9 : : ;; any later version.
10 : : ;;
11 : : ;; GCC is distributed in the hope that it will be useful,
12 : : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : ;; GNU General Public License for more details.
15 : : ;;
16 : : ;; You should have received a copy of the GNU General Public License
17 : : ;; along with GCC; see the file COPYING3. If not see
18 : : ;; <http://www.gnu.org/licenses/>.
19 : :
20 : : ;; The MMX and 3dNOW! patterns are in the same file because they use
21 : : ;; the same register file, and 3dNOW! adds a number of extensions to
22 : : ;; the base integer MMX isa.
23 : :
24 : : ;; Note! Except for the basic move instructions, *all* of these
25 : : ;; patterns are outside the normal optabs namespace. This is because
26 : : ;; use of these registers requires the insertion of emms or femms
27 : : ;; instructions to return to normal fpu mode. The compiler doesn't
28 : : ;; know how to do that itself, which means it's up to the user. Which
29 : : ;; means that we should never use any of these patterns except at the
30 : : ;; direction of the user via a builtin.
31 : :
32 : : (define_c_enum "unspec" [
33 : : UNSPEC_MOVNTQ
34 : : UNSPEC_PFRCP
35 : : UNSPEC_PFRCPIT1
36 : : UNSPEC_PFRCPIT2
37 : : UNSPEC_PFRSQRT
38 : : UNSPEC_PFRSQIT1
39 : : ])
40 : :
41 : : (define_c_enum "unspecv" [
42 : : UNSPECV_EMMS
43 : : UNSPECV_FEMMS
44 : : ])
45 : :
46 : : ;; 8 byte integral modes handled by MMX (and by extension, SSE)
47 : : (define_mode_iterator MMXMODEI [V8QI V4HI V2SI])
48 : 136 : (define_mode_iterator MMXMODEI8 [V8QI V4HI V2SI (V1DI "TARGET_SSE2")])
49 : :
50 : : ;; All 8-byte vector modes handled by MMX
51 : : (define_mode_iterator MMXMODE [V8QI V4HI V2SI V1DI V2SF V4HF V4BF])
52 : 5341 : (define_mode_iterator MMXMODE124 [V8QI V4HI V2SI V2SF])
53 : 5341 :
54 : 5341 : ;; Mix-n-match
55 : : (define_mode_iterator MMXMODE12 [V8QI V4HI])
56 : : (define_mode_iterator MMXMODE14 [V8QI V2SI])
57 : : (define_mode_iterator MMXMODE24 [V4HI V2SI])
58 : : (define_mode_iterator MMXMODE248 [V4HI V2SI V1DI])
59 : :
60 : : ;; All 4-byte integer/float16 vector modes
61 : : (define_mode_iterator V_32 [V4QI V2HI V1SI V2HF V2BF])
62 : :
63 : : (define_mode_iterator V2FI_32 [V2HF V2BF V2HI])
64 : : (define_mode_iterator V4FI_64 [V4HF V4BF V4HI])
65 : : (define_mode_iterator V4F_64 [V4HF V4BF])
66 : : (define_mode_iterator V2F_32 [V2HF V2BF])
67 : : ;; 4-byte integer vector modes
68 : : (define_mode_iterator VI_32 [V4QI V2HI])
69 : :
70 : : ;; 4-byte and 2-byte integer vector modes
71 : : (define_mode_iterator VI_16_32 [V4QI V2QI V2HI])
72 : :
73 : : ;; 4-byte and 2-byte QImode vector modes
74 : : (define_mode_iterator VI1_16_32 [V4QI V2QI])
75 : :
76 : : ;; All 2-byte, 4-byte and 8-byte vector modes with more than 1 element
77 : : (define_mode_iterator V_16_32_64
78 : : [V2QI V4QI V2HI V2HF
79 : 1011 : (V8QI "TARGET_64BIT") (V4HI "TARGET_64BIT")
80 : 48 : (V4HF "TARGET_64BIT") (V4BF "TARGET_64BIT")
81 : 36308 : (V2SI "TARGET_64BIT") (V2SF "TARGET_64BIT")])
82 : :
83 : 28871635 : ;; V2S* modes
84 : 28871635 : (define_mode_iterator V2FI [V2SF V2SI])
85 : 46365608 :
86 : 72992883 : (define_mode_iterator V24FI [V2SF V2SI V4HF V4HI])
87 : 44062507 :
88 : 26567617 : (define_mode_iterator V248FI [V2SF V2SI V4HF V4BF V4HI V8QI])
89 : :
90 : : (define_mode_iterator V24FI_32 [V2HF V2BF V2HI V4QI])
91 : :
92 : : ;; Mapping from integer vector mode to mnemonic suffix
93 : : (define_mode_attr mmxvecsize
94 : : [(V8QI "b") (V4QI "b") (V2QI "b")
95 : : (V4HI "w") (V2HI "w") (V2SI "d") (V1DI "q")])
96 : :
97 : : ;; Mapping to same size integral mode.
98 : : (define_mode_attr mmxinsnmode
99 : : [(V8QI "DI") (V4QI "SI") (V2QI "HI")
100 : : (V4HI "DI") (V2HI "SI")
101 : : (V2SI "DI")
102 : : (V4HF "DI") (V2HF "SI")
103 : : (V4BF "DI") (V2BF "SI")
104 : : (V2SF "DI")])
105 : :
106 : : (define_mode_attr mmxdoublemode
107 : : [(V8QI "V8HI") (V4HI "V4SI")])
108 : :
109 : : ;; Mapping of vector float modes to an integer mode of the same size
110 : : (define_mode_attr mmxintvecmode
111 : : [(V2SF "V2SI") (V2SI "V2SI") (V4HI "V4HI") (V8QI "V8QI")
112 : : (V4HF "V4HI") (V2HF "V2HI")])
113 : :
114 : : (define_mode_attr mmxintvecmodelower
115 : : [(V2SF "v2si") (V2SI "v2si") (V4HI "v4hi") (V8QI "v8qi")
116 : : (V4HF "v4hi") (V2HF "v2hi")])
117 : :
118 : : ;; Mapping of vector modes to a vector mode of double size
119 : : (define_mode_attr mmxdoublevecmode
120 : : [(V2SF "V4SF") (V2SI "V4SI") (V4HF "V8HF") (V4HI "V8HI")
121 : : (V2HI "V4HI") (V2HF "V4HF") (V2BF "V4BF")])
122 : :
123 : : ;; Mapping of vector modes back to the scalar modes
124 : : (define_mode_attr mmxscalarmode
125 : : [(V2SI "SI") (V2SF "SF")
126 : : (V4HF "HF") (V4BF "BF")
127 : : (V2HF "HF") (V2BF "BF")
128 : : (V4HI "HI") (V2HI "HI")
129 : : (V8QI "QI")])
130 : :
131 : : (define_mode_attr mmxscalarmodelower
132 : : [(V2SI "si") (V2SF "sf")
133 : : (V4HF "hf") (V4BF "bf")
134 : : (V2HF "hf") (V2BF "bf")
135 : : (V4HI "hi") (V2HI "hi")
136 : : (V8QI "qi")])
137 : :
138 : : (define_mode_attr Yv_Yw
139 : : [(V8QI "Yw") (V4HI "Yw") (V2SI "Yv") (V1DI "Yv") (V2SF "Yv")])
140 : :
141 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
142 : : ;;
143 : : ;; Move patterns
144 : : ;;
145 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
146 : :
147 : : ;; All of these patterns are enabled for MMX as well as 3dNOW.
148 : : ;; This is essential for maintaining stable calling conventions.
149 : :
150 : : (define_expand "mov<mode>"
151 : : [(set (match_operand:MMXMODE 0 "nonimmediate_operand")
152 : : (match_operand:MMXMODE 1 "nonimmediate_operand"))]
153 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
154 : 498648 : {
155 : 37796 : ix86_expand_vector_move (<MODE>mode, operands);
156 : 498648 : DONE;
157 : : })
158 : :
159 : : (define_insn "*mov<mode>_internal"
160 : : [(set (match_operand:MMXMODE 0 "nonimmediate_operand"
161 : : "=r ,o ,r,r ,m ,?!y,!y,?!y,m ,r ,?!y,v,v,v,m,r,v,!y,*x")
162 : : (match_operand:MMXMODE 1 "nonimm_or_0_operand"
163 : : "rCo,rC,C,rm,rC,C ,!y,m ,?!y,?!y,r ,C,v,m,v,v,r,*x,!y"))]
164 : 59261669 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
165 : 68424806 : && !(MEM_P (operands[0]) && MEM_P (operands[1]))
166 : 68180328 : && ix86_hardreg_mov_ok (operands[0], operands[1])"
167 : 260551 : {
168 : 23711279 : switch (get_attr_type (insn))
169 : 678098 : {
170 : 23452155 : case TYPE_MULTI:
171 : 13364076 : return "#";
172 : 9660811 :
173 : 23033954 : case TYPE_IMOV:
174 : 534348 : if (get_attr_mode (insn) == MODE_SI)
175 : 666 : return "mov{l}\t{%1, %k0|%k0, %1}";
176 : : else
177 : 534944 : return "mov{q}\t{%1, %0|%0, %1}";
178 : 461518 :
179 : 460233 : case TYPE_MMX:
180 : 460899 : return "pxor\t%0, %0";
181 : 460852 :
182 : 461446 : case TYPE_MMXMOV:
183 : : /* Handle broken assemblers that require movd instead of movq. */
184 : 594 : if (!HAVE_AS_IX86_INTERUNIT_MOVQ
185 : : && (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])))
186 : : return "movd\t{%1, %0|%0, %1}";
187 : 594 : return "movq\t{%1, %0|%0, %1}";
188 : :
189 : 98 : case TYPE_SSECVT:
190 : 98 : if (SSE_REG_P (operands[0]))
191 : : return "movq2dq\t{%1, %0|%0, %1}";
192 : : else
193 : 41 : return "movdq2q\t{%1, %0|%0, %1}";
194 : :
195 : 2925 : case TYPE_SSELOG1:
196 : 2925 : return standard_sse_constant_opcode (insn, operands);
197 : :
198 : 183438 : case TYPE_SSEMOV:
199 : 183438 : return ix86_output_ssemov (insn, operands);
200 : :
201 : 0 : default:
202 : 0 : gcc_unreachable ();
203 : : }
204 : : }
205 : : [(set (attr "isa")
206 : : (cond [(eq_attr "alternative" "0,1")
207 : : (const_string "nox64")
208 : 265469 : (eq_attr "alternative" "2,3,4,9,10")
209 : : (const_string "x64")
210 : : (eq_attr "alternative" "15,16")
211 : : (const_string "x64_sse2")
212 : : (eq_attr "alternative" "17,18")
213 : : (const_string "sse2")
214 : : ]
215 : : (const_string "*")))
216 : : (set (attr "type")
217 : : (cond [(eq_attr "alternative" "0,1")
218 : : (const_string "multi")
219 : : (eq_attr "alternative" "2,3,4")
220 : : (const_string "imov")
221 : : (eq_attr "alternative" "5")
222 : : (const_string "mmx")
223 : : (eq_attr "alternative" "6,7,8,9,10")
224 : : (const_string "mmxmov")
225 : : (eq_attr "alternative" "11")
226 : : (const_string "sselog1")
227 : : (eq_attr "alternative" "17,18")
228 : : (const_string "ssecvt")
229 : : ]
230 : : (const_string "ssemov")))
231 : : (set (attr "prefix_rex")
232 : : (if_then_else (eq_attr "alternative" "9,10,15,16")
233 : : (const_string "1")
234 : : (const_string "*")))
235 : : (set (attr "prefix")
236 : : (if_then_else (eq_attr "type" "sselog1,ssemov")
237 : : (const_string "maybe_vex")
238 : : (const_string "orig")))
239 : : (set (attr "prefix_data16")
240 : : (if_then_else
241 : : (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI"))
242 : : (const_string "1")
243 : : (const_string "*")))
244 : : (set (attr "mode")
245 : : (cond [(eq_attr "alternative" "2")
246 : : (const_string "SI")
247 : : (eq_attr "alternative" "11,12")
248 : : (cond [(match_test "<MODE>mode == V2SFmode
249 : : || <MODE>mode == V4HFmode
250 : : || <MODE>mode == V4BFmode")
251 : : (const_string "V4SF")
252 : : (ior (not (match_test "TARGET_SSE2"))
253 : : (match_test "optimize_function_for_size_p (cfun)"))
254 : 42780 : (const_string "V4SF")
255 : : ]
256 : : (const_string "TI"))
257 : :
258 : : (and (eq_attr "alternative" "13")
259 : 1861519 : (ior (ior (and (match_test "<MODE>mode == V2SFmode")
260 : : (not (match_test "TARGET_MMX_WITH_SSE")))
261 : : (not (match_test "TARGET_SSE2")))
262 : : (match_test "<MODE>mode == V4HFmode
263 : : || <MODE>mode == V4BFmode")))
264 : : (const_string "V2SF")
265 : :
266 : : (and (eq_attr "alternative" "14")
267 : 5592495 : (ior (ior (match_test "<MODE>mode == V2SFmode")
268 : : (not (match_test "TARGET_SSE2")))
269 : : (match_test "<MODE>mode == V4HFmode
270 : : || <MODE>mode == V4BFmode")))
271 : : (const_string "V2SF")
272 : 5906719 : ]
273 : 5906719 : (const_string "DI")))
274 : 5906719 : (set (attr "preferred_for_speed")
275 : : (cond [(eq_attr "alternative" "9,15")
276 : 16659 : (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
277 : : (eq_attr "alternative" "10,16")
278 : 5745541 : (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
279 : : ]
280 : 330125 : (symbol_ref "true")))])
281 : :
282 : : (define_split
283 : : [(set (match_operand:MMXMODE 0 "nonimmediate_gr_operand")
284 : : (match_operand:MMXMODE 1 "nonimmediate_gr_operand"))]
285 : 94450 : "!TARGET_64BIT && reload_completed"
286 : 77055 : [(const_int 0)]
287 : 77055 : "ix86_split_long_move (operands); DONE;")
288 : :
289 : 895356 : (define_split
290 : 895356 : [(set (match_operand:MMXMODE 0 "nonimmediate_gr_operand")
291 : 620788 : (match_operand:MMXMODE 1 "const0_operand"))]
292 : 1112771 : "!TARGET_64BIT && reload_completed"
293 : 19588 : [(const_int 0)]
294 : 67152 : "ix86_split_long_move (operands); DONE;")
295 : 35321 :
296 : 65534 : (define_expand "movmisalign<mode>"
297 : 2515 : [(set (match_operand:MMXMODE 0 "nonimmediate_operand")
298 : 1641 : (match_operand:MMXMODE 1 "nonimmediate_operand"))]
299 : 80384 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
300 : 132487 : {
301 : 208919 : ix86_expand_vector_move (<MODE>mode, operands);
302 : 208919 : DONE;
303 : 0 : })
304 : 76432 :
305 : 3038 : (define_expand "mov<mode>"
306 : 19545 : [(set (match_operand:V_32 0 "nonimmediate_operand")
307 : : (match_operand:V_32 1 "nonimmediate_operand"))]
308 : 22583 : ""
309 : 22583 : {
310 : 0 : ix86_expand_vector_move (<MODE>mode, operands);
311 : 61697 : DONE;
312 : 3038 : })
313 : 3038 :
314 : : (define_insn "*mov<mode>_internal"
315 : : [(set (match_operand:V_32 0 "nonimmediate_operand"
316 : : "=r ,m ,v,v,v,m,r,v")
317 : : (match_operand:V_32 1 "general_operand"
318 : : "rmC,rC,C,v,m,v,v,r"))]
319 : 9620685 : "!(MEM_P (operands[0]) && MEM_P (operands[1]))
320 : 39478640 : && ix86_hardreg_mov_ok (operands[0], operands[1])"
321 : 19480 : {
322 : 18324456 : switch (get_attr_type (insn))
323 : 11174562 : {
324 : 7446896 : case TYPE_IMOV:
325 : 11166832 : return "mov{l}\t{%1, %0|%0, %1}";
326 : 158242 :
327 : 11166996 : case TYPE_SSELOG1:
328 : 158405 : return standard_sse_constant_opcode (insn, operands);
329 : 13360 :
330 : 14455 : case TYPE_SSEMOV:
331 : 6340 : return ix86_output_ssemov (insn, operands);
332 : 21475 :
333 : 13360 : default:
334 : 21475 : gcc_unreachable ();
335 : 8115 : }
336 : 0 : }
337 : 21475 : [(set (attr "isa")
338 : : (cond [(eq_attr "alternative" "6,7")
339 : : (const_string "sse2")
340 : 5445 : ]
341 : : (const_string "*")))
342 : : (set (attr "type")
343 : : (cond [(eq_attr "alternative" "2")
344 : : (const_string "sselog1")
345 : : (eq_attr "alternative" "3,4,5,6,7")
346 : : (const_string "ssemov")
347 : : ]
348 : : (const_string "imov")))
349 : : (set (attr "prefix")
350 : : (if_then_else (eq_attr "type" "sselog1,ssemov")
351 : : (const_string "maybe_vex")
352 : : (const_string "orig")))
353 : : (set (attr "prefix_data16")
354 : : (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "SI"))
355 : : (const_string "1")
356 : : (const_string "*")))
357 : : (set (attr "mode")
358 : : (cond [(eq_attr "alternative" "2,3")
359 : : (cond [(match_test "<MODE>mode == V2HFmode
360 : 119006 : || <MODE>mode == V2BFmode")
361 : : (const_string "V4SF")
362 : : (match_test "TARGET_AVX")
363 : : (const_string "TI")
364 : 25663 : (ior (not (match_test "TARGET_SSE2"))
365 : 11138 : (match_test "optimize_function_for_size_p (cfun)"))
366 : : (const_string "V4SF")
367 : : ]
368 : : (const_string "TI"))
369 : :
370 : : (and (eq_attr "alternative" "4,5")
371 : : (ior (match_test "<MODE>mode == V2HFmode
372 : : || <MODE>mode == V2BFmode")
373 : : (not (match_test "TARGET_SSE2"))))
374 : : (const_string "SF")
375 : : ]
376 : : (const_string "SI")))
377 : : (set (attr "preferred_for_speed")
378 : : (cond [(eq_attr "alternative" "6")
379 : : (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
380 : : (eq_attr "alternative" "7")
381 : : (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
382 : : ]
383 : : (symbol_ref "true")))])
384 : :
385 : : ;; 16-bit, 32-bit and 64-bit constant vector stores. After reload,
386 : : ;; convert them to immediate integer stores.
387 : : (define_insn_and_split "*mov<mode>_imm"
388 : : [(set (match_operand:V_16_32_64 0 "memory_operand" "=m")
389 : : (match_operand:V_16_32_64 1 "x86_64_const_vector_operand" "i"))]
390 : : ""
391 : : "#"
392 : 17970 : "&& reload_completed"
393 : 23378 : [(set (match_dup 0) (match_dup 1))]
394 : 23378 : {
395 : 23378 : HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (operands[1],
396 : 94592 : <MODE>mode);
397 : 117970 : operands[1] = GEN_INT (val);
398 : 104887 : operands[0] = lowpart_subreg (<mmxinsnmode>mode, operands[0], <MODE>mode);
399 : 174915 : })
400 : :
401 : : ;; For TARGET_64BIT we always round up to 8 bytes.
402 : 23378 : (define_insn "*push<mode>2_rex64"
403 : 23378 : [(set (match_operand:V_32 0 "push_operand" "=X,X")
404 : 109724493 : (match_operand:V_32 1 "nonmemory_no_elim_operand" "rC,*v"))]
405 : 109724494 : "TARGET_64BIT"
406 : 23378 : "@
407 : 168 : push{q}\t%q1
408 : 23546 : #"
409 : 23546 : [(set_attr "type" "push,multi")
410 : 57656341 : (set_attr "mode" "DI")])
411 : 43056547 :
412 : 77411372 : (define_split
413 : 11614815 : [(set (match_operand:V_32 0 "push_operand")
414 : 7969955 : (match_operand:V_32 1 "sse_reg_operand"))]
415 : 11614815 : "TARGET_64BIT && TARGET_SSE && reload_completed"
416 : 15263 : [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
417 : : (set (match_dup 0) (match_dup 1))]
418 : 15263 : {
419 : 0 : operands[2] = GEN_INT (-PUSH_ROUNDING (GET_MODE_SIZE (<V_32:MODE>mode)));
420 : 15263 : /* Preserve memory attributes. */
421 : 15263 : operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
422 : 0 : })
423 : 15263 :
424 : 0 : (define_expand "movmisalign<mode>"
425 : 0 : [(set (match_operand:V_32 0 "nonimmediate_operand")
426 : 0 : (match_operand:V_32 1 "nonimmediate_operand"))]
427 : 0 : ""
428 : 8308 : {
429 : 8308 : ix86_expand_vector_move (<MODE>mode, operands);
430 : 8308 : DONE;
431 : 0 : })
432 : :
433 : : (define_expand "movv2qi"
434 : : [(set (match_operand:V2QI 0 "nonimmediate_operand")
435 : : (match_operand:V2QI 1 "nonimmediate_operand"))]
436 : : ""
437 : 0 : {
438 : 36178 : ix86_expand_vector_move (V2QImode, operands);
439 : 36178 : DONE;
440 : 0 : })
441 : 0 :
442 : : (define_insn "*movv2qi_internal"
443 : : [(set (match_operand:V2QI 0 "nonimmediate_operand"
444 : : "=r,r,r,m ,v,v,v,jm,m,r,v")
445 : : (match_operand:V2QI 1 "general_operand"
446 : 6487 : "r ,C,m,rC,C,v,m,x,v,v,r"))]
447 : 7928464 : "!(MEM_P (operands[0]) && MEM_P (operands[1]))"
448 : 49137 : {
449 : 3713748 : switch (get_attr_type (insn))
450 : 3702610 : {
451 : 50839 : case TYPE_IMOV:
452 : 44352 : if (get_attr_mode (insn) == MODE_SI)
453 : 0 : return "mov{l}\t{%k1, %k0|%k0, %k1}";
454 : 7439 : else
455 : 7062 : return "mov{w}\t{%1, %0|%0, %1}";
456 : 38951 :
457 : 1904 : case TYPE_IMOVX:
458 : 0 : /* movzwl is faster than movw on p2 due to partial word stalls,
459 : : though not as fast as an aligned movl. */
460 : 0 : return "movz{wl|x}\t{%1, %k0|%k0, %1}";
461 : 0 :
462 : 544 : case TYPE_SSELOG1:
463 : 544 : if (satisfies_constraint_C (operands[1]))
464 : 66 : return standard_sse_constant_opcode (insn, operands);
465 : 0 :
466 : 478 : if (SSE_REG_P (operands[0]))
467 : : return "%vpinsrw\t{$0, %1, %d0|%d0, %1, 0}";
468 : : else
469 : 156 : return "%vpextrw\t{$0, %1, %0|%0, %1, 0}";
470 : :
471 : 361 : case TYPE_SSEMOV:
472 : 361 : return ix86_output_ssemov (insn, operands);
473 : :
474 : 0 : default:
475 : 0 : gcc_unreachable ();
476 : : }
477 : : }
478 : : [(set (attr "isa")
479 : : (cond [(eq_attr "alternative" "6,9,10")
480 : : (const_string "sse2")
481 : 0 : (eq_attr "alternative" "7")
482 : : (const_string "sse4_noavx")
483 : : (eq_attr "alternative" "8")
484 : : (const_string "avx")
485 : : ]
486 : : (const_string "*")))
487 : : (set (attr "addr")
488 : : (if_then_else (eq_attr "alternative" "7")
489 : : (const_string "gpr16")
490 : : (const_string "*")))
491 : : (set (attr "type")
492 : : (cond [(eq_attr "alternative" "6,7,8")
493 : : (if_then_else (match_test "TARGET_AVX512FP16")
494 : : (const_string "ssemov")
495 : : (const_string "sselog1"))
496 : : (eq_attr "alternative" "4")
497 : : (const_string "sselog1")
498 : : (eq_attr "alternative" "5,9,10")
499 : : (const_string "ssemov")
500 : : (match_test "optimize_function_for_size_p (cfun)")
501 : : (const_string "imov")
502 : : (and (eq_attr "alternative" "0")
503 : : (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
504 : 0 : (not (match_test "TARGET_HIMODE_MATH"))))
505 : : (const_string "imov")
506 : : (and (eq_attr "alternative" "1,2")
507 : : (match_operand:V2QI 1 "aligned_operand"))
508 : 20916597 : (const_string "imov")
509 : 94020324 : (and (match_test "TARGET_MOVX")
510 : : (eq_attr "alternative" "0,2"))
511 : : (const_string "imovx")
512 : 17461863 : ]
513 : 23340482 : (const_string "imov")))
514 : 23340482 : (set (attr "prefix")
515 : 23390428 : (cond [(eq_attr "alternative" "4,5,6,7,8,9,10")
516 : : (const_string "maybe_evex")
517 : 0 : ]
518 : 122564114 : (const_string "orig")))
519 : 105058602 : (set (attr "mode")
520 : 81809607 : (cond [(eq_attr "alternative" "6,7,8")
521 : 70308 : (if_then_else (match_test "TARGET_AVX512FP16")
522 : 53056 : (const_string "HI")
523 : 8224472 : (const_string "TI"))
524 : 81261029 : (eq_attr "alternative" "9,10")
525 : 17252 : (if_then_else (match_test "TARGET_AVX512FP16")
526 : 40701451 : (const_string "HI")
527 : 40701451 : (const_string "SI"))
528 : 81246688 : (eq_attr "alternative" "4")
529 : 40701451 : (cond [(match_test "TARGET_AVX")
530 : 34211 : (const_string "TI")
531 : 40701451 : (ior (not (match_test "TARGET_SSE2"))
532 : 119301503 : (match_test "optimize_function_for_size_p (cfun)"))
533 : : (const_string "V4SF")
534 : 5060211 : ]
535 : 5060211 : (const_string "TI"))
536 : 5060211 : (eq_attr "alternative" "5")
537 : : (cond [(match_test "TARGET_AVX512FP16")
538 : : (const_string "HF")
539 : : (match_test "TARGET_AVX")
540 : : (const_string "TI")
541 : 76 : (ior (not (match_test "TARGET_SSE2"))
542 : 76 : (match_test "optimize_function_for_size_p (cfun)"))
543 : 76 : (const_string "V4SF")
544 : : ]
545 : 23727156 : (const_string "TI"))
546 : 23727156 : (eq_attr "type" "imovx")
547 : 23727156 : (const_string "SI")
548 : : (and (eq_attr "alternative" "1,2")
549 : : (match_operand:V2QI 1 "aligned_operand"))
550 : : (const_string "SI")
551 : 23162836 : (and (eq_attr "alternative" "0")
552 : 14445 : (ior (not (match_test "TARGET_PARTIAL_REG_STALL"))
553 : 14445 : (not (match_test "TARGET_HIMODE_MATH"))))
554 : 14445 : (const_string "SI")
555 : 23177281 : ]
556 : : (const_string "HI")))
557 : : (set (attr "preferred_for_speed")
558 : : (cond [(eq_attr "alternative" "9")
559 : 22420868 : (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
560 : : (eq_attr "alternative" "10")
561 : : (symbol_ref "TARGET_INTER_UNIT_MOVES_TO_VEC")
562 : : ]
563 : : (symbol_ref "true")))])
564 : 11352 :
565 : 11352 : ;; We always round up to UNITS_PER_WORD bytes.
566 : 11352 : (define_insn "*pushv2qi2"
567 : : [(set (match_operand:V2QI 0 "push_operand" "=X,X")
568 : 26051196 : (match_operand:V2QI 1 "nonmemory_no_elim_operand" "rC,v"))]
569 : 26051196 : ""
570 : 26062548 : "* return TARGET_64BIT ? \"push{q}\t%q1\" : \"push{l}\t%k1\";
571 : : #"
572 : : [(set_attr "isa" "*,sse4")
573 : : (set_attr "type" "push,multi")
574 : 25658148 : (set (attr "mode")
575 : : (cond [(eq_attr "alternative" "0")
576 : : (if_then_else (match_test "TARGET_64BIT")
577 : : (const_string "DI")
578 : 24434835 : (const_string "SI"))
579 : 6935 : (eq_attr "alternative" "1")
580 : 6935 : (if_then_else (match_test "TARGET_AVX512FP16")
581 : 6935 : (const_string "HI")
582 : 20411823 : (const_string "TI"))
583 : : ]
584 : : (const_string "HI")))])
585 : 148 :
586 : : (define_split
587 : : [(set (match_operand:V2QI 0 "push_operand")
588 : : (match_operand:V2QI 1 "sse_reg_operand"))]
589 : 0 : "TARGET_SSE4_1 && reload_completed"
590 : : [(set (reg:P SP_REG) (plus:P (reg:P SP_REG) (match_dup 2)))
591 : 1419359 : (set (match_dup 0) (match_dup 1))]
592 : 1419359 : {
593 : 1419359 : operands[2] = GEN_INT (-PUSH_ROUNDING (GET_MODE_SIZE (V2QImode)));
594 : 1419359 : /* Preserve memory attributes. */
595 : 0 : operands[0] = replace_equiv_address (operands[0], stack_pointer_rtx);
596 : : })
597 : :
598 : 1406623 : (define_expand "movmisalignv2qi"
599 : 0 : [(set (match_operand:V2QI 0 "nonimmediate_operand")
600 : 0 : (match_operand:V2QI 1 "nonimmediate_operand"))]
601 : 0 : ""
602 : 1064154 : {
603 : 5392 : ix86_expand_vector_move (V2QImode, operands);
604 : 740026 : DONE;
605 : 0 : })
606 : :
607 : : (define_insn "sse_movntq"
608 : : [(set (match_operand:DI 0 "memory_operand" "=m,m")
609 : : (unspec:DI [(match_operand:DI 1 "register_operand" "y,r")]
610 : 40108 : UNSPEC_MOVNTQ))]
611 : 40141 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
612 : 40108 : && (TARGET_SSE || TARGET_3DNOW_A)"
613 : 40108 : "@
614 : 40108 : movntq\t{%1, %0|%0, %1}
615 : 40108 : movnti\t{%1, %0|%0, %1}"
616 : 40725 : [(set_attr "isa" "*,x64")
617 : 40725 : (set_attr "mmx_isa" "native,*")
618 : 40108 : (set_attr "type" "mmxmov,ssemov")
619 : 40277 : (set_attr "mode" "DI")])
620 : 45669 :
621 : 0 : (define_expand "movq_<mode>_to_sse"
622 : 12136 : [(set (match_operand:<mmxdoublevecmode> 0 "register_operand")
623 : 5392 : (vec_concat:<mmxdoublevecmode>
624 : 5392 : (match_operand:V24FI 1 "nonimmediate_operand")
625 : 17528 : (match_dup 2)))]
626 : 17528 : "TARGET_SSE2"
627 : 12136 : {
628 : 5392 : if (<MODE>mode != V2SImode
629 : 0 : && !flag_trapping_math)
630 : 12136 : {
631 : 12155 : rtx op1 = force_reg (<MODE>mode, operands[1]);
632 : 8078 : emit_move_insn (operands[0], lowpart_subreg (<mmxdoublevecmode>mode,
633 : : op1, <MODE>mode));
634 : 8078 : DONE;
635 : : }
636 : :
637 : 4478 : operands[2] = CONST0_RTX (<MODE>mode);
638 : : })
639 : :
640 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
641 : 70044 : ;;
642 : 70044 : ;; Parallel single-precision floating point arithmetic
643 : 70044 : ;;
644 : 4478 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
645 : 4478 :
646 : 4478 : (define_expand "<code>v2sf2"
647 : 65383 : [(set (match_operand:V2SF 0 "register_operand")
648 : 4478 : (absneg:V2SF
649 : : (match_operand:V2SF 1 "register_operand")))]
650 : : "TARGET_MMX_WITH_SSE"
651 : 65421 : "ix86_expand_fp_absneg_operator (<CODE>, V2SFmode, operands); DONE;")
652 : 4478 :
653 : 277 : (define_insn_and_split "*mmx_<code>v2sf2"
654 : 4201 : [(set (match_operand:V2SF 0 "register_operand" "=x,x,x")
655 : : (absneg:V2SF
656 : : (match_operand:V2SF 1 "register_operand" "0,x,x")))
657 : : (use (match_operand:V2SF 2 "nonimmediate_operand" "x,0,x"))]
658 : 20 : "TARGET_MMX_WITH_SSE"
659 : 430 : "#"
660 : 62300 : "&& reload_completed"
661 : 62280 : [(set (match_dup 0)
662 : 62762 : (<absneg_op>:V2SF (match_dup 1) (match_dup 2)))]
663 : 12 : {
664 : 476 : if (!TARGET_AVX && operands_match_p (operands[0], operands[2]))
665 : 11 : std::swap (operands[1], operands[2]);
666 : 776 : }
667 : 10 : [(set_attr "isa" "noavx,noavx,avx")])
668 : 420 :
669 : 80 : (define_insn_and_split "*mmx_nabsv2sf2"
670 : 62 : [(set (match_operand:V2SF 0 "register_operand" "=x,x,x")
671 : 52 : (neg:V2SF
672 : 90 : (abs:V2SF
673 : 28 : (match_operand:V2SF 1 "register_operand" "0,x,x"))))
674 : 90 : (use (match_operand:V2SF 2 "nonimmediate_operand" "x,0,x"))]
675 : 52 : "TARGET_MMX_WITH_SSE"
676 : 10 : "#"
677 : 28 : "&& reload_completed"
678 : 10 : [(set (match_dup 0)
679 : 1177101 : (ior:V2SF (match_dup 1) (match_dup 2)))]
680 : 1177101 : {
681 : 1177049 : if (!TARGET_AVX && operands_match_p (operands[0], operands[2]))
682 : 1177049 : std::swap (operands[1], operands[2]);
683 : 0 : }
684 : : [(set_attr "isa" "noavx,noavx,avx")])
685 : :
686 : 1146433 : (define_expand "<insn>v2sf3"
687 : 42 : [(set (match_operand:V2SF 0 "register_operand")
688 : 0 : (plusminusmult:V2SF
689 : 42 : (match_operand:V2SF 1 "nonimmediate_operand")
690 : 1146475 : (match_operand:V2SF 2 "nonimmediate_operand")))]
691 : 42 : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
692 : 0 : {
693 : 42 : rtx op2 = gen_reg_rtx (V4SFmode);
694 : 4780 : rtx op1 = gen_reg_rtx (V4SFmode);
695 : 4822 : rtx op0 = gen_reg_rtx (V4SFmode);
696 : 0 :
697 : 4780 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
698 : 4780 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
699 : 5501 :
700 : 10281 : emit_insn (gen_<insn>v4sf3 (op0, op1, op2));
701 : 5501 :
702 : 10281 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
703 : 10281 : DONE;
704 : : })
705 : :
706 : : (define_expand "mmx_addv2sf3"
707 : 2984 : [(set (match_operand:V2SF 0 "register_operand")
708 : 2984 : (plus:V2SF
709 : 2984 : (match_operand:V2SF 1 "nonimmediate_operand")
710 : 2984 : (match_operand:V2SF 2 "nonimmediate_operand")))]
711 : 2984 : "TARGET_3DNOW"
712 : 5600 : "ix86_fixup_binary_operands_no_copy (PLUS, V2SFmode, operands);")
713 : 5582 :
714 : 2598 : (define_insn "*mmx_addv2sf3"
715 : 2616 : [(set (match_operand:V2SF 0 "register_operand" "=y")
716 : 2616 : (plus:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "%0")
717 : 2616 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
718 : 2685 : "TARGET_3DNOW && ix86_binary_operator_ok (PLUS, V2SFmode, operands)"
719 : 2616 : "pfadd\t{%2, %0|%0, %2}"
720 : 2616 : [(set_attr "type" "mmxadd")
721 : 2598 : (set_attr "prefix_extra" "1")
722 : 6043 : (set_attr "mode" "V2SF")])
723 : 6025 :
724 : 6025 : (define_expand "mmx_subv2sf3"
725 : 1814 : [(set (match_operand:V2SF 0 "register_operand")
726 : 18 : (minus:V2SF (match_operand:V2SF 1 "register_operand")
727 : 18 : (match_operand:V2SF 2 "nonimmediate_operand")))]
728 : 18 : "TARGET_3DNOW")
729 : 1814 :
730 : 3064 : (define_expand "mmx_subrv2sf3"
731 : 3064 : [(set (match_operand:V2SF 0 "register_operand")
732 : 3064 : (minus:V2SF (match_operand:V2SF 2 "register_operand")
733 : 1829 : (match_operand:V2SF 1 "nonimmediate_operand")))]
734 : 1814 : "TARGET_3DNOW")
735 : 1814 :
736 : 1233 : (define_insn "*mmx_subv2sf3"
737 : 15 : [(set (match_operand:V2SF 0 "register_operand" "=y,y")
738 : : (minus:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "0,ym")
739 : : (match_operand:V2SF 2 "nonimmediate_operand" "ym,0")))]
740 : 1348 : "TARGET_3DNOW && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
741 : : "@
742 : : pfsub\t{%2, %0|%0, %2}
743 : : pfsubr\t{%1, %0|%0, %1}"
744 : 243 : [(set_attr "type" "mmxadd")
745 : 257 : (set_attr "prefix_extra" "1")
746 : 243 : (set_attr "mode" "V2SF")])
747 : :
748 : : (define_expand "mmx_mulv2sf3"
749 : 109209 : [(set (match_operand:V2SF 0 "register_operand")
750 : 109195 : (mult:V2SF (match_operand:V2SF 1 "nonimmediate_operand")
751 : 109195 : (match_operand:V2SF 2 "nonimmediate_operand")))]
752 : 109195 : "TARGET_3DNOW"
753 : 15 : "ix86_fixup_binary_operands_no_copy (MULT, V2SFmode, operands);")
754 : :
755 : : (define_insn "*mmx_mulv2sf3"
756 : 15 : [(set (match_operand:V2SF 0 "register_operand" "=y")
757 : 30 : (mult:V2SF (match_operand:V2SF 1 "nonimmediate_operand" "%0")
758 : 15 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
759 : 65 : "TARGET_3DNOW && ix86_binary_operator_ok (MULT, V2SFmode, operands)"
760 : 17 : "pfmul\t{%2, %0|%0, %2}"
761 : 342790 : [(set_attr "type" "mmxmul")
762 : 342775 : (set_attr "prefix_extra" "1")
763 : 343779 : (set_attr "mode" "V2SF")])
764 : 1019 :
765 : 1019 : (define_expand "divv2sf3"
766 : 15 : [(set (match_operand:V2SF 0 "register_operand")
767 : 30 : (div:V2SF (match_operand:V2SF 1 "register_operand")
768 : 15 : (match_operand:V2SF 2 "register_operand")))]
769 : 15 : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
770 : 68 : {
771 : 136 : rtx op2 = gen_reg_rtx (V4SFmode);
772 : 550680 : rtx op1 = gen_reg_rtx (V4SFmode);
773 : 550680 : rtx op0 = gen_reg_rtx (V4SFmode);
774 : 550680 :
775 : 68 : rtx tmp = gen_rtx_VEC_CONCAT (V4SFmode, operands[2],
776 : : force_reg (V2SFmode, CONST1_RTX (V2SFmode)));
777 : 68 : emit_insn (gen_rtx_SET (op2, tmp));
778 : 72663 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
779 : 68 :
780 : 68 : emit_insn (gen_divv4sf3 (op0, op1, op2));
781 : 68 :
782 : 27799 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
783 : 68 : DONE;
784 : 68 : })
785 : :
786 : : (define_expand "<code>v2sf3"
787 : : [(set (match_operand:V2SF 0 "register_operand")
788 : : (smaxmin:V2SF
789 : : (match_operand:V2SF 1 "register_operand")
790 : : (match_operand:V2SF 2 "register_operand")))]
791 : 54798 : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
792 : 54927 : {
793 : 55056 : rtx op2 = gen_reg_rtx (V4SFmode);
794 : 129 : rtx op1 = gen_reg_rtx (V4SFmode);
795 : 129 : rtx op0 = gen_reg_rtx (V4SFmode);
796 : :
797 : 50263 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
798 : 129 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
799 : :
800 : 129 : emit_insn (gen_<code>v4sf3 (op0, op1, op2));
801 : 50134 :
802 : 129 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
803 : 129 : DONE;
804 : : })
805 : 71 :
806 : : (define_expand "mmx_<code>v2sf3"
807 : : [(set (match_operand:V2SF 0 "register_operand")
808 : : (smaxmin:V2SF
809 : 71 : (match_operand:V2SF 1 "nonimmediate_operand")
810 : 936356 : (match_operand:V2SF 2 "nonimmediate_operand")))]
811 : 936356 : "TARGET_3DNOW"
812 : 936384 : {
813 : 0 : if (!flag_finite_math_only || flag_signed_zeros)
814 : 71 : {
815 : 99 : operands[1] = force_reg (V2SFmode, operands[1]);
816 : 28 : emit_insn (gen_mmx_ieee_<maxmin_float>v2sf3
817 : : (operands[0], operands[1], operands[2]));
818 : 28 : DONE;
819 : : }
820 : : else
821 : 0 : ix86_fixup_binary_operands_no_copy (<CODE>, V2SFmode, operands);
822 : : })
823 : :
824 : : ;; These versions of the min/max patterns are intentionally ignorant of
825 : 72 : ;; their behavior wrt -0.0 and NaN (via the commutative operand mark).
826 : 0 : ;; Since both the tree-level MAX_EXPR and the rtl-level SMAX operator
827 : 0 : ;; are undefined in this condition, we're certain this is correct.
828 : 0 :
829 : 72 : (define_insn "*mmx_<code>v2sf3"
830 : 72 : [(set (match_operand:V2SF 0 "register_operand" "=y")
831 : 72 : (smaxmin:V2SF
832 : 0 : (match_operand:V2SF 1 "nonimmediate_operand" "%0")
833 : 72 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
834 : 74 : "TARGET_3DNOW && ix86_binary_operator_ok (<CODE>, V2SFmode, operands)"
835 : 74 : "pf<maxmin_float>\t{%2, %0|%0, %2}"
836 : 0 : [(set_attr "type" "mmxadd")
837 : 2255415 : (set_attr "prefix_extra" "1")
838 : 2255415 : (set_attr "mode" "V2SF")])
839 : 2255415 :
840 : : ;; These versions of the min/max patterns implement exactly the operations
841 : : ;; min = (op1 < op2 ? op1 : op2)
842 : : ;; max = (!(op1 < op2) ? op1 : op2)
843 : 22 : ;; Their operands are not commutative, and thus they may be used in the
844 : : ;; presence of -0.0 and NaN.
845 : :
846 : 8 : (define_insn "mmx_ieee_<ieee_maxmin>v2sf3"
847 : 8 : [(set (match_operand:V2SF 0 "register_operand" "=y")
848 : 244026 : (unspec:V2SF
849 : 244034 : [(match_operand:V2SF 1 "register_operand" "0")
850 : 244034 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
851 : 22 : IEEE_MAXMIN))]
852 : 122 : "TARGET_3DNOW"
853 : 14 : "pf<ieee_maxmin>\t{%2, %0|%0, %2}"
854 : : [(set_attr "type" "mmxadd")
855 : : (set_attr "prefix_extra" "1")
856 : : (set_attr "mode" "V2SF")])
857 : :
858 : : (define_insn "mmx_rcpv2sf2"
859 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
860 : 9548 : (unspec:V2SF [(match_operand:V2SF 1 "nonimmediate_operand" "ym")]
861 : 9548 : UNSPEC_PFRCP))]
862 : 92 : "TARGET_3DNOW"
863 : 106 : "pfrcp\t{%1, %0|%0, %1}"
864 : 106 : [(set_attr "type" "mmx")
865 : : (set_attr "prefix_extra" "1")
866 : 46 : (set_attr "mode" "V2SF")])
867 : 46 :
868 : : (define_insn "mmx_rcpit1v2sf3"
869 : 46 : [(set (match_operand:V2SF 0 "register_operand" "=y")
870 : 46 : (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
871 : 46 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
872 : : UNSPEC_PFRCPIT1))]
873 : 46 : "TARGET_3DNOW"
874 : 46 : "pfrcpit1\t{%2, %0|%0, %2}"
875 : 46 : [(set_attr "type" "mmx")
876 : 46 : (set_attr "prefix_extra" "1")
877 : 46 : (set_attr "mode" "V2SF")])
878 : 46 :
879 : 46 : (define_insn "mmx_rcpit2v2sf3"
880 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
881 : : (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
882 : : (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
883 : : UNSPEC_PFRCPIT2))]
884 : 46 : "TARGET_3DNOW"
885 : : "pfrcpit2\t{%2, %0|%0, %2}"
886 : : [(set_attr "type" "mmx")
887 : : (set_attr "prefix_extra" "1")
888 : 46 : (set_attr "mode" "V2SF")])
889 : 46 :
890 : 46 : (define_expand "sqrtv2sf2"
891 : : [(set (match_operand:V2SF 0 "register_operand")
892 : : (sqrt:V2SF (match_operand:V2SF 1 "nonimmediate_operand")))]
893 : : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
894 : 8 : {
895 : 8 : rtx op1 = gen_reg_rtx (V4SFmode);
896 : 8 : rtx op0 = gen_reg_rtx (V4SFmode);
897 : :
898 : 8 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
899 : :
900 : 8 : emit_insn (gen_sqrtv4sf2 (op0, op1));
901 : :
902 : 8 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
903 : 8 : DONE;
904 : : })
905 : :
906 : : (define_insn "mmx_rsqrtv2sf2"
907 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
908 : : (unspec:V2SF [(match_operand:V2SF 1 "nonimmediate_operand" "ym")]
909 : : UNSPEC_PFRSQRT))]
910 : 46 : "TARGET_3DNOW"
911 : : "pfrsqrt\t{%1, %0|%0, %1}"
912 : : [(set_attr "type" "mmx")
913 : : (set_attr "prefix_extra" "1")
914 : 1658 : (set_attr "mode" "V2SF")])
915 : 1658 :
916 : : (define_insn "mmx_rsqit1v2sf3"
917 : 49 : [(set (match_operand:V2SF 0 "register_operand" "=y")
918 : 49 : (unspec:V2SF [(match_operand:V2SF 1 "register_operand" "0")
919 : 49 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")]
920 : : UNSPEC_PFRSQIT1))]
921 : 46 : "TARGET_3DNOW"
922 : 63 : "pfrsqit1\t{%2, %0|%0, %2}"
923 : 49 : [(set_attr "type" "mmx")
924 : 49 : (set_attr "prefix_extra" "1")
925 : 64345 : (set_attr "mode" "V2SF")])
926 : 64359 :
927 : : (define_expand "mmx_haddv2sf3"
928 : 1747 : [(set (match_operand:V2SF 0 "register_operand")
929 : 1753 : (vec_concat:V2SF
930 : : (plus:SF
931 : : (vec_select:SF
932 : : (match_operand:V2SF 1 "register_operand")
933 : : (parallel [(const_int 0)]))
934 : : (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
935 : : (plus:SF
936 : : (vec_select:SF
937 : : (match_operand:V2SF 2 "nonimmediate_operand")
938 : : (parallel [(const_int 0)]))
939 : : (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))))]
940 : : "TARGET_3DNOW")
941 : :
942 : : (define_insn "*mmx_haddv2sf3"
943 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
944 : : (vec_concat:V2SF
945 : : (plus:SF
946 : : (vec_select:SF
947 : : (match_operand:V2SF 1 "register_operand" "0")
948 : : (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))
949 : : (vec_select:SF (match_dup 1)
950 : : (parallel [(match_operand:SI 4 "const_0_to_1_operand")])))
951 : : (plus:SF
952 : : (vec_select:SF
953 : : (match_operand:V2SF 2 "nonimmediate_operand" "ym")
954 : : (parallel [(match_operand:SI 5 "const_0_to_1_operand")]))
955 : 1 : (vec_select:SF (match_dup 2)
956 : : (parallel [(match_operand:SI 6 "const_0_to_1_operand")])))))]
957 : 47 : "TARGET_3DNOW
958 : 47 : && INTVAL (operands[3]) != INTVAL (operands[4])
959 : 46 : && INTVAL (operands[5]) != INTVAL (operands[6])"
960 : 1 : "pfacc\t{%2, %0|%0, %2}"
961 : : [(set_attr "type" "mmxadd")
962 : : (set_attr "prefix_extra" "1")
963 : 3039 : (set_attr "mode" "V2SF")])
964 : 3039 :
965 : 93 : (define_insn_and_split "*mmx_haddv2sf3_low"
966 : 3132 : [(set (match_operand:SF 0 "register_operand")
967 : 2946 : (plus:SF
968 : 93 : (vec_select:SF
969 : 93 : (match_operand:V2SF 1 "nonimmediate_operand")
970 : 93 : (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))
971 : 93 : (vec_select:SF
972 : : (match_dup 1)
973 : 93 : (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))))]
974 : 96 : "TARGET_SSE3 && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math
975 : 3 : && INTVAL (operands[2]) != INTVAL (operands[3])
976 : 3 : && ix86_pre_reload_split ()"
977 : 18 : "#"
978 : 93 : "&& 1"
979 : 50 : [(const_int 0)]
980 : 95 : {
981 : 71 : rtx op1 = gen_reg_rtx (V4SFmode);
982 : 91 : rtx op0 = gen_reg_rtx (V4SFmode);
983 : 708 :
984 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
985 : 77 :
986 : 46 : emit_insn (gen_sse3_haddv4sf3 (op0, op1, op1));
987 : 47 :
988 : 48 : emit_move_insn (operands[0], lowpart_subreg (SFmode, op0, V4SFmode));
989 : 1 : DONE;
990 : 47 : })
991 : 47 :
992 : 47 : (define_insn "mmx_hsubv2sf3"
993 : 47 : [(set (match_operand:V2SF 0 "register_operand" "=y")
994 : : (vec_concat:V2SF
995 : : (minus:SF
996 : : (vec_select:SF
997 : : (match_operand:V2SF 1 "register_operand" "0")
998 : : (parallel [(const_int 0)]))
999 : : (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1000 : : (minus:SF
1001 : : (vec_select:SF
1002 : 1 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")
1003 : : (parallel [(const_int 0)]))
1004 : 1 : (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))))]
1005 : 48 : "TARGET_3DNOW_A"
1006 : 0 : "pfnacc\t{%2, %0|%0, %2}"
1007 : 1 : [(set_attr "type" "mmxadd")
1008 : : (set_attr "prefix_extra" "1")
1009 : 46 : (set_attr "mode" "V2SF")])
1010 : 46 :
1011 : 46 : (define_insn_and_split "*mmx_hsubv2sf3_low"
1012 : 46 : [(set (match_operand:SF 0 "register_operand")
1013 : : (minus:SF
1014 : 46 : (vec_select:SF
1015 : 46 : (match_operand:V2SF 1 "register_operand")
1016 : 46 : (parallel [(const_int 0)]))
1017 : : (vec_select:SF
1018 : 46 : (match_dup 1)
1019 : 46 : (parallel [(const_int 1)]))))]
1020 : 49 : "TARGET_SSE3 && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math
1021 : 3 : && ix86_pre_reload_split ()"
1022 : 0 : "#"
1023 : 46 : "&& 1"
1024 : 46 : [(const_int 0)]
1025 : 2 : {
1026 : 12 : rtx op1 = gen_reg_rtx (V4SFmode);
1027 : 12 : rtx op0 = gen_reg_rtx (V4SFmode);
1028 : 455 :
1029 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1030 : 76 :
1031 : 46 : emit_insn (gen_sse3_hsubv4sf3 (op0, op1, op1));
1032 : 46 :
1033 : 1 : emit_move_insn (operands[0], lowpart_subreg (SFmode, op0, V4SFmode));
1034 : 47 : DONE;
1035 : 46 : })
1036 : 46 :
1037 : : (define_expand "mmx_haddsubv2sf3"
1038 : 46 : [(set (match_operand:V2SF 0 "register_operand")
1039 : 46 : (vec_concat:V2SF
1040 : 46 : (minus:SF
1041 : : (vec_select:SF
1042 : : (match_operand:V2SF 1 "register_operand")
1043 : : (parallel [(const_int 0)]))
1044 : : (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1045 : : (plus:SF
1046 : 14 : (vec_select:SF
1047 : : (match_operand:V2SF 2 "nonimmediate_operand")
1048 : : (parallel [(const_int 0)]))
1049 : : (vec_select:SF (match_dup 2) (parallel [(const_int 1)])))))]
1050 : 14 : "TARGET_3DNOW_A")
1051 : :
1052 : : (define_insn "*mmx_haddsubv2sf3"
1053 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
1054 : : (vec_concat:V2SF
1055 : : (minus:SF
1056 : : (vec_select:SF
1057 : : (match_operand:V2SF 1 "register_operand" "0")
1058 : : (parallel [(const_int 0)]))
1059 : : (vec_select:SF (match_dup 1) (parallel [(const_int 1)])))
1060 : : (plus:SF
1061 : : (vec_select:SF
1062 : : (match_operand:V2SF 2 "nonimmediate_operand" "ym")
1063 : : (parallel [(match_operand:SI 3 "const_0_to_1_operand")]))
1064 : : (vec_select:SF
1065 : : (match_dup 2)
1066 : : (parallel [(match_operand:SI 4 "const_0_to_1_operand")])))))]
1067 : 46 : "TARGET_3DNOW_A
1068 : 46 : && INTVAL (operands[3]) != INTVAL (operands[4])"
1069 : : "pfpnacc\t{%2, %0|%0, %2}"
1070 : : [(set_attr "type" "mmxadd")
1071 : : (set_attr "prefix_extra" "1")
1072 : : (set_attr "mode" "V2SF")])
1073 : :
1074 : : (define_expand "vec_addsubv2sf3"
1075 : : [(set (match_operand:V2SF 0 "register_operand")
1076 : 2054515 : (vec_merge:V2SF
1077 : 2054515 : (minus:V2SF
1078 : 2054691 : (match_operand:V2SF 1 "nonimmediate_operand")
1079 : 2054515 : (match_operand:V2SF 2 "nonimmediate_operand"))
1080 : 2054515 : (plus:V2SF (match_dup 1) (match_dup 2))
1081 : 2054515 : (const_int 1)))]
1082 : 2054691 : "TARGET_SSE3 && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1083 : 176 : {
1084 : 52401 : rtx op2 = gen_reg_rtx (V4SFmode);
1085 : 52225 : rtx op1 = gen_reg_rtx (V4SFmode);
1086 : 48609 : rtx op0 = gen_reg_rtx (V4SFmode);
1087 : 100658 :
1088 : 6866 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
1089 : 45711 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1090 : :
1091 : 41428 : emit_insn (gen_vec_addsubv4sf3 (op0, op1, op2));
1092 : :
1093 : 176 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1094 : 176 : DONE;
1095 : : })
1096 : :
1097 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1098 : : ;;
1099 : : ;; Parallel single-precision floating point comparisons
1100 : : ;;
1101 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1102 : :
1103 : : (define_expand "mmx_eqv2sf3"
1104 : : [(set (match_operand:V2SI 0 "register_operand")
1105 : : (eq:V2SI (match_operand:V2SF 1 "nonimmediate_operand")
1106 : : (match_operand:V2SF 2 "nonimmediate_operand")))]
1107 : : "TARGET_3DNOW"
1108 : 14 : "ix86_fixup_binary_operands_no_copy (EQ, V2SFmode, operands);")
1109 : :
1110 : : (define_insn "*mmx_eqv2sf3"
1111 : 14 : [(set (match_operand:V2SI 0 "register_operand" "=y")
1112 : 14 : (eq:V2SI (match_operand:V2SF 1 "nonimmediate_operand" "%0")
1113 : 14 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
1114 : 60 : "TARGET_3DNOW && ix86_binary_operator_ok (EQ, V2SFmode, operands)"
1115 : 14 : "pfcmpeq\t{%2, %0|%0, %2}"
1116 : 14 : [(set_attr "type" "mmxcmp")
1117 : : (set_attr "prefix_extra" "1")
1118 : 6445 : (set_attr "mode" "V2SF")])
1119 : 6431 :
1120 : 6107 : (define_insn "mmx_gtv2sf3"
1121 : 8767 : [(set (match_operand:V2SI 0 "register_operand" "=y")
1122 : 14 : (gt:V2SI (match_operand:V2SF 1 "register_operand" "0")
1123 : 14 : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
1124 : 60 : "TARGET_3DNOW"
1125 : 14 : "pfcmpgt\t{%2, %0|%0, %2}"
1126 : 14 : [(set_attr "type" "mmxcmp")
1127 : 14 : (set_attr "prefix_extra" "1")
1128 : 9517 : (set_attr "mode" "V2SF")])
1129 : 9605 :
1130 : 4756 : (define_insn "mmx_gev2sf3"
1131 : 9517 : [(set (match_operand:V2SI 0 "register_operand" "=y")
1132 : : (ge:V2SI (match_operand:V2SF 1 "register_operand" "0")
1133 : : (match_operand:V2SF 2 "nonimmediate_operand" "ym")))]
1134 : 134 : "TARGET_3DNOW"
1135 : 88 : "pfcmpge\t{%2, %0|%0, %2}"
1136 : 88 : [(set_attr "type" "mmxcmp")
1137 : 88 : (set_attr "prefix_extra" "1")
1138 : 88 : (set_attr "mode" "V2SF")])
1139 : 88 :
1140 : 88 : (define_expand "vec_cmpv2sfv2si"
1141 : 88 : [(set (match_operand:V2SI 0 "register_operand")
1142 : : (match_operator:V2SI 1 ""
1143 : 2071502 : [(match_operand:V2SF 2 "nonimmediate_operand")
1144 : 2071502 : (match_operand:V2SF 3 "nonimmediate_operand")]))]
1145 : 2071502 : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1146 : 2071590 : {
1147 : 2071590 : rtx ops[4];
1148 : 2071590 : ops[3] = gen_reg_rtx (V4SFmode);
1149 : 88 : ops[2] = gen_reg_rtx (V4SFmode);
1150 : 2451 : ops[1] = gen_rtx_fmt_ee (GET_CODE (operands[1]), V4SImode, ops[2], ops[3]);
1151 : 2451 : ops[0] = gen_reg_rtx (V4SImode);
1152 : 2363 :
1153 : 88 : emit_insn (gen_movq_v2sf_to_sse (ops[3], operands[3]));
1154 : 88 : emit_insn (gen_movq_v2sf_to_sse (ops[2], operands[2]));
1155 : :
1156 : 88 : bool ok = ix86_expand_fp_vec_cmp (ops);
1157 : 88 : gcc_assert (ok);
1158 : :
1159 : 88 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, ops[0], V4SImode));
1160 : 88 : DONE;
1161 : : })
1162 : :
1163 : : (define_expand "vcond<mode>v2sf"
1164 : : [(set (match_operand:V2FI 0 "register_operand")
1165 : : (if_then_else:V2FI
1166 : : (match_operator 3 ""
1167 : : [(match_operand:V2SF 4 "nonimmediate_operand")
1168 : : (match_operand:V2SF 5 "nonimmediate_operand")])
1169 : : (match_operand:V2FI 1 "general_operand")
1170 : : (match_operand:V2FI 2 "general_operand")))]
1171 : : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1172 : 32 : {
1173 : 32 : rtx ops[6];
1174 : 64 : ops[5] = gen_reg_rtx (V4SFmode);
1175 : 32 : ops[4] = gen_reg_rtx (V4SFmode);
1176 : 32 : ops[3] = gen_rtx_fmt_ee (GET_CODE (operands[3]), VOIDmode, ops[4], ops[5]);
1177 : 32 : ops[2] = lowpart_subreg (<mmxdoublevecmode>mode,
1178 : : force_reg (<MODE>mode, operands[2]),
1179 : : <MODE>mode);
1180 : 32 : ops[1] = lowpart_subreg (<mmxdoublevecmode>mode,
1181 : : force_reg (<MODE>mode, operands[1]),
1182 : : <MODE>mode);
1183 : 32 : ops[0] = gen_reg_rtx (<mmxdoublevecmode>mode);
1184 : 13 :
1185 : 32 : emit_insn (gen_movq_v2sf_to_sse (ops[5], operands[5]));
1186 : 32 : emit_insn (gen_movq_v2sf_to_sse (ops[4], operands[4]));
1187 : :
1188 : 32 : bool ok = ix86_expand_fp_vcond (ops);
1189 : 32 : gcc_assert (ok);
1190 : :
1191 : 32 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, ops[0],
1192 : 13 : <mmxdoublevecmode>mode));
1193 : 32 : DONE;
1194 : 13 : })
1195 : 13 :
1196 : 13 : (define_insn "@sse4_1_insertps_<mode>"
1197 : 13 : [(set (match_operand:V2FI 0 "register_operand" "=Yr,*x,v")
1198 : 13 : (unspec:V2FI
1199 : 13 : [(match_operand:V2FI 2 "nonimmediate_operand" "Yrjm,*xjm,vm")
1200 : 13 : (match_operand:V2FI 1 "register_operand" "0,0,v")
1201 : : (match_operand:SI 3 "const_0_to_255_operand")]
1202 : : UNSPEC_INSERTPS))]
1203 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
1204 : 148 : {
1205 : 148 : if (MEM_P (operands[2]))
1206 : : {
1207 : 0 : unsigned count_s = INTVAL (operands[3]) >> 6;
1208 : 0 : if (count_s)
1209 : 0 : operands[3] = GEN_INT (INTVAL (operands[3]) & 0x3f);
1210 : 0 : operands[2] = adjust_address_nv (operands[2],
1211 : 35673 : <mmxscalarmode>mode, count_s * 4);
1212 : 35673 : }
1213 : 35821 : switch (which_alternative)
1214 : 35673 : {
1215 : 35673 : case 0:
1216 : 35673 : case 1:
1217 : 35673 : return "insertps\t{%3, %2, %0|%0, %2, %3}";
1218 : 35821 : case 2:
1219 : 35821 : return "vinsertps\t{%3, %2, %1, %0|%0, %1, %2, %3}";
1220 : 35673 : default:
1221 : 0 : gcc_unreachable ();
1222 : 32619 : }
1223 : : }
1224 : 228 : [(set_attr "isa" "noavx,noavx,avx")
1225 : 203 : (set_attr "addr" "gpr16,gpr16,*")
1226 : 203 : (set_attr "type" "sselog")
1227 : 0 : (set_attr "prefix_data16" "1,1,*")
1228 : 6 : (set_attr "prefix_extra" "1")
1229 : 6 : (set_attr "length_immediate" "1")
1230 : 6 : (set_attr "prefix" "orig,orig,maybe_evex")
1231 : 25 : (set_attr "mode" "V4SF")])
1232 : 25 :
1233 : 25 : (define_insn "*mmx_blendps"
1234 : 25 : [(set (match_operand:V2SF 0 "register_operand" "=Yr,*x,x")
1235 : 25 : (vec_merge:V2SF
1236 : 25 : (match_operand:V2SF 2 "register_operand" "Yr,*x,x")
1237 : 25 : (match_operand:V2SF 1 "register_operand" "0,0,x")
1238 : 19 : (match_operand:SI 3 "const_0_to_3_operand")))]
1239 : 519 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
1240 : 19 : "@
1241 : : blendps\t{%3, %2, %0|%0, %2, %3}
1242 : : blendps\t{%3, %2, %0|%0, %2, %3}
1243 : 3 : vblendps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1244 : 3 : [(set_attr "isa" "noavx,noavx,avx")
1245 : 3 : (set_attr "type" "ssemov")
1246 : : (set_attr "length_immediate" "1")
1247 : : (set_attr "prefix_data16" "1,1,*")
1248 : : (set_attr "prefix_extra" "1")
1249 : : (set_attr "prefix" "orig,orig,vex")
1250 : : (set_attr "mode" "V4SF")])
1251 : :
1252 : : (define_insn "mmx_blendvps"
1253 : : [(set (match_operand:V2SF 0 "register_operand" "=Yr,*x,x")
1254 : : (unspec:V2SF
1255 : : [(match_operand:V2SF 1 "register_operand" "0,0,x")
1256 : : (match_operand:V2SF 2 "register_operand" "Yr,*x,x")
1257 : : (match_operand:V2SF 3 "register_operand" "Yz,Yz,x")]
1258 : : UNSPEC_BLENDV))]
1259 : 14 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
1260 : : "@
1261 : : blendvps\t{%3, %2, %0|%0, %2, %3}
1262 : : blendvps\t{%3, %2, %0|%0, %2, %3}
1263 : 3542 : vblendvps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
1264 : 3542 : [(set_attr "isa" "noavx,noavx,avx")
1265 : 3542 : (set_attr "type" "ssemov")
1266 : : (set_attr "length_immediate" "1")
1267 : : (set_attr "prefix_data16" "1,1,*")
1268 : : (set_attr "prefix_extra" "1")
1269 : : (set_attr "prefix" "orig,orig,vex")
1270 : : (set_attr "btver2_decode" "vector")
1271 : : (set_attr "mode" "V4SF")])
1272 : :
1273 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1274 : : ;;
1275 : : ;; Parallel single-precision floating point logical operations
1276 : : ;;
1277 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1278 : :
1279 : : (define_insn "*mmx_andnotv2sf3"
1280 : : [(set (match_operand:V2SF 0 "register_operand" "=x,x")
1281 : : (and:V2SF
1282 : : (not:V2SF
1283 : : (match_operand:V2SF 1 "register_operand" "0,x"))
1284 : : (match_operand:V2SF 2 "register_operand" "x,x")))]
1285 : : "TARGET_MMX_WITH_SSE"
1286 : : "@
1287 : : andnps\t{%2, %0|%0, %2}
1288 : : vandnps\t{%2, %1, %0|%0, %1, %2}"
1289 : 1 : [(set_attr "isa" "noavx,avx")
1290 : 1 : (set_attr "type" "sselog")
1291 : 1 : (set_attr "prefix" "orig,vex")
1292 : : (set_attr "mode" "V4SF")])
1293 : :
1294 : : (define_insn "<code>v2sf3"
1295 : : [(set (match_operand:V2SF 0 "register_operand" "=x,x")
1296 : : (any_logic:V2SF
1297 : : (match_operand:V2SF 1 "register_operand" "%0,x")
1298 : : (match_operand:V2SF 2 "register_operand" "x,x")))]
1299 : 279 : "TARGET_MMX_WITH_SSE"
1300 : : "@
1301 : : <logic>ps\t{%2, %0|%0, %2}
1302 : : v<logic>ps\t{%2, %1, %0|%0, %1, %2}"
1303 : 31 : [(set_attr "isa" "noavx,avx")
1304 : 27 : (set_attr "type" "sselog")
1305 : 27 : (set_attr "prefix" "orig,vex")
1306 : : (set_attr "mode" "V4SF")])
1307 : :
1308 : : (define_expand "copysignv2sf3"
1309 : : [(set (match_dup 4)
1310 : : (and:V2SF
1311 : : (not:V2SF (match_dup 3))
1312 : : (match_operand:V2SF 1 "register_operand")))
1313 : : (set (match_dup 5)
1314 : : (and:V2SF (match_dup 3)
1315 : : (match_operand:V2SF 2 "register_operand")))
1316 : : (set (match_operand:V2SF 0 "register_operand")
1317 : : (ior:V2SF (match_dup 4) (match_dup 5)))]
1318 : : "TARGET_MMX_WITH_SSE"
1319 : 6 : {
1320 : 6 : operands[3] = ix86_build_signbit_mask (V2SFmode, true, false);
1321 : :
1322 : 6 : operands[4] = gen_reg_rtx (V2SFmode);
1323 : 6 : operands[5] = gen_reg_rtx (V2SFmode);
1324 : : })
1325 : :
1326 : : (define_expand "xorsignv2sf3"
1327 : 6 : [(set (match_dup 4)
1328 : 6 : (and:V2SF (match_dup 3)
1329 : 6 : (match_operand:V2SF 2 "register_operand")))
1330 : 6 : (set (match_operand:V2SF 0 "register_operand")
1331 : 6 : (xor:V2SF (match_dup 4)
1332 : 6 : (match_operand:V2SF 1 "register_operand")))]
1333 : 6 : "TARGET_MMX_WITH_SSE"
1334 : 7 : {
1335 : 8 : operands[3] = ix86_build_signbit_mask (V2SFmode, true, false);
1336 : 6 :
1337 : 1 : operands[4] = gen_reg_rtx (V2SFmode);
1338 : 6 : })
1339 : :
1340 : 6 : (define_expand "signbitv2sf2"
1341 : 1 : [(set (match_operand:V2SI 0 "register_operand")
1342 : 1 : (lshiftrt:V2SI
1343 : 1 : (subreg:V2SI
1344 : 1 : (match_operand:V2SF 1 "register_operand") 0)
1345 : 6 : (match_dup 2)))]
1346 : 1 : "TARGET_MMX_WITH_SSE"
1347 : 3 : {
1348 : 5 : operands[1] = force_reg (V2SFmode, operands[1]);
1349 : 8 : operands[2] = GEN_INT (GET_MODE_UNIT_BITSIZE (V2SFmode)-1);
1350 : 1 : })
1351 : :
1352 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1353 : 6 : ;;
1354 : 6 : ;; Parallel single-precision FMA multiply/accumulate instructions.
1355 : 8 : ;;
1356 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1357 : 2 :
1358 : 2 : (define_expand "fmav2sf4"
1359 : : [(set (match_operand:V2SF 0 "register_operand")
1360 : 3 : (fma:V2SF
1361 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")
1362 : 1 : (match_operand:V2SF 2 "nonimmediate_operand")
1363 : : (match_operand:V2SF 3 "nonimmediate_operand")))]
1364 : 1 : "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512VL)
1365 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1366 : 2 : {
1367 : 3 : rtx op3 = gen_reg_rtx (V4SFmode);
1368 : 398 : rtx op2 = gen_reg_rtx (V4SFmode);
1369 : 398 : rtx op1 = gen_reg_rtx (V4SFmode);
1370 : 398 : rtx op0 = gen_reg_rtx (V4SFmode);
1371 : 3 :
1372 : 401 : emit_insn (gen_movq_v2sf_to_sse (op3, operands[3]));
1373 : 398 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
1374 : 398 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1375 : 2 :
1376 : 400 : emit_insn (gen_fmav4sf4 (op0, op1, op2, op3));
1377 : :
1378 : 398 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1379 : 796 : DONE;
1380 : 398 : })
1381 : 398 :
1382 : 398 : (define_expand "fmsv2sf4"
1383 : 398 : [(set (match_operand:V2SF 0 "register_operand")
1384 : 398 : (fma:V2SF
1385 : 398 : (match_operand:V2SF 1 "nonimmediate_operand")
1386 : : (match_operand:V2SF 2 "nonimmediate_operand")
1387 : : (neg:V2SF
1388 : : (match_operand:V2SF 3 "nonimmediate_operand"))))]
1389 : : "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512VL)
1390 : : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1391 : 18 : {
1392 : 36 : rtx op3 = gen_reg_rtx (V4SFmode);
1393 : 18 : rtx op2 = gen_reg_rtx (V4SFmode);
1394 : 18 : rtx op1 = gen_reg_rtx (V4SFmode);
1395 : 18 : rtx op0 = gen_reg_rtx (V4SFmode);
1396 : :
1397 : 18 : emit_insn (gen_movq_v2sf_to_sse (op3, operands[3]));
1398 : 18 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
1399 : 18 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1400 : :
1401 : 18 : emit_insn (gen_fmsv4sf4 (op0, op1, op2, op3));
1402 : :
1403 : 18 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1404 : 18 : DONE;
1405 : : })
1406 : :
1407 : : (define_expand "fnmav2sf4"
1408 : : [(set (match_operand:V2SF 0 "register_operand")
1409 : 18 : (fma:V2SF
1410 : 18 : (neg:V2SF
1411 : 18 : (match_operand:V2SF 1 "nonimmediate_operand"))
1412 : 18 : (match_operand:V2SF 2 "nonimmediate_operand")
1413 : 18 : (match_operand:V2SF 3 "nonimmediate_operand")))]
1414 : 18 : "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512VL)
1415 : 18 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1416 : 18 : {
1417 : 212 : rtx op3 = gen_reg_rtx (V4SFmode);
1418 : 106 : rtx op2 = gen_reg_rtx (V4SFmode);
1419 : 106 : rtx op1 = gen_reg_rtx (V4SFmode);
1420 : 106 : rtx op0 = gen_reg_rtx (V4SFmode);
1421 : :
1422 : 106 : emit_insn (gen_movq_v2sf_to_sse (op3, operands[3]));
1423 : 106 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
1424 : 106 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1425 : :
1426 : 106 : emit_insn (gen_fnmav4sf4 (op0, op1, op2, op3));
1427 : :
1428 : 106 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1429 : 106 : DONE;
1430 : 106 : })
1431 : :
1432 : : (define_expand "fnmsv2sf4"
1433 : : [(set (match_operand:V2SF 0 "register_operand" "=v,v,x")
1434 : : (fma:V2SF
1435 : 106 : (neg:V2SF
1436 : 106 : (match_operand:V2SF 1 "nonimmediate_operand"))
1437 : 106 : (match_operand:V2SF 2 "nonimmediate_operand")
1438 : 106 : (neg:V2SF
1439 : 106 : (match_operand:V2SF 3 "nonimmediate_operand"))))]
1440 : 106 : "(TARGET_FMA || TARGET_FMA4 || TARGET_AVX512VL)
1441 : 106 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1442 : 106 : {
1443 : 4 : rtx op3 = gen_reg_rtx (V4SFmode);
1444 : 2 : rtx op2 = gen_reg_rtx (V4SFmode);
1445 : 2 : rtx op1 = gen_reg_rtx (V4SFmode);
1446 : 2 : rtx op0 = gen_reg_rtx (V4SFmode);
1447 : :
1448 : 2 : emit_insn (gen_movq_v2sf_to_sse (op3, operands[3]));
1449 : 2 : emit_insn (gen_movq_v2sf_to_sse (op2, operands[2]));
1450 : 2 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1451 : :
1452 : 2 : emit_insn (gen_fnmsv4sf4 (op0, op1, op2, op3));
1453 : :
1454 : 2 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1455 : 2 : DONE;
1456 : : })
1457 : :
1458 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1459 : : ;;
1460 : 2 : ;; Parallel single-precision floating point conversion operations
1461 : 2 : ;;
1462 : 2 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1463 : 2 :
1464 : 2 : (define_expand "fix_truncv2sfv2si2"
1465 : 2 : [(set (match_operand:V2SI 0 "register_operand")
1466 : 2 : (fix:V2SI (match_operand:V2SF 1 "nonimmediate_operand")))]
1467 : 2 : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1468 : 63 : {
1469 : 126 : rtx op1 = gen_reg_rtx (V4SFmode);
1470 : 63 : rtx op0 = gen_reg_rtx (V4SImode);
1471 : :
1472 : 63 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1473 : :
1474 : 63 : emit_insn (gen_fix_truncv4sfv4si2 (op0, op1));
1475 : :
1476 : 63 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1477 : 63 : DONE;
1478 : : })
1479 : :
1480 : : (define_expand "fixuns_truncv2sfv2si2"
1481 : : [(set (match_operand:V2SI 0 "register_operand")
1482 : 63 : (unsigned_fix:V2SI (match_operand:V2SF 1 "nonimmediate_operand")))]
1483 : : "TARGET_AVX512VL && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1484 : 1 : {
1485 : 65 : rtx op1 = gen_reg_rtx (V4SFmode);
1486 : 64 : rtx op0 = gen_reg_rtx (V4SImode);
1487 : 63 :
1488 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1489 : 63 :
1490 : 64 : emit_insn (gen_fixuns_truncv4sfv4si2 (op0, op1));
1491 : :
1492 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1493 : 1 : DONE;
1494 : : })
1495 : :
1496 : 1 : (define_insn "mmx_fix_truncv2sfv2si2"
1497 : : [(set (match_operand:V2SI 0 "register_operand" "=y")
1498 : : (fix:V2SI (match_operand:V2SF 1 "nonimmediate_operand" "ym")))]
1499 : 53 : "TARGET_3DNOW"
1500 : 1 : "pf2id\t{%1, %0|%0, %1}"
1501 : 1 : [(set_attr "type" "mmxcvt")
1502 : 1 : (set_attr "prefix_extra" "1")
1503 : 800 : (set_attr "mode" "V2SF")])
1504 : 800 :
1505 : 799 : (define_expand "floatv2siv2sf2"
1506 : : [(set (match_operand:V2SF 0 "register_operand")
1507 : : (float:V2SF (match_operand:V2SI 1 "nonimmediate_operand")))]
1508 : : "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1509 : 274 : {
1510 : 548 : rtx op1 = gen_reg_rtx (V4SImode);
1511 : 274 : rtx op0 = gen_reg_rtx (V4SFmode);
1512 : 274 :
1513 : 274 : emit_insn (gen_movq_v2si_to_sse (op1, operands[1]));
1514 : :
1515 : 274 : emit_insn (gen_floatv4siv4sf2 (op0, op1));
1516 : 274 :
1517 : 274 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1518 : 274 : DONE;
1519 : 274 : })
1520 : 274 :
1521 : : (define_expand "floatunsv2siv2sf2"
1522 : : [(set (match_operand:V2SF 0 "register_operand")
1523 : : (unsigned_float:V2SF (match_operand:V2SI 1 "nonimmediate_operand")))]
1524 : : "TARGET_AVX512VL && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1525 : 1 : {
1526 : 2 : rtx op1 = gen_reg_rtx (V4SImode);
1527 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
1528 : :
1529 : 1 : emit_insn (gen_movq_v2si_to_sse (op1, operands[1]));
1530 : :
1531 : 1 : emit_insn (gen_floatunsv4siv4sf2 (op0, op1));
1532 : :
1533 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1534 : 1 : DONE;
1535 : : })
1536 : :
1537 : 1 : (define_insn "mmx_floatv2siv2sf2"
1538 : : [(set (match_operand:V2SF 0 "register_operand" "=y")
1539 : : (float:V2SF (match_operand:V2SI 1 "nonimmediate_operand" "ym")))]
1540 : 121 : "TARGET_3DNOW"
1541 : 46 : "pi2fd\t{%1, %0|%0, %1}"
1542 : 1 : [(set_attr "type" "mmxcvt")
1543 : 1 : (set_attr "prefix_extra" "1")
1544 : 1 : (set_attr "mode" "V2SF")])
1545 : 1 :
1546 : : (define_insn "mmx_pf2iw"
1547 : : [(set (match_operand:V2SI 0 "register_operand" "=y")
1548 : 4147 : (sign_extend:V2SI
1549 : 4147 : (ss_truncate:V2HI
1550 : : (fix:V2SI
1551 : 36 : (match_operand:V2SF 1 "nonimmediate_operand" "ym")))))]
1552 : 46 : "TARGET_3DNOW_A"
1553 : 36 : "pf2iw\t{%1, %0|%0, %1}"
1554 : 96 : [(set_attr "type" "mmxcvt")
1555 : 72 : (set_attr "prefix_extra" "1")
1556 : 60 : (set_attr "mode" "V2SF")])
1557 : 17634 :
1558 : 17538 : (define_insn "mmx_pi2fw"
1559 : 96 : [(set (match_operand:V2SF 0 "register_operand" "=y")
1560 : 36 : (float:V2SF
1561 : 17538 : (sign_extend:V2SI
1562 : 17538 : (truncate:V2HI
1563 : : (match_operand:V2SI 1 "nonimmediate_operand" "ym")))))]
1564 : 36 : "TARGET_3DNOW_A"
1565 : 4631 : "pi2fw\t{%1, %0|%0, %1}"
1566 : 4631 : [(set_attr "type" "mmxcvt")
1567 : : (set_attr "prefix_extra" "1")
1568 : : (set_attr "mode" "V2SF")])
1569 : :
1570 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1571 : : ;;
1572 : : ;; Parallel single-precision floating point element swizzling
1573 : : ;;
1574 : 1647 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1575 : :
1576 : : (define_insn "mmx_pswapdv2sf2"
1577 : : [(set (match_operand:V2SF 0 "register_operand" "=y,x,Yv")
1578 : 1647 : (vec_select:V2SF
1579 : 1647 : (match_operand:V2SF 1 "register_mmxmem_operand" "ym,0,Yv")
1580 : 1647 : (parallel [(const_int 1) (const_int 0)])))]
1581 : 2443 : "TARGET_3DNOW_A || TARGET_MMX_WITH_SSE"
1582 : 1647 : "@
1583 : 1647 : pswapd\t{%1, %0|%0, %1}
1584 : 1647 : shufps\t{$0xe1, %1, %0|%0, %1, 0xe1}
1585 : 2891 : vshufps\t{$0xe1, %1, %1, %0|%0, %1, %1, 0xe1}"
1586 : 2891 : [(set_attr "isa" "*,sse_noavx,avx")
1587 : 1244 : (set_attr "mmx_isa" "native,*,*")
1588 : 10 : (set_attr "type" "mmxcvt,ssemov,ssemov")
1589 : 10 : (set_attr "prefix_extra" "1,*,*")
1590 : : (set_attr "mode" "V2SF,V4SF,V4SF")])
1591 : 5 :
1592 : 5 : (define_insn "*mmx_movshdup"
1593 : : [(set (match_operand:V2SF 0 "register_operand" "=v,x")
1594 : : (vec_select:V2SF
1595 : : (match_operand:V2SF 1 "register_operand" "v,0")
1596 : : (parallel [(const_int 1) (const_int 1)])))]
1597 : 1140 : "TARGET_MMX_WITH_SSE"
1598 : : "@
1599 : : %vmovshdup\t{%1, %0|%0, %1}
1600 : : shufps\t{$0xe5, %0, %0|%0, %0, 0xe5}"
1601 : : [(set_attr "isa" "sse3,*")
1602 : : (set_attr "type" "sse,sseshuf1")
1603 : : (set_attr "length_immediate" "*,1")
1604 : : (set_attr "prefix_rep" "1,*")
1605 : : (set_attr "prefix" "maybe_vex,orig")
1606 : : (set_attr "mode" "V4SF")])
1607 : 1704 :
1608 : 1704 : (define_insn "*mmx_movsldup"
1609 : : [(set (match_operand:V2SF 0 "register_operand" "=v,x")
1610 : 1258 : (vec_select:V2SF
1611 : 1258 : (match_operand:V2SF 1 "register_operand" "v,0")
1612 : 1236 : (parallel [(const_int 0) (const_int 0)])))]
1613 : 2394 : "TARGET_MMX_WITH_SSE"
1614 : : "@
1615 : : %vmovsldup\t{%1, %0|%0, %1}
1616 : : shufps\t{$0xe0, %0, %0|%0, %0, 0xe0}"
1617 : 443 : [(set_attr "isa" "sse3,*")
1618 : 443 : (set_attr "type" "sse,sseshuf1")
1619 : 443 : (set_attr "length_immediate" "*,1")
1620 : 879 : (set_attr "prefix_rep" "1,*")
1621 : : (set_attr "prefix" "maybe_vex,orig")
1622 : : (set_attr "mode" "V4SF")])
1623 : :
1624 : : (define_insn_and_split "*vec_interleave_lowv2sf"
1625 : : [(set (match_operand:V2SF 0 "register_operand" "=x,v")
1626 : : (vec_select:V2SF
1627 : : (vec_concat:V4SF
1628 : : (match_operand:V2SF 1 "register_operand" "0,v")
1629 : : (match_operand:V2SF 2 "register_operand" "x,v"))
1630 : : (parallel [(const_int 0) (const_int 2)])))]
1631 : 120 : "TARGET_MMX_WITH_SSE"
1632 : : "#"
1633 : 120 : "&& reload_completed"
1634 : 60 : [(const_int 0)]
1635 : 3368 : "ix86_split_mmx_punpck (operands, false); DONE;"
1636 : 3308 : [(set_attr "isa" "noavx,avx")
1637 : 210 : (set_attr "type" "sselog")
1638 : 210 : (set_attr "prefix" "orig,maybe_evex")
1639 : : (set_attr "mode" "V4SF")])
1640 : :
1641 : : (define_insn_and_split "*vec_interleave_highv2sf"
1642 : : [(set (match_operand:V2SF 0 "register_operand" "=x,v")
1643 : : (vec_select:V2SF
1644 : : (vec_concat:V4SF
1645 : : (match_operand:V2SF 1 "register_operand" "0,v")
1646 : : (match_operand:V2SF 2 "register_operand" "x,v"))
1647 : 47 : (parallel [(const_int 1) (const_int 3)])))]
1648 : 1023 : "TARGET_MMX_WITH_SSE"
1649 : 47 : "#"
1650 : 141 : "&& reload_completed"
1651 : 47 : [(const_int 0)]
1652 : 2210 : "ix86_split_mmx_punpck (operands, true); DONE;"
1653 : 2163 : [(set_attr "isa" "noavx,avx")
1654 : 184 : (set_attr "type" "sselog")
1655 : 184 : (set_attr "prefix" "orig,vex")
1656 : : (set_attr "mode" "V4SF")])
1657 : :
1658 : : (define_insn "*vec_dupv2sf"
1659 : : [(set (match_operand:V2SF 0 "register_operand" "=y,Yv,x")
1660 : : (vec_duplicate:V2SF
1661 : : (match_operand:SF 1 "register_operand" "0,Yv,0")))]
1662 : 1720 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
1663 : 217 : "@
1664 : : punpckldq\t%0, %0
1665 : : %vmovsldup\t{%1, %0|%0, %1}
1666 : 19 : shufps\t{$0xe0, %0, %0|%0, %0, 0xe0}"
1667 : 28 : [(set_attr "isa" "*,sse3,sse_noavx")
1668 : 25 : (set_attr "mmx_isa" "native,*,*")
1669 : 25 : (set_attr "type" "mmxcvt,sse,sseshuf1")
1670 : 44 : (set_attr "length_immediate" "*,*,1")
1671 : 9 : (set_attr "prefix_rep" "*,1,*")
1672 : 9 : (set_attr "prefix" "*,maybe_vex,orig")
1673 : 9 : (set_attr "mode" "DI,V4SF,V4SF")])
1674 : :
1675 : : (define_insn "*mmx_movss_<mode>"
1676 : : [(set (match_operand:V2FI 0 "register_operand" "=x,v")
1677 : : (vec_merge:V2FI
1678 : : (match_operand:V2FI 2 "register_operand" " x,v")
1679 : : (match_operand:V2FI 1 "register_operand" " 0,v")
1680 : : (const_int 1)))]
1681 : : "TARGET_MMX_WITH_SSE"
1682 : : "@
1683 : : movss\t{%2, %0|%0, %2}
1684 : : vmovss\t{%2, %1, %0|%0, %1, %2}"
1685 : 215 : [(set_attr "isa" "noavx,avx")
1686 : 215 : (set_attr "type" "ssemov")
1687 : 215 : (set_attr "prefix" "orig,maybe_evex")
1688 : : (set_attr "mode" "SF")])
1689 : 317528 :
1690 : 317528 : (define_insn "*mmx_concatv2sf"
1691 : 317528 : [(set (match_operand:V2SF 0 "register_operand" "=y,y")
1692 : 317528 : (vec_concat:V2SF
1693 : 317528 : (match_operand:SF 1 "nonimmediate_operand" " 0,rm")
1694 : 317528 : (match_operand:SF 2 "nonimm_or_0_operand" "ym,C")))]
1695 : 41252 : "TARGET_MMX && !TARGET_SSE"
1696 : 317528 : "@
1697 : 41252 : punpckldq\t{%2, %0|%0, %2}
1698 : 305318 : movd\t{%1, %0|%0, %1}"
1699 : : [(set_attr "type" "mmxcvt,mmxmov")
1700 : 172 : (set_attr "mode" "DI")])
1701 : 172 :
1702 : 172 : (define_expand "vec_setv2sf"
1703 : : [(match_operand:V2SF 0 "register_operand")
1704 : : (match_operand:SF 1 "register_operand")
1705 : : (match_operand 2 "vec_setm_mmx_operand")]
1706 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
1707 : 9 : {
1708 : 9 : if (CONST_INT_P (operands[2]))
1709 : 7 : ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
1710 : 7 : INTVAL (operands[2]));
1711 : : else
1712 : 2 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
1713 : 9 : DONE;
1714 : : })
1715 : :
1716 : : ;; Avoid combining registers from different units in a single alternative,
1717 : : ;; see comment above inline_secondary_memory_needed function in i386.cc
1718 : : (define_insn_and_split "*vec_extractv2sf_0"
1719 : : [(set (match_operand:SF 0 "nonimmediate_operand" "=x, m,y ,m,f,r")
1720 : : (vec_select:SF
1721 : : (match_operand:V2SF 1 "nonimmediate_operand" " xm,x,ym,y,m,m")
1722 : : (parallel [(const_int 0)])))]
1723 : 1183 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
1724 : 4052 : && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1725 : : "#"
1726 : 1165 : "&& reload_completed"
1727 : 326 : [(set (match_dup 0) (match_dup 1))]
1728 : 24294 : "operands[1] = gen_lowpart (SFmode, operands[1]);"
1729 : 23968 : [(set_attr "mmx_isa" "*,*,native,native,*,*")])
1730 : 10135 :
1731 : 10461 : ;; Avoid combining registers from different units in a single alternative,
1732 : 326 : ;; see comment above inline_secondary_memory_needed function in i386.cc
1733 : 326 : (define_insn "*vec_extractv2sf_1"
1734 : 326 : [(set (match_operand:SF 0 "nonimmediate_operand" "=y,x,x,y,x,f,r")
1735 : 326 : (vec_select:SF
1736 : : (match_operand:V2SF 1 "nonimmediate_operand" " 0,x,0,o,o,o,o")
1737 : 326 : (parallel [(const_int 1)])))]
1738 : 1679 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
1739 : 2005 : && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
1740 : 326 : "@
1741 : 0 : punpckhdq\t%0, %0
1742 : 326 : %vmovshdup\t{%1, %0|%0, %1}
1743 : 4587 : shufps\t{$0xe5, %0, %0|%0, %0, 0xe5}
1744 : 4587 : #
1745 : 4456 : #
1746 : 9040 : #
1747 : 3 : #"
1748 : 4408 : [(set_attr "isa" "*,sse3,noavx,*,*,*,*")
1749 : 3 : (set_attr "mmx_isa" "native,*,*,native,*,*,*")
1750 : 3 : (set_attr "type" "mmxcvt,sse,sseshuf1,mmxmov,ssemov,fmov,imov")
1751 : 0 : (set (attr "length_immediate")
1752 : 3 : (if_then_else (eq_attr "alternative" "2")
1753 : : (const_string "1")
1754 : : (const_string "*")))
1755 : : (set (attr "prefix_rep")
1756 : : (if_then_else (eq_attr "alternative" "1")
1757 : : (const_string "1")
1758 : : (const_string "*")))
1759 : : (set_attr "prefix" "orig,maybe_vex,orig,orig,orig,orig,orig")
1760 : : (set_attr "mode" "DI,V4SF,V4SF,SF,SF,SF,SF")])
1761 : :
1762 : : (define_split
1763 : : [(set (match_operand:SF 0 "register_operand")
1764 : : (vec_select:SF
1765 : : (match_operand:V2SF 1 "memory_operand")
1766 : : (parallel [(const_int 1)])))]
1767 : 3 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && reload_completed"
1768 : 3 : [(set (match_dup 0) (match_dup 1))]
1769 : 3 : "operands[1] = adjust_address (operands[1], SFmode, 4);")
1770 : :
1771 : 4777 : (define_expand "vec_extractv2sfsf"
1772 : 4780 : [(match_operand:SF 0 "register_operand")
1773 : 4080 : (match_operand:V2SF 1 "register_operand")
1774 : 4080 : (match_operand 2 "const_int_operand")]
1775 : 4780 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
1776 : 3 : {
1777 : 1024 : ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
1778 : 3 : operands[1], INTVAL (operands[2]));
1779 : 1027 : DONE;
1780 : 3 : })
1781 : :
1782 : : (define_expand "vec_initv2sfsf"
1783 : : [(match_operand:V2SF 0 "register_operand")
1784 : : (match_operand 1)]
1785 : 1024 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
1786 : 1757 : {
1787 : 1757 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
1788 : : operands[1]);
1789 : 1757 : DONE;
1790 : 1024 : })
1791 : 1024 :
1792 : 1024 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1793 : 1024 : ;;
1794 : 1024 : ;; Parallel single-precision floating point rounding operations.
1795 : 1024 : ;;
1796 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1797 : :
1798 : : (define_expand "nearbyintv2sf2"
1799 : : [(match_operand:V2SF 0 "register_operand")
1800 : 1757 : (match_operand:V2SF 1 "nonimmediate_operand")]
1801 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1802 : 1 : {
1803 : 1759 : rtx op1 = gen_reg_rtx (V4SFmode);
1804 : 1758 : rtx op0 = gen_reg_rtx (V4SFmode);
1805 : 1757 :
1806 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1807 : 1758 :
1808 : 1758 : emit_insn (gen_nearbyintv4sf2 (op0, op1));
1809 : :
1810 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1811 : 2 : DONE;
1812 : 1 : })
1813 : 1 :
1814 : 1 : (define_expand "rintv2sf2"
1815 : 1 : [(match_operand:V2SF 0 "register_operand")
1816 : : (match_operand:V2SF 1 "nonimmediate_operand")]
1817 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1818 : 1 : {
1819 : 2 : rtx op1 = gen_reg_rtx (V4SFmode);
1820 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
1821 : :
1822 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1823 : :
1824 : 1 : emit_insn (gen_rintv4sf2 (op0, op1));
1825 : :
1826 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1827 : 1 : DONE;
1828 : : })
1829 : 1 :
1830 : : (define_expand "lrintv2sfv2si2"
1831 : : [(match_operand:V2SI 0 "register_operand")
1832 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1833 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1834 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1835 : 2 : {
1836 : 3 : rtx op1 = gen_reg_rtx (V4SFmode);
1837 : 2 : rtx op0 = gen_reg_rtx (V4SImode);
1838 : :
1839 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1840 : :
1841 : 1 : emit_insn (gen_lrintv4sfv4si2 (op0, op1));
1842 : :
1843 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1844 : 1 : DONE;
1845 : 1 : })
1846 : :
1847 : : (define_expand "ceilv2sf2"
1848 : 1 : [(match_operand:V2SF 0 "register_operand")
1849 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1850 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1851 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1852 : 2 : {
1853 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1854 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
1855 : :
1856 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1857 : :
1858 : 1 : emit_insn (gen_ceilv4sf2 (op0, op1));
1859 : :
1860 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1861 : 1 : DONE;
1862 : 1 : })
1863 : :
1864 : : (define_expand "lceilv2sfv2si2"
1865 : 1 : [(match_operand:V2SI 0 "register_operand")
1866 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1867 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1868 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1869 : 2 : {
1870 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1871 : 1 : rtx op0 = gen_reg_rtx (V4SImode);
1872 : :
1873 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1874 : :
1875 : 1 : emit_insn (gen_lceilv4sfv4si2 (op0, op1));
1876 : :
1877 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1878 : 1 : DONE;
1879 : 1 : })
1880 : :
1881 : : (define_expand "floorv2sf2"
1882 : 1 : [(match_operand:V2SF 0 "register_operand")
1883 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1884 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1885 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1886 : 3 : {
1887 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1888 : 2 : rtx op0 = gen_reg_rtx (V4SFmode);
1889 : :
1890 : 2 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1891 : :
1892 : 2 : emit_insn (gen_floorv4sf2 (op0, op1));
1893 : :
1894 : 2 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1895 : 2 : DONE;
1896 : 2 : })
1897 : :
1898 : : (define_expand "lfloorv2sfv2si2"
1899 : 2 : [(match_operand:V2SI 0 "register_operand")
1900 : 2 : (match_operand:V2SF 1 "nonimmediate_operand")]
1901 : 2 : "TARGET_SSE4_1 && !flag_trapping_math
1902 : 2 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1903 : 3 : {
1904 : 2 : rtx op1 = gen_reg_rtx (V4SFmode);
1905 : 1 : rtx op0 = gen_reg_rtx (V4SImode);
1906 : :
1907 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1908 : :
1909 : 1 : emit_insn (gen_lfloorv4sfv4si2 (op0, op1));
1910 : :
1911 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1912 : 1 : DONE;
1913 : 1 : })
1914 : :
1915 : : (define_expand "btruncv2sf2"
1916 : 1 : [(match_operand:V2SF 0 "register_operand")
1917 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1918 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1919 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1920 : 2 : {
1921 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1922 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
1923 : :
1924 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1925 : :
1926 : 1 : emit_insn (gen_btruncv4sf2 (op0, op1));
1927 : :
1928 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1929 : 1 : DONE;
1930 : 1 : })
1931 : :
1932 : : (define_expand "roundv2sf2"
1933 : 1 : [(match_operand:V2SF 0 "register_operand")
1934 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1935 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1936 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1937 : 2 : {
1938 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1939 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
1940 : :
1941 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1942 : :
1943 : 1 : emit_insn (gen_roundv4sf2 (op0, op1));
1944 : :
1945 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
1946 : 1 : DONE;
1947 : 1 : })
1948 : :
1949 : : (define_expand "lroundv2sfv2si2"
1950 : 1 : [(match_operand:V2SI 0 "register_operand")
1951 : 1 : (match_operand:V2SF 1 "nonimmediate_operand")]
1952 : 1 : "TARGET_SSE4_1 && !flag_trapping_math
1953 : 1 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
1954 : 2 : {
1955 : 1 : rtx op1 = gen_reg_rtx (V4SFmode);
1956 : 1 : rtx op0 = gen_reg_rtx (V4SImode);
1957 : :
1958 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
1959 : :
1960 : 1 : emit_insn (gen_lroundv4sfv4si2 (op0, op1));
1961 : :
1962 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
1963 : 1 : DONE;
1964 : 1 : })
1965 : :
1966 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1967 : 1 : ;;
1968 : 1 : ;; Parallel half-precision floating point arithmetic
1969 : 1 : ;;
1970 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1971 : 1 :
1972 : 1 : (define_mode_iterator VHF_32_64 [V2HF (V4HF "TARGET_MMX_WITH_SSE")])
1973 : :
1974 : : (define_expand "divv4hf3"
1975 : : [(set (match_operand:V4HF 0 "register_operand")
1976 : 1978 : (div:V4HF
1977 : 1018 : (match_operand:V4HF 1 "nonimmediate_operand")
1978 : 994 : (match_operand:V4HF 2 "register_operand")))]
1979 : : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
1980 : 6 : {
1981 : 18 : rtx op2 = gen_reg_rtx (V8HFmode);
1982 : 6 : rtx op1 = gen_reg_rtx (V8HFmode);
1983 : 6 : rtx op0 = gen_reg_rtx (V8HFmode);
1984 : :
1985 : 6 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
1986 : 12 : rtx tmp = gen_rtx_VEC_CONCAT (V8HFmode, operands[2],
1987 : 6 : force_reg (V4HFmode, CONST1_RTX (V4HFmode)));
1988 : 6 : emit_insn (gen_rtx_SET (op2, tmp));
1989 : 6 : emit_insn (gen_divv8hf3 (op0, op1, op2));
1990 : 6 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
1991 : 12 : DONE;
1992 : : })
1993 : :
1994 : : (define_mode_attr mov_to_sse_suffix
1995 : : [(V2HF "d") (V4HF "q") (V2HI "d") (V4HI "q")])
1996 : :
1997 : : (define_mode_attr mmxxmmmode
1998 : : [(V2HF "V8HF") (V2HI "V8HI") (V2BF "V8BF")
1999 : : (V4HF "V8HF") (V4HI "V8HI") (V4BF "V8BF")])
2000 : :
2001 : : (define_mode_attr mmxxmmmodelower
2002 : : [(V2HF "v8hf") (V2HI "v8hi") (V2BF "v8bf")
2003 : : (V4HF "v8hf") (V4HI "v8hi") (V4BF "v8bf")])
2004 : :
2005 : : (define_expand "movd_<mode>_to_sse"
2006 : : [(set (match_operand:<mmxxmmmode> 0 "register_operand")
2007 : : (vec_merge:<mmxxmmmode>
2008 : : (vec_duplicate:<mmxxmmmode>
2009 : : (match_operand:V2FI_32 1 "nonimmediate_operand"))
2010 : : (match_dup 2)
2011 : : (const_int 3)))]
2012 : : "TARGET_SSE"
2013 : 200 : {
2014 : 101 : if (!flag_trapping_math)
2015 : : {
2016 : 9 : rtx op1 = force_reg (<MODE>mode, operands[1]);
2017 : 9 : emit_move_insn (operands[0],
2018 : 99 : lowpart_subreg (<mmxxmmmode>mode, op1, <MODE>mode));
2019 : 9 : DONE;
2020 : 99 : }
2021 : 191 : operands[2] = CONST0_RTX (<mmxxmmmode>mode);
2022 : 99 : })
2023 : :
2024 : : (define_expand "movd_<mode>_to_sse_reg"
2025 : 92 : [(set (match_operand:<mmxxmmmode> 0 "register_operand")
2026 : 92 : (vec_merge:<mmxxmmmode>
2027 : 110 : (vec_duplicate:<mmxxmmmode>
2028 : 92 : (match_operand:V2FI_32 1 "nonimmediate_operand"))
2029 : 92 : (match_operand:<mmxxmmmode> 2 "register_operand")
2030 : 92 : (const_int 3)))]
2031 : : "TARGET_SSE")
2032 : 92 :
2033 : : (define_expand "<insn><mode>3"
2034 : : [(set (match_operand:VHF_32_64 0 "register_operand")
2035 : : (plusminusmult:VHF_32_64
2036 : : (match_operand:VHF_32_64 1 "nonimmediate_operand")
2037 : : (match_operand:VHF_32_64 2 "nonimmediate_operand")))]
2038 : 92 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2039 : 117 : {
2040 : 92 : rtx op2 = gen_reg_rtx (V8HFmode);
2041 : 25 : rtx op1 = gen_reg_rtx (V8HFmode);
2042 : 25 : rtx op0 = gen_reg_rtx (V8HFmode);
2043 : :
2044 : 25 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2045 : 32 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2046 : 25 : emit_insn (gen_<insn>v8hf3 (op0, op1, op2));
2047 : :
2048 : 25 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2049 : 30 : DONE;
2050 : 2 : })
2051 : 2 :
2052 : 2 : (define_expand "divv2hf3"
2053 : 2 : [(set (match_operand:V2HF 0 "register_operand")
2054 : 2 : (div:V2HF
2055 : : (match_operand:V2HF 1 "nonimmediate_operand")
2056 : : (match_operand:V2HF 2 "nonimmediate_operand")))]
2057 : : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2058 : 5 : {
2059 : 10 : rtx op2 = gen_reg_rtx (V8HFmode);
2060 : 5 : rtx op1 = gen_reg_rtx (V8HFmode);
2061 : 5 : rtx op0 = gen_reg_rtx (V8HFmode);
2062 : :
2063 : 5 : emit_insn (gen_movd_v2hf_to_sse_reg (op2, operands[2],
2064 : : force_reg (V8HFmode, CONST1_RTX (V8HFmode))));
2065 : 5 : emit_insn (gen_movd_v2hf_to_sse (op1, operands[1]));
2066 : 5 : emit_insn (gen_divv8hf3 (op0, op1, op2));
2067 : :
2068 : 5 : emit_move_insn (operands[0], lowpart_subreg (V2HFmode, op0, V8HFmode));
2069 : 5 : DONE;
2070 : : })
2071 : 26 :
2072 : : (define_expand "<code><mode>3"
2073 : 0 : [(set (match_operand:VHF_32_64 0 "register_operand")
2074 : : (smaxmin:VHF_32_64
2075 : 26 : (match_operand:VHF_32_64 1 "nonimmediate_operand")
2076 : 26 : (match_operand:VHF_32_64 2 "nonimmediate_operand")))]
2077 : 0 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2078 : 30 : {
2079 : 34 : rtx op2 = gen_reg_rtx (V8HFmode);
2080 : 4 : rtx op1 = gen_reg_rtx (V8HFmode);
2081 : 30 : rtx op0 = gen_reg_rtx (V8HFmode);
2082 : :
2083 : 4 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2084 : 4 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2085 : :
2086 : 4 : emit_insn (gen_<code>v8hf3 (op0, op1, op2));
2087 : 4 :
2088 : 4 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2089 : 4 : DONE;
2090 : : })
2091 : 5 :
2092 : 4 : (define_expand "sqrt<mode>2"
2093 : 4 : [(set (match_operand:VHF_32_64 0 "register_operand")
2094 : 4 : (sqrt:VHF_32_64
2095 : 5 : (match_operand:VHF_32_64 1 "nonimmediate_operand")))]
2096 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2097 : 4 : {
2098 : 5 : rtx op1 = gen_reg_rtx (V8HFmode);
2099 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2100 : 1 :
2101 : 3 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2102 : 2 : emit_insn (gen_sqrtv8hf2 (op0, op1));
2103 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2104 : 2 : DONE;
2105 : : })
2106 : :
2107 : : (define_expand "<code><mode>2"
2108 : : [(set (match_operand:VHF_32_64 0 "register_operand")
2109 : : (absneg:VHF_32_64
2110 : : (match_operand:VHF_32_64 1 "register_operand")))]
2111 : 4 : "TARGET_SSE"
2112 : 5 : "ix86_expand_fp_absneg_operator (<CODE>, <MODE>mode, operands); DONE;")
2113 : :
2114 : 1 : (define_insn_and_split "*mmx_<code><mode>"
2115 : 1 : [(set (match_operand:VHF_32_64 0 "register_operand" "=x,x,x")
2116 : 3 : (absneg:VHF_32_64
2117 : 4 : (match_operand:VHF_32_64 1 "register_operand" "0,x,x")))
2118 : 4 : (use (match_operand:VHF_32_64 2 "register_operand" "x,0,x"))]
2119 : 7 : "TARGET_SSE"
2120 : 3 : "#"
2121 : 7 : "&& reload_completed"
2122 : : [(set (match_dup 0)
2123 : 7 : (<absneg_op>:<MODE> (match_dup 1) (match_dup 2)))]
2124 : 8 : {
2125 : 25 : if (!TARGET_AVX && operands_match_p (operands[0], operands[2]))
2126 : 34 : std::swap (operands[1], operands[2]);
2127 : 2 : }
2128 : 2 : [(set_attr "isa" "noavx,noavx,avx")])
2129 : 2 :
2130 : 11 : (define_insn_and_split "*mmx_nabs<mode>2"
2131 : 2 : [(set (match_operand:VHF_32_64 0 "register_operand" "=x,x,x")
2132 : 5 : (neg:VHF_32_64
2133 : 10 : (abs:VHF_32_64
2134 : 4 : (match_operand:VHF_32_64 1 "register_operand" "0,x,x"))))
2135 : 10 : (use (match_operand:VHF_32_64 2 "register_operand" "x,0,x"))]
2136 : 5 : "TARGET_SSE"
2137 : 1 : "#"
2138 : 4 : "&& reload_completed"
2139 : 1 : [(set (match_dup 0)
2140 : 5 : (ior:<MODE> (match_dup 1) (match_dup 2)))])
2141 : 5 :
2142 : 5 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2143 : 0 : ;;
2144 : 0 : ;; Parallel half-precision floating point comparisons
2145 : : ;;
2146 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2147 : :
2148 : 4 : (define_expand "vec_cmpv4hfqi"
2149 : : [(set (match_operand:QI 0 "register_operand")
2150 : 4 : (match_operator:QI 1 ""
2151 : 4 : [(match_operand:V4HF 2 "nonimmediate_operand")
2152 : 4 : (match_operand:V4HF 3 "nonimmediate_operand")]))]
2153 : 4 : "TARGET_MMX_WITH_SSE && TARGET_AVX512FP16 && TARGET_AVX512VL
2154 : 4 : && ix86_partial_vec_fp_math"
2155 : 0 : {
2156 : 4 : rtx ops[4];
2157 : 68 : ops[3] = gen_reg_rtx (V8HFmode);
2158 : 34 : ops[2] = gen_reg_rtx (V8HFmode);
2159 : 0 :
2160 : 34 : emit_insn (gen_movq_v4hf_to_sse (ops[3], operands[3]));
2161 : 34 : emit_insn (gen_movq_v4hf_to_sse (ops[2], operands[2]));
2162 : 34 : emit_insn (gen_vec_cmpv8hfqi (operands[0], operands[1], ops[2], ops[3]));
2163 : 34 : DONE;
2164 : : })
2165 : :
2166 : : (define_expand "vcond_mask_<mode>v4hi"
2167 : 0 : [(set (match_operand:V4F_64 0 "register_operand")
2168 : 0 : (vec_merge:V4F_64
2169 : 0 : (match_operand:V4F_64 1 "register_operand")
2170 : : (match_operand:V4F_64 2 "register_operand")
2171 : : (match_operand:V4HI 3 "register_operand")))]
2172 : : "TARGET_MMX_WITH_SSE && TARGET_SSE4_1"
2173 : 24 : {
2174 : 24 : ix86_expand_sse_movcc (operands[0], operands[3],
2175 : 0 : operands[1], operands[2]);
2176 : 24 : DONE;
2177 : 0 : })
2178 : 0 :
2179 : 0 : (define_expand "vcond_mask_<mode>qi"
2180 : 0 : [(set (match_operand:V4FI_64 0 "register_operand")
2181 : 0 : (vec_merge:V4FI_64
2182 : 0 : (match_operand:V4FI_64 1 "register_operand")
2183 : 0 : (match_operand:V4FI_64 2 "register_operand")
2184 : 0 : (match_operand:QI 3 "register_operand")))]
2185 : 0 : "TARGET_MMX_WITH_SSE && TARGET_AVX512BW && TARGET_AVX512VL"
2186 : 21 : {
2187 : 62 : rtx op0 = gen_reg_rtx (<mmxxmmmode>mode);
2188 : 21 : operands[1] = lowpart_subreg (<mmxxmmmode>mode, operands[1], <MODE>mode);
2189 : 21 : operands[2] = lowpart_subreg (<mmxxmmmode>mode, operands[2], <MODE>mode);
2190 : 21 : emit_insn (gen_vcond_mask_<mmxxmmmodelower>qi (op0, operands[1],
2191 : : operands[2], operands[3]));
2192 : 21 : emit_move_insn (operands[0],
2193 : 20 : lowpart_subreg (<MODE>mode, op0, <mmxxmmmode>mode));
2194 : 21 : DONE;
2195 : 0 : })
2196 : 20 :
2197 : 20 : (define_expand "vec_cmpv2hfqi"
2198 : 20 : [(set (match_operand:QI 0 "register_operand")
2199 : 20 : (match_operator:QI 1 ""
2200 : : [(match_operand:V2HF 2 "nonimmediate_operand")
2201 : 38 : (match_operand:V2HF 3 "nonimmediate_operand")]))]
2202 : : "TARGET_AVX512FP16 && TARGET_AVX512VL
2203 : : && ix86_partial_vec_fp_math"
2204 : 21 : {
2205 : 21 : rtx ops[4];
2206 : 80 : ops[3] = gen_reg_rtx (V8HFmode);
2207 : 59 : ops[2] = gen_reg_rtx (V8HFmode);
2208 : 38 :
2209 : 21 : emit_insn (gen_movd_v2hf_to_sse (ops[3], operands[3]));
2210 : 21 : emit_insn (gen_movd_v2hf_to_sse (ops[2], operands[2]));
2211 : 21 : emit_insn (gen_vec_cmpv8hfqi (operands[0], operands[1], ops[2], ops[3]));
2212 : 21 : DONE;
2213 : 38 : })
2214 : :
2215 : : (define_expand "vcond_mask_<mode>v2hi"
2216 : : [(set (match_operand:V2F_32 0 "register_operand")
2217 : : (vec_merge:V2F_32
2218 : : (match_operand:V2F_32 1 "register_operand")
2219 : 42 : (match_operand:V2F_32 2 "register_operand")
2220 : : (match_operand:V2HI 3 "register_operand")))]
2221 : : "TARGET_SSE4_1"
2222 : 24 : {
2223 : 24 : ix86_expand_sse_movcc (operands[0], operands[3],
2224 : 42 : operands[1], operands[2]);
2225 : 66 : DONE;
2226 : 42 : })
2227 : 42 :
2228 : 42 : (define_expand "vcond_mask_<mode>qi"
2229 : 42 : [(set (match_operand:V2FI_32 0 "register_operand")
2230 : 42 : (vec_merge:V2FI_32
2231 : 42 : (match_operand:V2FI_32 1 "register_operand")
2232 : : (match_operand:V2FI_32 2 "register_operand")
2233 : : (match_operand:QI 3 "register_operand")))]
2234 : : "TARGET_AVX512BW && TARGET_AVX512VL"
2235 : 21 : {
2236 : 62 : rtx op0 = gen_reg_rtx (<mmxxmmmode>mode);
2237 : 21 : operands[1] = lowpart_subreg (<mmxxmmmode>mode, operands[1], <MODE>mode);
2238 : 21 : operands[2] = lowpart_subreg (<mmxxmmmode>mode, operands[2], <MODE>mode);
2239 : 21 : emit_insn (gen_vcond_mask_<mmxxmmmodelower>qi (op0, operands[1],
2240 : : operands[2], operands[3]));
2241 : 21 : emit_move_insn (operands[0],
2242 : 20 : lowpart_subreg (<MODE>mode, op0, <mmxxmmmode>mode));
2243 : 21 : DONE;
2244 : 20 : })
2245 : 20 :
2246 : 20 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2247 : 20 : ;;
2248 : 20 : ;; Parallel half-precision floating point rounding operations.
2249 : : ;;
2250 : 4 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2251 : :
2252 : : (define_expand "btrunc<mode>2"
2253 : : [(match_operand:VHF_32_64 0 "register_operand")
2254 : : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2255 : 4 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2256 : 4 : && ix86_partial_vec_fp_math
2257 : 4 : && !flag_trapping_math"
2258 : 6 : {
2259 : 8 : rtx op1 = gen_reg_rtx (V8HFmode);
2260 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2261 : 4 :
2262 : 6 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2263 : 2 : emit_insn (gen_btruncv8hf2 (op0, op1));
2264 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2265 : :
2266 : 2 : DONE;
2267 : : })
2268 : 22 :
2269 : : (define_expand "nearbyint<mode>2"
2270 : : [(match_operand:VHF_32_64 0 "register_operand")
2271 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2272 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2273 : 22 : && ix86_partial_vec_fp_math"
2274 : 21 : {
2275 : 26 : rtx op1 = gen_reg_rtx (V8HFmode);
2276 : 3 : rtx op0 = gen_reg_rtx (V8HFmode);
2277 : 21 :
2278 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2279 : 2 : emit_insn (gen_nearbyintv8hf2 (op0, op1));
2280 : 23 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2281 : :
2282 : 2 : DONE;
2283 : : })
2284 : 2 :
2285 : : (define_expand "rint<mode>2"
2286 : : [(match_operand:VHF_32_64 0 "register_operand")
2287 : 2 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2288 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2289 : 2 : && ix86_partial_vec_fp_math"
2290 : 4 : {
2291 : 6 : rtx op1 = gen_reg_rtx (V8HFmode);
2292 : 4 : rtx op0 = gen_reg_rtx (V8HFmode);
2293 : :
2294 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2295 : 2 : emit_insn (gen_rintv8hf2 (op0, op1));
2296 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2297 : :
2298 : 2 : DONE;
2299 : : })
2300 : 2 :
2301 : : (define_expand "lrint<mode><mmxintvecmodelower>2"
2302 : : [(match_operand:<mmxintvecmode> 0 "register_operand")
2303 : 2 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2304 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2305 : 2 : && ix86_partial_vec_fp_math"
2306 : 2 : {
2307 : 2 : rtx op1 = gen_reg_rtx (V8HFmode);
2308 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2309 : :
2310 : 0 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2311 : 0 : emit_insn (gen_lrintv8hfv8hi2 (op0, op1));
2312 : 0 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2313 : :
2314 : 0 : DONE;
2315 : : })
2316 : 1 :
2317 : : (define_expand "floor<mode>2"
2318 : : [(match_operand:VHF_32_64 0 "register_operand")
2319 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2320 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2321 : 1 : && ix86_partial_vec_fp_math
2322 : 1 : && !flag_trapping_math"
2323 : 3 : {
2324 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2325 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2326 : :
2327 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2328 : 2 : emit_insn (gen_floorv8hf2 (op0, op1));
2329 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2330 : :
2331 : 2 : DONE;
2332 : 1 : })
2333 : :
2334 : : (define_expand "lfloor<mode><mmxintvecmodelower>2"
2335 : 1 : [(match_operand:<mmxintvecmode> 0 "register_operand")
2336 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2337 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2338 : 1 : && ix86_partial_vec_fp_math
2339 : 1 : && !flag_trapping_math"
2340 : 1 : {
2341 : 0 : rtx op1 = gen_reg_rtx (V8HFmode);
2342 : 0 : rtx op0 = gen_reg_rtx (V8HFmode);
2343 : :
2344 : 0 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2345 : 0 : emit_insn (gen_lfloorv8hfv8hi2 (op0, op1));
2346 : 0 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2347 : :
2348 : 0 : DONE;
2349 : 1 : })
2350 : :
2351 : : (define_expand "ceil<mode>2"
2352 : 1 : [(match_operand:VHF_32_64 0 "register_operand")
2353 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2354 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2355 : 1 : && ix86_partial_vec_fp_math
2356 : 1 : && !flag_trapping_math"
2357 : 1 : {
2358 : 4 : rtx op1 = gen_reg_rtx (V8HFmode);
2359 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2360 : :
2361 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2362 : 2 : emit_insn (gen_ceilv8hf2 (op0, op1));
2363 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2364 : :
2365 : 2 : DONE;
2366 : 1 : })
2367 : :
2368 : : (define_expand "lceil<mode><mmxintvecmodelower>2"
2369 : 1 : [(match_operand:<mmxintvecmode> 0 "register_operand")
2370 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2371 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2372 : 1 : && ix86_partial_vec_fp_math
2373 : 1 : && !flag_trapping_math"
2374 : 1 : {
2375 : 0 : rtx op1 = gen_reg_rtx (V8HFmode);
2376 : 0 : rtx op0 = gen_reg_rtx (V8HFmode);
2377 : :
2378 : 0 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2379 : 0 : emit_insn (gen_lceilv8hfv8hi2 (op0, op1));
2380 : 0 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2381 : :
2382 : 0 : DONE;
2383 : 1 : })
2384 : :
2385 : : (define_expand "round<mode>2"
2386 : 1 : [(match_operand:VHF_32_64 0 "register_operand")
2387 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2388 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2389 : 1 : && ix86_partial_vec_fp_math
2390 : 1 : && !flag_trapping_math"
2391 : 1 : {
2392 : 4 : rtx op1 = gen_reg_rtx (V8HFmode);
2393 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2394 : :
2395 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2396 : 2 : emit_insn (gen_roundv8hf2 (op0, op1));
2397 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2398 : :
2399 : 2 : DONE;
2400 : 1 : })
2401 : :
2402 : : (define_expand "lround<mode><mmxintvecmodelower>2"
2403 : 1 : [(match_operand:<mmxintvecmode> 0 "register_operand")
2404 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")]
2405 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2406 : 1 : && ix86_partial_vec_fp_math
2407 : 1 : && !flag_trapping_math"
2408 : 1 : {
2409 : 0 : rtx op1 = gen_reg_rtx (V8HFmode);
2410 : 0 : rtx op0 = gen_reg_rtx (V8HFmode);
2411 : :
2412 : 0 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2413 : 0 : emit_insn (gen_lroundv8hfv8hi2 (op0, op1));
2414 : 0 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2415 : :
2416 : 0 : DONE;
2417 : 1 : })
2418 : :
2419 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2420 : 1 : ;;
2421 : 1 : ;; Parallel half-precision floating point logical operations
2422 : 1 : ;;
2423 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2424 : 1 :
2425 : 1 : (define_insn "*mmx_andnot<mode>3"
2426 : : [(set (match_operand:VHF_32_64 0 "register_operand" "=x,x")
2427 : : (and:VHF_32_64
2428 : : (not:VHF_32_64
2429 : : (match_operand:VHF_32_64 1 "register_operand" "0,x"))
2430 : : (match_operand:VHF_32_64 2 "register_operand" "x,x")))]
2431 : 1 : "TARGET_SSE"
2432 : : "@
2433 : : andnps\t{%2, %0|%0, %2}
2434 : 1 : vandnps\t{%2, %1, %0|%0, %1, %2}"
2435 : 2 : [(set_attr "isa" "noavx,avx")
2436 : 2 : (set_attr "type" "sselog")
2437 : 2 : (set_attr "prefix" "orig,vex")
2438 : 0 : (set_attr "mode" "V4SF")])
2439 : 1 :
2440 : 1 : (define_insn "<code><mode>3"
2441 : 1 : [(set (match_operand:VHF_32_64 0 "register_operand" "=x,x")
2442 : 1 : (any_logic:VHF_32_64
2443 : 1 : (match_operand:VHF_32_64 1 "register_operand" "%0,x")
2444 : 1 : (match_operand:VHF_32_64 2 "register_operand" " x,x")))]
2445 : 12 : "TARGET_SSE"
2446 : 1 : "@
2447 : 1 : <logic>ps\t{%2, %0|%0, %2}
2448 : : v<logic>ps\t{%2, %1, %0|%0, %1, %2}"
2449 : 47 : [(set_attr "isa" "noavx,avx")
2450 : 47 : (set_attr "type" "sselog,sselog")
2451 : 39 : (set_attr "prefix" "orig,vex")
2452 : : (set_attr "mode" "V4SF")])
2453 : :
2454 : : (define_expand "copysign<mode>3"
2455 : : [(set (match_dup 4)
2456 : : (and:VHF_32_64
2457 : : (not:VHF_32_64 (match_dup 3))
2458 : : (match_operand:VHF_32_64 1 "register_operand")))
2459 : : (set (match_dup 5)
2460 : : (and:VHF_32_64 (match_dup 3)
2461 : : (match_operand:VHF_32_64 2 "register_operand")))
2462 : : (set (match_operand:VHF_32_64 0 "register_operand")
2463 : : (ior:VHF_32_64 (match_dup 4) (match_dup 5)))]
2464 : : "TARGET_SSE"
2465 : 3 : {
2466 : 1 : operands[3] = ix86_build_signbit_mask (<MODE>mode, true, false);
2467 : :
2468 : 3 : operands[4] = gen_reg_rtx (<MODE>mode);
2469 : 3 : operands[5] = gen_reg_rtx (<MODE>mode);
2470 : : })
2471 : :
2472 : : (define_expand "xorsign<mode>3"
2473 : 3 : [(set (match_dup 4)
2474 : 3 : (and:VHF_32_64 (match_dup 3)
2475 : 3 : (match_operand:VHF_32_64 2 "register_operand")))
2476 : 3 : (set (match_operand:VHF_32_64 0 "register_operand")
2477 : 3 : (xor:VHF_32_64 (match_dup 4)
2478 : 3 : (match_operand:VHF_32_64 1 "register_operand")))]
2479 : 3 : "TARGET_SSE"
2480 : 5 : {
2481 : 7 : operands[3] = ix86_build_signbit_mask (<MODE>mode, true, false);
2482 : 3 :
2483 : 2 : operands[4] = gen_reg_rtx (<MODE>mode);
2484 : 3 : })
2485 : :
2486 : 3 : (define_expand "signbit<mode>2"
2487 : 2 : [(set (match_operand:<mmxintvecmode> 0 "register_operand")
2488 : 2 : (lshiftrt:<mmxintvecmode>
2489 : 2 : (subreg:<mmxintvecmode>
2490 : 2 : (match_operand:VHF_32_64 1 "register_operand") 0)
2491 : 3 : (match_dup 2)))]
2492 : 2 : "TARGET_SSE2"
2493 : 2 : {
2494 : 2 : operands[1] = force_reg (<MODE>mode, operands[1]);
2495 : 3 : operands[2] = GEN_INT (GET_MODE_UNIT_BITSIZE (<MODE>mode)-1);
2496 : 2 : })
2497 : :
2498 : 2 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2499 : 3 : ;;
2500 : 3 : ;; Parallel half-precision FMA multiply/accumulate instructions.
2501 : 3 : ;;
2502 : 2 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2503 : 0 :
2504 : 0 : (define_expand "fma<mode>4"
2505 : : [(set (match_operand:VHF_32_64 0 "register_operand")
2506 : 4 : (fma:VHF_32_64
2507 : 2 : (match_operand:VHF_32_64 1 "nonimmediate_operand")
2508 : 2 : (match_operand:VHF_32_64 2 "nonimmediate_operand")
2509 : : (match_operand:VHF_32_64 3 "nonimmediate_operand")))]
2510 : 3 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2511 : 5 : {
2512 : 0 : rtx op3 = gen_reg_rtx (V8HFmode);
2513 : 4 : rtx op2 = gen_reg_rtx (V8HFmode);
2514 : 4 : rtx op1 = gen_reg_rtx (V8HFmode);
2515 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2516 : 3 :
2517 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op3, operands[3]));
2518 : 3 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2519 : 4 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2520 : 1 :
2521 : 2 : emit_insn (gen_fmav8hf4 (op0, op1, op2, op3));
2522 : 0 :
2523 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2524 : 2 : DONE;
2525 : 2 : })
2526 : 1 :
2527 : 1 : (define_expand "fms<mode>4"
2528 : 0 : [(set (match_operand:VHF_32_64 0 "register_operand")
2529 : 1 : (fma:VHF_32_64
2530 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")
2531 : 1 : (match_operand:VHF_32_64 2 "nonimmediate_operand")
2532 : : (neg:VHF_32_64
2533 : : (match_operand:VHF_32_64 3 "nonimmediate_operand"))))]
2534 : : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2535 : 2 : {
2536 : 4 : rtx op3 = gen_reg_rtx (V8HFmode);
2537 : 2 : rtx op2 = gen_reg_rtx (V8HFmode);
2538 : 2 : rtx op1 = gen_reg_rtx (V8HFmode);
2539 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2540 : :
2541 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op3, operands[3]));
2542 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2543 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2544 : :
2545 : 2 : emit_insn (gen_fmsv8hf4 (op0, op1, op2, op3));
2546 : :
2547 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2548 : 2 : DONE;
2549 : 2 : })
2550 : :
2551 : : (define_expand "fnma<mode>4"
2552 : : [(set (match_operand:VHF_32_64 0 "register_operand")
2553 : : (fma:VHF_32_64
2554 : 2 : (neg:VHF_32_64
2555 : 2 : (match_operand:VHF_32_64 1 "nonimmediate_operand"))
2556 : 2 : (match_operand:VHF_32_64 2 "nonimmediate_operand")
2557 : 2 : (match_operand:VHF_32_64 3 "nonimmediate_operand")))]
2558 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2559 : 4 : {
2560 : 6 : rtx op3 = gen_reg_rtx (V8HFmode);
2561 : 4 : rtx op2 = gen_reg_rtx (V8HFmode);
2562 : 2 : rtx op1 = gen_reg_rtx (V8HFmode);
2563 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2564 : :
2565 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op3, operands[3]));
2566 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2567 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2568 : :
2569 : 2 : emit_insn (gen_fnmav8hf4 (op0, op1, op2, op3));
2570 : :
2571 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2572 : 2 : DONE;
2573 : : })
2574 : 2 :
2575 : : (define_expand "fnms<mode>4"
2576 : : [(set (match_operand:VHF_32_64 0 "register_operand" "=v,v,x")
2577 : : (fma:VHF_32_64
2578 : : (neg:VHF_32_64
2579 : 2 : (match_operand:VHF_32_64 1 "nonimmediate_operand"))
2580 : 2 : (match_operand:VHF_32_64 2 "nonimmediate_operand")
2581 : 2 : (neg:VHF_32_64
2582 : 2 : (match_operand:VHF_32_64 3 "nonimmediate_operand"))))]
2583 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2584 : 4 : {
2585 : 6 : rtx op3 = gen_reg_rtx (V8HFmode);
2586 : 4 : rtx op2 = gen_reg_rtx (V8HFmode);
2587 : 2 : rtx op1 = gen_reg_rtx (V8HFmode);
2588 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2589 : :
2590 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op3, operands[3]));
2591 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op2, operands[2]));
2592 : 2 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2593 : :
2594 : 2 : emit_insn (gen_fnmsv8hf4 (op0, op1, op2, op3));
2595 : :
2596 : 2 : emit_move_insn (operands[0], lowpart_subreg (<MODE>mode, op0, V8HFmode));
2597 : 2 : DONE;
2598 : 2 : })
2599 : :
2600 : : (define_expand "vec_fmaddsubv4hf4"
2601 : : [(match_operand:V4HF 0 "register_operand")
2602 : : (match_operand:V4HF 1 "nonimmediate_operand")
2603 : 2 : (match_operand:V4HF 2 "nonimmediate_operand")
2604 : 2 : (match_operand:V4HF 3 "nonimmediate_operand")]
2605 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2606 : 2 : && TARGET_MMX_WITH_SSE
2607 : 2 : && ix86_partial_vec_fp_math"
2608 : 3 : {
2609 : 4 : rtx op3 = gen_reg_rtx (V8HFmode);
2610 : 3 : rtx op2 = gen_reg_rtx (V8HFmode);
2611 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2612 : 1 : rtx op0 = gen_reg_rtx (V8HFmode);
2613 : :
2614 : 1 : emit_insn (gen_movq_v4hf_to_sse (op3, operands[3]));
2615 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2616 : 1 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2617 : :
2618 : 1 : emit_insn (gen_vec_fmaddsubv8hf4 (op0, op1, op2, op3));
2619 : :
2620 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2621 : 1 : DONE;
2622 : : })
2623 : :
2624 : 2 : (define_expand "vec_fmsubaddv4hf4"
2625 : : [(match_operand:V4HF 0 "register_operand")
2626 : : (match_operand:V4HF 1 "nonimmediate_operand")
2627 : : (match_operand:V4HF 2 "nonimmediate_operand")
2628 : : (match_operand:V4HF 3 "nonimmediate_operand")]
2629 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2630 : 2 : && ix86_partial_vec_fp_math
2631 : 2 : && TARGET_MMX_WITH_SSE"
2632 : 3 : {
2633 : 4 : rtx op3 = gen_reg_rtx (V8HFmode);
2634 : 1 : rtx op2 = gen_reg_rtx (V8HFmode);
2635 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2636 : 3 : rtx op0 = gen_reg_rtx (V8HFmode);
2637 : :
2638 : 1 : emit_insn (gen_movq_v4hf_to_sse (op3, operands[3]));
2639 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2640 : 1 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2641 : :
2642 : 1 : emit_insn (gen_vec_fmsubaddv8hf4 (op0, op1, op2, op3));
2643 : :
2644 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2645 : 1 : DONE;
2646 : : })
2647 : :
2648 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2649 : : ;;
2650 : 1 : ;; Parallel half-precision floating point complex type operations
2651 : 1 : ;;
2652 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2653 : 1 :
2654 : 1 : (define_expand "cmlav4hf4"
2655 : 1 : [(match_operand:V4HF 0 "register_operand")
2656 : 1 : (match_operand:V4HF 1 "vector_operand")
2657 : 1 : (match_operand:V4HF 2 "vector_operand")
2658 : : (match_operand:V4HF 3 "vector_operand")]
2659 : : "TARGET_AVX512FP16 && TARGET_AVX512VL"
2660 : 1 : {
2661 : 2 : rtx op3 = gen_reg_rtx (V8HFmode);
2662 : 1 : rtx op2 = gen_reg_rtx (V8HFmode);
2663 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2664 : 1 : rtx op0 = gen_reg_rtx (V8HFmode);
2665 : :
2666 : 1 : emit_insn (gen_movq_v4hf_to_sse (op3, operands[3]));
2667 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2668 : 1 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2669 : 1 :
2670 : 1 : emit_insn (gen_cmlav8hf4 (op0, op1, op2, op3));
2671 : :
2672 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2673 : 1 : DONE;
2674 : 1 : })
2675 : 1 :
2676 : 1 : (define_expand "cmla_conjv4hf4"
2677 : 1 : [(match_operand:V4HF 0 "register_operand")
2678 : 1 : (match_operand:V4HF 1 "vector_operand")
2679 : 1 : (match_operand:V4HF 2 "vector_operand")
2680 : 1 : (match_operand:V4HF 3 "vector_operand")]
2681 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL"
2682 : 1 : {
2683 : 2 : rtx op3 = gen_reg_rtx (V8HFmode);
2684 : 1 : rtx op2 = gen_reg_rtx (V8HFmode);
2685 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2686 : 1 : rtx op0 = gen_reg_rtx (V8HFmode);
2687 : :
2688 : 1 : emit_insn (gen_movq_v4hf_to_sse (op3, operands[3]));
2689 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2690 : 1 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2691 : :
2692 : 1 : emit_insn (gen_cmla_conjv8hf4 (op0, op1, op2, op3));
2693 : :
2694 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2695 : 1 : DONE;
2696 : : })
2697 : 1 :
2698 : : (define_expand "cmulv4hf3"
2699 : : [(match_operand:V4HF 0 "register_operand")
2700 : : (match_operand:V4HF 1 "vector_operand")
2701 : : (match_operand:V4HF 2 "vector_operand")]
2702 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL"
2703 : 1 : {
2704 : 3 : rtx op2 = gen_reg_rtx (V8HFmode);
2705 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2706 : 1 : rtx op0 = gen_reg_rtx (V8HFmode);
2707 : 1 :
2708 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2709 : 2 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2710 : :
2711 : 1 : emit_insn (gen_cmulv8hf3 (op0, op1, op2));
2712 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2713 : 1 : DONE;
2714 : : })
2715 : :
2716 : : (define_expand "cmul_conjv4hf3"
2717 : : [(match_operand:V4HF 0 "register_operand")
2718 : : (match_operand:V4HF 1 "vector_operand")
2719 : 1 : (match_operand:V4HF 2 "vector_operand")]
2720 : : "TARGET_AVX512FP16 && TARGET_AVX512VL"
2721 : 1 : {
2722 : 2 : rtx op2 = gen_reg_rtx (V8HFmode);
2723 : 1 : rtx op1 = gen_reg_rtx (V8HFmode);
2724 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2725 : 1 :
2726 : 1 : emit_insn (gen_movq_v4hf_to_sse (op2, operands[2]));
2727 : 1 : emit_insn (gen_movq_v4hf_to_sse (op1, operands[1]));
2728 : 1 :
2729 : 2 : emit_insn (gen_cmul_conjv8hf3 (op0, op1, op2));
2730 : 1 : emit_move_insn (operands[0], lowpart_subreg (V4HFmode, op0, V8HFmode));
2731 : 1 : DONE;
2732 : : })
2733 : :
2734 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2735 : : ;;
2736 : : ;; Parallel half-precision floating point conversion operations
2737 : : ;;
2738 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2739 : 1 :
2740 : 1 : (define_expand "fix<fixunssuffix>_trunc<mode><mmxintvecmodelower>2"
2741 : 1 : [(set (match_operand:<mmxintvecmode> 0 "register_operand")
2742 : 1 : (any_fix:<mmxintvecmode>
2743 : 1 : (match_operand:VHF_32_64 1 "nonimmediate_operand")))]
2744 : 1 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2745 : 4 : {
2746 : 8 : rtx op1 = gen_reg_rtx (V8HFmode);
2747 : 4 : rtx op0 = gen_reg_rtx (V8HImode);
2748 : :
2749 : 4 : emit_insn (gen_mov<mov_to_sse_suffix>_<mode>_to_sse (op1, operands[1]));
2750 : :
2751 : 4 : emit_insn (gen_fix<fixunssuffix>_truncv8hfv8hi2 (op0, op1));
2752 : 1 :
2753 : 4 : emit_move_insn (operands[0],
2754 : : lowpart_subreg (<mmxintvecmode>mode, op0, V8HImode));
2755 : 4 : DONE;
2756 : 1 : })
2757 : 1 :
2758 : 1 : (define_expand "fix<fixunssuffix>_truncv2hfv2si2"
2759 : 1 : [(set (match_operand:V2SI 0 "register_operand")
2760 : 1 : (any_fix:V2SI
2761 : : (match_operand:V2HF 1 "nonimmediate_operand")))]
2762 : : "TARGET_AVX512FP16 && TARGET_AVX512VL
2763 : : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
2764 : 2 : {
2765 : 4 : rtx op1 = gen_reg_rtx (V8HFmode);
2766 : 2 : rtx op0 = gen_reg_rtx (V4SImode);
2767 : :
2768 : 2 : emit_insn (gen_movd_v2hf_to_sse (op1, operands[1]));
2769 : :
2770 : 2 : emit_insn (gen_avx512fp16_fix<fixunssuffix>_truncv4si2 (op0, op1));
2771 : :
2772 : 2 : emit_move_insn (operands[0], lowpart_subreg (V2SImode, op0, V4SImode));
2773 : 2 : DONE;
2774 : 4 : })
2775 : :
2776 : : (define_expand "float<floatunssuffix><mmxintvecmodelower><mode>2"
2777 : 4 : [(set (match_operand:VHF_32_64 0 "register_operand")
2778 : 4 : (any_float:VHF_32_64
2779 : 4 : (match_operand:<mmxintvecmode> 1 "nonimmediate_operand")))]
2780 : 4 : "TARGET_AVX512FP16 && TARGET_AVX512VL && ix86_partial_vec_fp_math"
2781 : 8 : {
2782 : 4 : rtx op1 = gen_reg_rtx (V8HImode);
2783 : 4 : rtx op0 = gen_reg_rtx (V8HFmode);
2784 : :
2785 : 4 : rtx (*gen_movd_sse) (rtx, rtx)
2786 : : = gen_mov<mov_to_sse_suffix>_<mmxintvecmodelower>_to_sse;
2787 : 4 : emit_insn (gen_movd_sse (op1, operands[1]));
2788 : :
2789 : 4 : emit_insn (gen_float<floatunssuffix>v8hiv8hf2 (op0, op1));
2790 : :
2791 : 4 : emit_move_insn (operands[0],
2792 : 2 : lowpart_subreg (<MODE>mode, op0, V8HFmode));
2793 : 4 : DONE;
2794 : : })
2795 : 2 :
2796 : 2 : (define_expand "float<floatunssuffix>v2siv2hf2"
2797 : 2 : [(set (match_operand:V2HF 0 "register_operand")
2798 : 2 : (any_float:V2HF
2799 : 2 : (match_operand:V2SI 1 "nonimmediate_operand")))]
2800 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2801 : : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
2802 : 2 : {
2803 : 4 : rtx op1 = gen_reg_rtx (V4SImode);
2804 : 2 : rtx op0 = gen_reg_rtx (V8HFmode);
2805 : :
2806 : 2 : emit_insn (gen_movq_v2si_to_sse (op1, operands[1]));
2807 : :
2808 : 2 : emit_insn (gen_avx512fp16_float<floatunssuffix>v4siv4hf2 (op0, op1));
2809 : :
2810 : 2 : emit_move_insn (operands[0], lowpart_subreg (V2HFmode, op0, V8HFmode));
2811 : 2 : DONE;
2812 : 4 : })
2813 : :
2814 : : (define_expand "extendv2hfv2sf2"
2815 : 4 : [(set (match_operand:V2SF 0 "register_operand")
2816 : 4 : (float_extend:V2SF
2817 : 4 : (match_operand:V2HF 1 "nonimmediate_operand")))]
2818 : 4 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2819 : 4 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
2820 : 4 : {
2821 : 2 : rtx op1 = gen_reg_rtx (V8HFmode);
2822 : 1 : rtx op0 = gen_reg_rtx (V4SFmode);
2823 : :
2824 : 1 : emit_insn (gen_movd_v2hf_to_sse (op1, operands[1]));
2825 : :
2826 : 1 : emit_insn (gen_avx512fp16_float_extend_phv4sf2 (op0, op1));
2827 : :
2828 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2SFmode, op0, V4SFmode));
2829 : 1 : DONE;
2830 : 2 : })
2831 : :
2832 : : (define_expand "truncv2sfv2hf2"
2833 : 2 : [(set (match_operand:V2HF 0 "register_operand")
2834 : 2 : (float_truncate:V2HF
2835 : 2 : (match_operand:V2SF 1 "nonimmediate_operand")))]
2836 : 2 : "TARGET_AVX512FP16 && TARGET_AVX512VL
2837 : 2 : && TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math"
2838 : 2 : {
2839 : 2 : rtx op1 = gen_reg_rtx (V4SFmode);
2840 : 1 : rtx op0 = gen_reg_rtx (V8HFmode);
2841 : :
2842 : 1 : emit_insn (gen_movq_v2sf_to_sse (op1, operands[1]));
2843 : :
2844 : 1 : emit_insn (gen_avx512fp16_truncv4sfv4hf2 (op0, op1));
2845 : :
2846 : 1 : emit_move_insn (operands[0], lowpart_subreg (V2HFmode, op0, V8HFmode));
2847 : 1 : DONE;
2848 : 1 : })
2849 : :
2850 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2851 : 1 : ;;
2852 : 1 : ;; Parallel integral arithmetic
2853 : 1 : ;;
2854 : 1 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2855 : 1 :
2856 : 1 : (define_expand "neg<mode>2"
2857 : : [(set (match_operand:MMXMODEI 0 "register_operand")
2858 : : (minus:MMXMODEI
2859 : : (match_dup 2)
2860 : : (match_operand:MMXMODEI 1 "register_operand")))]
2861 : : "TARGET_MMX_WITH_SSE"
2862 : 134 : "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
2863 : :
2864 : : (define_expand "neg<mode>2"
2865 : 67 : [(set (match_operand:VI_32 0 "register_operand")
2866 : 68 : (minus:VI_32
2867 : 67 : (match_dup 2)
2868 : 67 : (match_operand:VI_32 1 "register_operand")))]
2869 : 68 : "TARGET_SSE2"
2870 : 72 : "operands[2] = force_reg (<MODE>mode, CONST0_RTX (<MODE>mode));")
2871 : 1 :
2872 : 67 : (define_insn "negv2qi2"
2873 : 3 : [(set (match_operand:V2QI 0 "register_operand" "=?Q,&Yw")
2874 : 3 : (neg:V2QI
2875 : 1 : (match_operand:V2QI 1 "register_operand" "0,Yw")))
2876 : 67 : (clobber (reg:CC FLAGS_REG))]
2877 : 87 : "!TARGET_PARTIAL_REG_STALL || optimize_size || TARGET_SSE2"
2878 : 73 : "#"
2879 : 10 : [(set_attr "isa" "*,sse2")
2880 : 12 : (set_attr "type" "multi")
2881 : : (set_attr "mode" "QI,TI")
2882 : : (set (attr "enabled")
2883 : 67 : (cond [(and (eq_attr "alternative" "0")
2884 : 2 : (and (match_test "TARGET_PARTIAL_REG_STALL")
2885 : 23884 : (not (match_test "optimize_function_for_size_p (cfun)"))))
2886 : 23951 : (symbol_ref "false")
2887 : 68 : ]
2888 : 1795 : (const_string "*")))])
2889 : 1795 :
2890 : 68 : (define_split
2891 : 69 : [(set (match_operand:V2QI 0 "general_reg_operand")
2892 : 67 : (neg:V2QI
2893 : 1 : (match_operand:V2QI 1 "general_reg_operand")))
2894 : 7 : (clobber (reg:CC FLAGS_REG))]
2895 : 11 : "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
2896 : 6 : && reload_completed"
2897 : 11 : [(parallel
2898 : 11 : [(set (strict_low_part (match_dup 0))
2899 : 5 : (neg:QI (match_dup 1)))
2900 : 6 : (clobber (reg:CC FLAGS_REG))])
2901 : 5 : (parallel
2902 : : [(set (zero_extract:HI (match_dup 2) (const_int 8) (const_int 8))
2903 : : (subreg:HI
2904 : : (neg:QI
2905 : : (subreg:QI
2906 : : (zero_extract:HI (match_dup 3)
2907 : : (const_int 8)
2908 : : (const_int 8)) 0)) 0))
2909 : : (clobber (reg:CC FLAGS_REG))])]
2910 : 5 : {
2911 : 5 : operands[3] = lowpart_subreg (HImode, operands[1], V2QImode);
2912 : 5 : operands[2] = lowpart_subreg (HImode, operands[0], V2QImode);
2913 : 5 : operands[1] = lowpart_subreg (QImode, operands[1], V2QImode);
2914 : 5 : operands[0] = lowpart_subreg (QImode, operands[0], V2QImode);
2915 : : })
2916 : :
2917 : : (define_split
2918 : 5 : [(set (match_operand:V2QI 0 "sse_reg_operand")
2919 : 5 : (neg:V2QI
2920 : 5 : (match_operand:V2QI 1 "sse_reg_operand")))
2921 : 5 : (clobber (reg:CC FLAGS_REG))]
2922 : 5 : "TARGET_SSE2 && reload_completed"
2923 : 10 : [(set (match_dup 0) (match_dup 2))
2924 : 5 : (set (match_dup 0)
2925 : 5 : (minus:V16QI (match_dup 0) (match_dup 1)))]
2926 : 3423 : {
2927 : 3418 : operands[2] = CONST0_RTX (V16QImode);
2928 : 0 : operands[1] = lowpart_subreg (V16QImode, operands[1], V2QImode);
2929 : 84 : operands[0] = lowpart_subreg (V16QImode, operands[0], V2QImode);
2930 : 84 : })
2931 : :
2932 : : (define_expand "mmx_<insn><mode>3"
2933 : 5 : [(set (match_operand:MMXMODEI8 0 "register_operand")
2934 : 0 : (plusminus:MMXMODEI8
2935 : 0 : (match_operand:MMXMODEI8 1 "register_mmxmem_operand")
2936 : 0 : (match_operand:MMXMODEI8 2 "register_mmxmem_operand")))]
2937 : 0 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
2938 : 249 : "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
2939 : 0 :
2940 : : (define_expand "<insn><mode>3"
2941 : 0 : [(set (match_operand:MMXMODEI 0 "register_operand")
2942 : 249 : (plusminus:MMXMODEI
2943 : 249 : (match_operand:MMXMODEI 1 "register_operand")
2944 : 249 : (match_operand:MMXMODEI 2 "register_operand")))]
2945 : 0 : "TARGET_MMX_WITH_SSE")
2946 : 0 :
2947 : 0 : (define_insn "*mmx_<insn><mode>3"
2948 : 249 : [(set (match_operand:MMXMODEI8 0 "register_operand" "=y,x,<Yv_Yw>")
2949 : 5 : (plusminus:MMXMODEI8
2950 : 5 : (match_operand:MMXMODEI8 1 "register_mmxmem_operand"
2951 : 5 : "<comm>0,0,<Yv_Yw>")
2952 : 249 : (match_operand:MMXMODEI8 2 "register_mmxmem_operand"
2953 : 249 : "ym,x,<Yv_Yw>")))]
2954 : 3855 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
2955 : 40175 : && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
2956 : 33 : "@
2957 : 33 : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
2958 : 33 : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
2959 : 72965 : vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
2960 : 72029 : [(set_attr "isa" "*,sse2_noavx,avx")
2961 : 72029 : (set_attr "mmx_isa" "native,*,*")
2962 : 33 : (set_attr "type" "mmxadd,sseadd,sseadd")
2963 : 720 : (set_attr "mode" "DI,TI,TI")])
2964 : 216 :
2965 : 0 : (define_insn "<insn><mode>3"
2966 : 216 : [(set (match_operand:VI_32 0 "register_operand" "=x,Yw")
2967 : 216 : (plusminus:VI_32
2968 : 216 : (match_operand:VI_32 1 "register_operand" "<comm>0,Yw")
2969 : 216 : (match_operand:VI_32 2 "register_operand" "x,Yw")))]
2970 : 4423 : "TARGET_SSE2"
2971 : 19 : "@
2972 : : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
2973 : : vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
2974 : 6105 : [(set_attr "isa" "noavx,avx")
2975 : 4954 : (set_attr "type" "sseadd")
2976 : 6105 : (set_attr "mode" "TI")])
2977 : 1170 :
2978 : : (define_insn "<insn>v2qi3"
2979 : : [(set (match_operand:V2QI 0 "register_operand" "=?Q,x,Yw")
2980 : : (plusminus:V2QI
2981 : : (match_operand:V2QI 1 "register_operand" "<comm>0,0,Yw")
2982 : : (match_operand:V2QI 2 "register_operand" "Q,x,Yw")))
2983 : 1367 : (clobber (reg:CC FLAGS_REG))]
2984 : 662 : "!TARGET_PARTIAL_REG_STALL || optimize_size || TARGET_SSE2"
2985 : : "#"
2986 : 354 : [(set_attr "isa" "*,sse2_noavx,avx")
2987 : 1721 : (set_attr "type" "multi,sseadd,sseadd")
2988 : : (set_attr "mode" "QI,TI,TI")
2989 : : (set (attr "enabled")
2990 : : (cond [(and (eq_attr "alternative" "0")
2991 : 7659834 : (and (match_test "TARGET_PARTIAL_REG_STALL")
2992 : 39 : (not (match_test "optimize_function_for_size_p (cfun)"))))
2993 : 39 : (symbol_ref "false")
2994 : 29 : ]
2995 : 123543 : (const_string "*")))])
2996 : 36 :
2997 : 28 : (define_split
2998 : : [(set (match_operand:V2QI 0 "general_reg_operand")
2999 : 115 : (plusminus:V2QI
3000 : 11 : (match_operand:V2QI 1 "general_reg_operand")
3001 : 11 : (match_operand:V2QI 2 "general_reg_operand")))
3002 : : (clobber (reg:CC FLAGS_REG))]
3003 : 129 : "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
3004 : 157 : && reload_completed"
3005 : 157 : [(parallel
3006 : 837 : [(set (strict_low_part (match_dup 0))
3007 : 5632 : (plusminus:QI (match_dup 1) (match_dup 2)))
3008 : 56 : (clobber (reg:CC FLAGS_REG))])
3009 : 837 : (parallel
3010 : : [(set (zero_extract:HI (match_dup 3) (const_int 8) (const_int 8))
3011 : 5576 : (subreg:HI
3012 : : (plusminus:QI
3013 : : (subreg:QI
3014 : : (zero_extract:HI (match_dup 4)
3015 : : (const_int 8)
3016 : : (const_int 8)) 0)
3017 : : (subreg:QI
3018 : : (zero_extract:HI (match_dup 5)
3019 : 972 : (const_int 8)
3020 : : (const_int 8)) 0)) 0))
3021 : : (clobber (reg:CC FLAGS_REG))])]
3022 : 148 : {
3023 : 1120 : operands[5] = lowpart_subreg (HImode, operands[2], V2QImode);
3024 : 148 : operands[4] = lowpart_subreg (HImode, operands[1], V2QImode);
3025 : 148 : operands[3] = lowpart_subreg (HImode, operands[0], V2QImode);
3026 : 148 : operands[2] = lowpart_subreg (QImode, operands[2], V2QImode);
3027 : 148 : operands[1] = lowpart_subreg (QImode, operands[1], V2QImode);
3028 : 148 : operands[0] = lowpart_subreg (QImode, operands[0], V2QImode);
3029 : : })
3030 : :
3031 : : (define_split
3032 : 277 : [(set (match_operand:V2QI 0 "sse_reg_operand")
3033 : 148 : (plusminus:V2QI
3034 : 277 : (match_operand:V2QI 1 "sse_reg_operand")
3035 : 277 : (match_operand:V2QI 2 "sse_reg_operand")))
3036 : 277 : (clobber (reg:CC FLAGS_REG))]
3037 : 333 : "TARGET_SSE2 && reload_completed"
3038 : 1058 : [(set (match_dup 0)
3039 : 333 : (plusminus:V16QI (match_dup 1) (match_dup 2)))]
3040 : 333 : {
3041 : 2733640 : operands[2] = lowpart_subreg (V16QImode, operands[2], V2QImode);
3042 : 1385260 : operands[1] = lowpart_subreg (V16QImode, operands[1], V2QImode);
3043 : 1348436 : operands[0] = lowpart_subreg (V16QImode, operands[0], V2QImode);
3044 : 1348399 : })
3045 : 70 :
3046 : 70 : (define_expand "mmx_<insn><mode>3"
3047 : 77 : [(set (match_operand:MMXMODE12 0 "register_operand")
3048 : 77 : (sat_plusminus:MMXMODE12
3049 : 145 : (match_operand:MMXMODE12 1 "register_mmxmem_operand")
3050 : 56 : (match_operand:MMXMODE12 2 "register_mmxmem_operand")))]
3051 : 56 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3052 : 148 : "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
3053 : 56 :
3054 : : (define_insn "*mmx_<insn><mode>3"
3055 : 276 : [(set (match_operand:MMXMODE12 0 "register_operand" "=y,x,Yw")
3056 : 276 : (sat_plusminus:MMXMODE12
3057 : 56 : (match_operand:MMXMODE12 1 "register_mmxmem_operand" "<comm>0,0,Yw")
3058 : 56 : (match_operand:MMXMODE12 2 "register_mmxmem_operand" "ym,x,Yw")))]
3059 : 344 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3060 : 1222 : && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
3061 : 0 : "@
3062 : 276 : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
3063 : : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
3064 : 563 : vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3065 : 581 : [(set_attr "isa" "*,sse2_noavx,avx")
3066 : 276 : (set_attr "mmx_isa" "native,*,*")
3067 : 276 : (set_attr "type" "mmxadd,sseadd,sseadd")
3068 : 312 : (set_attr "mode" "DI,TI,TI")])
3069 : 36 :
3070 : 36 : (define_insn "*<insn><mode>3"
3071 : 0 : [(set (match_operand:VI_16_32 0 "register_operand" "=x,Yw")
3072 : 0 : (sat_plusminus:VI_16_32
3073 : 273 : (match_operand:VI_16_32 1 "register_operand" "<comm>0,Yw")
3074 : 184 : (match_operand:VI_16_32 2 "register_operand" "x,Yw")))]
3075 : 200 : "TARGET_SSE2"
3076 : 148 : "@
3077 : 273 : p<plusminus_mnemonic><mmxvecsize>\t{%2, %0|%0, %2}
3078 : 273 : vp<plusminus_mnemonic><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3079 : 424 : [(set_attr "isa" "noavx,avx")
3080 : 424 : (set_attr "type" "sseadd")
3081 : 273 : (set_attr "mode" "TI")])
3082 : 348 :
3083 : 428 : (define_insn "mulv2si3"
3084 : 263 : [(set (match_operand:V2SI 0 "register_operand" "=Yr,*x,v")
3085 : 7778 : (mult:V2SI
3086 : 7589 : (match_operand:V2SI 1 "register_operand" "%0,0,v")
3087 : 881 : (match_operand:V2SI 2 "register_operand" "Yr,*x,v")))]
3088 : 862 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
3089 : 0 : "@
3090 : 137517 : pmulld\t{%2, %0|%0, %2}
3091 : 136902 : pmulld\t{%2, %0|%0, %2}
3092 : 136883 : vpmulld\t{%2, %1, %0|%0, %1, %2}"
3093 : 5619 : [(set_attr "isa" "noavx,noavx,avx")
3094 : 7489 : (set_attr "type" "sseimul")
3095 : 110 : (set_attr "prefix_extra" "1")
3096 : 110 : (set_attr "prefix" "orig,orig,vex")
3097 : 343 : (set_attr "btver2_decode" "vector")
3098 : : (set_attr "mode" "TI")])
3099 : 0 :
3100 : 0 : (define_expand "mmx_mulv4hi3"
3101 : : [(set (match_operand:V4HI 0 "register_operand")
3102 : : (mult:V4HI (match_operand:V4HI 1 "register_mmxmem_operand")
3103 : : (match_operand:V4HI 2 "register_mmxmem_operand")))]
3104 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3105 : 33 : "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
3106 : :
3107 : : (define_expand "mulv4hi3"
3108 : 33 : [(set (match_operand:V4HI 0 "register_operand")
3109 : 33 : (mult:V4HI (match_operand:V4HI 1 "register_operand")
3110 : 33 : (match_operand:V4HI 2 "register_operand")))]
3111 : 33 : "TARGET_MMX_WITH_SSE")
3112 : 33 :
3113 : 33 : (define_insn "*mmx_mulv4hi3"
3114 : : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
3115 : 33 : (mult:V4HI (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw")
3116 : : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")))]
3117 : 2467 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3118 : 2467 : && ix86_binary_operator_ok (MULT, V4HImode, operands)"
3119 : 2588 : "@
3120 : 33 : pmullw\t{%2, %0|%0, %2}
3121 : 33 : pmullw\t{%2, %0|%0, %2}
3122 : 4796 : vpmullw\t{%2, %1, %0|%0, %1, %2}"
3123 : 4796 : [(set_attr "isa" "*,sse2_noavx,avx")
3124 : 4796 : (set_attr "mmx_isa" "native,*,*")
3125 : : (set_attr "type" "mmxmul,ssemul,ssemul")
3126 : 371 : (set_attr "mode" "DI,TI,TI")])
3127 : :
3128 : : (define_insn "mulv2hi3"
3129 : : [(set (match_operand:V2HI 0 "register_operand" "=x,Yw")
3130 : 371 : (mult:V2HI (match_operand:V2HI 1 "register_operand" "%0,Yw")
3131 : : (match_operand:V2HI 2 "register_operand" "x,Yw")))]
3132 : 3352 : "TARGET_SSE2"
3133 : : "@
3134 : : pmullw\t{%2, %0|%0, %2}
3135 : : vpmullw\t{%2, %1, %0|%0, %1, %2}"
3136 : : [(set_attr "isa" "noavx,avx")
3137 : : (set_attr "type" "ssemul")
3138 : 257 : (set_attr "mode" "TI")])
3139 : :
3140 : 232131 : (define_expand "mulv8qi3"
3141 : 232131 : [(set (match_operand:V8QI 0 "register_operand")
3142 : 232388 : (mult:V8QI (match_operand:V8QI 1 "register_operand")
3143 : 257 : (match_operand:V8QI 2 "register_operand")))]
3144 : 102959 : "TARGET_MMX_WITH_SSE"
3145 : 102959 : {
3146 : 257 : ix86_expand_vecop_qihi_partial (MULT, operands[0], operands[1], operands[2]);
3147 : 30778 : DONE;
3148 : 30778 : })
3149 : 30521 :
3150 : : (define_expand "mulv4qi3"
3151 : 30504 : [(set (match_operand:V4QI 0 "register_operand")
3152 : : (mult:V4QI (match_operand:V4QI 1 "register_operand")
3153 : 14280 : (match_operand:V4QI 2 "register_operand")))]
3154 : 14280 : "TARGET_SSE2"
3155 : 694 : {
3156 : 694 : ix86_expand_vecop_qihi_partial (MULT, operands[0], operands[1], operands[2]);
3157 : 694 : DONE;
3158 : : })
3159 : :
3160 : : (define_expand "mmx_smulv4hi3_highpart"
3161 : : [(set (match_operand:V4HI 0 "register_operand")
3162 : : (truncate:V4HI
3163 : : (lshiftrt:V4SI
3164 : : (mult:V4SI
3165 : : (sign_extend:V4SI
3166 : : (match_operand:V4HI 1 "register_mmxmem_operand"))
3167 : : (sign_extend:V4SI
3168 : : (match_operand:V4HI 2 "register_mmxmem_operand")))
3169 : 694 : (const_int 16))))]
3170 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3171 : 34 : "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
3172 : :
3173 : 694 : (define_insn "*mmx_smulv4hi3_highpart"
3174 : 694 : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
3175 : 728 : (truncate:V4HI
3176 : 728 : (lshiftrt:V4SI
3177 : 728 : (mult:V4SI
3178 : 728 : (sign_extend:V4SI
3179 : 694 : (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw"))
3180 : : (sign_extend:V4SI
3181 : 34 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")))
3182 : : (const_int 16))))]
3183 : 145 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3184 : 145 : && ix86_binary_operator_ok (MULT, V4HImode, operands)"
3185 : 34 : "@
3186 : 34 : pmulhw\t{%2, %0|%0, %2}
3187 : 34 : pmulhw\t{%2, %0|%0, %2}
3188 : 35 : vpmulhw\t{%2, %1, %0|%0, %1, %2}"
3189 : 35 : [(set_attr "isa" "*,sse2_noavx,avx")
3190 : 34 : (set_attr "mmx_isa" "native,*,*")
3191 : 34 : (set_attr "type" "mmxmul,ssemul,ssemul")
3192 : 34 : (set_attr "mode" "DI,TI,TI")])
3193 : :
3194 : : (define_expand "mmx_umulv4hi3_highpart"
3195 : : [(set (match_operand:V4HI 0 "register_operand")
3196 : : (truncate:V4HI
3197 : 22 : (lshiftrt:V4SI
3198 : : (mult:V4SI
3199 : : (zero_extend:V4SI
3200 : : (match_operand:V4HI 1 "register_mmxmem_operand"))
3201 : 22 : (zero_extend:V4SI
3202 : 22 : (match_operand:V4HI 2 "register_mmxmem_operand")))
3203 : 22 : (const_int 16))))]
3204 : 22 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3205 : 22 : && (TARGET_SSE || TARGET_3DNOW_A)"
3206 : 22 : "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
3207 : 22 :
3208 : : (define_insn "*mmx_umulv4hi3_highpart"
3209 : 22 : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
3210 : 22 : (truncate:V4HI
3211 : 22 : (lshiftrt:V4SI
3212 : 22 : (mult:V4SI
3213 : 22 : (zero_extend:V4SI
3214 : 22 : (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw"))
3215 : : (zero_extend:V4SI
3216 : 22 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")))
3217 : : (const_int 16))))]
3218 : 5 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3219 : 121 : && (TARGET_SSE || TARGET_3DNOW_A)
3220 : 121 : && ix86_binary_operator_ok (MULT, V4HImode, operands)"
3221 : 0 : "@
3222 : : pmulhuw\t{%2, %0|%0, %2}
3223 : : pmulhuw\t{%2, %0|%0, %2}
3224 : 1 : vpmulhuw\t{%2, %1, %0|%0, %1, %2}"
3225 : 23 : [(set_attr "isa" "*,sse2_noavx,avx")
3226 : 22 : (set_attr "mmx_isa" "native,*,*")
3227 : 22 : (set_attr "type" "mmxmul,ssemul,ssemul")
3228 : : (set_attr "mode" "DI,TI,TI")])
3229 : :
3230 : : (define_expand "<s>mulv4hi3_highpart"
3231 : : [(set (match_operand:V4HI 0 "register_operand")
3232 : 1 : (truncate:V4HI
3233 : : (lshiftrt:V4SI
3234 : : (mult:V4SI
3235 : : (any_extend:V4SI
3236 : 1 : (match_operand:V4HI 1 "register_operand"))
3237 : : (any_extend:V4SI
3238 : : (match_operand:V4HI 2 "register_operand")))
3239 : : (const_int 16))))]
3240 : : "TARGET_MMX_WITH_SSE")
3241 : :
3242 : : (define_insn "<s>mulv2hi3_highpart"
3243 : : [(set (match_operand:V2HI 0 "register_operand" "=x,Yw")
3244 : : (truncate:V2HI
3245 : : (lshiftrt:V2SI
3246 : : (mult:V2SI
3247 : : (any_extend:V2SI
3248 : : (match_operand:V2HI 1 "register_operand" "%0,Yw"))
3249 : 25 : (any_extend:V2SI
3250 : : (match_operand:V2HI 2 "register_operand" "x,Yw")))
3251 : : (const_int 16))))]
3252 : 2 : "TARGET_SSE2"
3253 : 25 : "@
3254 : : pmulh<u>w\t{%2, %0|%0, %2}
3255 : : vpmulh<u>w\t{%2, %1, %0|%0, %1, %2}"
3256 : : [(set_attr "isa" "noavx,avx")
3257 : : (set_attr "type" "ssemul")
3258 : : (set_attr "mode" "TI")])
3259 : :
3260 : 2196 : (define_expand "mmx_pmaddwd"
3261 : 2196 : [(set (match_operand:V2SI 0 "register_operand")
3262 : : (plus:V2SI
3263 : 121 : (mult:V2SI
3264 : 242 : (sign_extend:V2SI
3265 : 1297 : (vec_select:V2HI
3266 : 1331 : (match_operand:V4HI 1 "register_mmxmem_operand")
3267 : : (parallel [(const_int 0) (const_int 2)])))
3268 : 46 : (sign_extend:V2SI
3269 : 46 : (vec_select:V2HI
3270 : 34 : (match_operand:V4HI 2 "register_mmxmem_operand")
3271 : 80 : (parallel [(const_int 0) (const_int 2)]))))
3272 : 80 : (mult:V2SI
3273 : 80 : (sign_extend:V2SI
3274 : 34 : (vec_select:V2HI (match_dup 1)
3275 : 80 : (parallel [(const_int 1) (const_int 3)])))
3276 : 80 : (sign_extend:V2SI
3277 : 46 : (vec_select:V2HI (match_dup 2)
3278 : : (parallel [(const_int 1) (const_int 3)]))))))]
3279 : 46 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3280 : 80 : "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
3281 : 46 :
3282 : 46 : (define_insn "*mmx_pmaddwd"
3283 : 34 : [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yw")
3284 : 80 : (plus:V2SI
3285 : 80 : (mult:V2SI
3286 : 80 : (sign_extend:V2SI
3287 : 34 : (vec_select:V2HI
3288 : 80 : (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw")
3289 : 46 : (parallel [(const_int 0) (const_int 2)])))
3290 : 80 : (sign_extend:V2SI
3291 : : (vec_select:V2HI
3292 : 46 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")
3293 : 46 : (parallel [(const_int 0) (const_int 2)]))))
3294 : 46 : (mult:V2SI
3295 : : (sign_extend:V2SI
3296 : 46 : (vec_select:V2HI (match_dup 1)
3297 : 46 : (parallel [(const_int 1) (const_int 3)])))
3298 : 46 : (sign_extend:V2SI
3299 : 46 : (vec_select:V2HI (match_dup 2)
3300 : 92 : (parallel [(const_int 1) (const_int 3)]))))))]
3301 : 108 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3302 : 108 : && ix86_binary_operator_ok (MULT, V4HImode, operands)"
3303 : 0 : "@
3304 : 46 : pmaddwd\t{%2, %0|%0, %2}
3305 : : pmaddwd\t{%2, %0|%0, %2}
3306 : 46 : vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
3307 : 46 : [(set_attr "isa" "*,sse2_noavx,avx")
3308 : 46 : (set_attr "mmx_isa" "native,*,*")
3309 : 92 : (set_attr "type" "mmxmul,sseiadd,sseiadd")
3310 : 1134935 : (set_attr "mode" "DI,TI,TI")])
3311 : 1134935 :
3312 : 1134935 : (define_expand "mmx_pmulhrwv4hi3"
3313 : 1134935 : [(set (match_operand:V4HI 0 "register_operand")
3314 : 1134935 : (truncate:V4HI
3315 : 1134935 : (lshiftrt:V4SI
3316 : 1134935 : (plus:V4SI
3317 : : (mult:V4SI
3318 : 835718 : (sign_extend:V4SI
3319 : 835718 : (match_operand:V4HI 1 "nonimmediate_operand"))
3320 : 835718 : (sign_extend:V4SI
3321 : 835718 : (match_operand:V4HI 2 "nonimmediate_operand")))
3322 : 835752 : (const_vector:V4SI [(const_int 32768) (const_int 32768)
3323 : 34 : (const_int 32768) (const_int 32768)]))
3324 : 771009 : (const_int 16))))]
3325 : 770975 : "TARGET_3DNOW"
3326 : 770989 : "ix86_fixup_binary_operands_no_copy (MULT, V4HImode, operands);")
3327 : 770975 :
3328 : 770975 : (define_insn "*mmx_pmulhrwv4hi3"
3329 : 771003 : [(set (match_operand:V4HI 0 "register_operand" "=y")
3330 : 770989 : (truncate:V4HI
3331 : 770989 : (lshiftrt:V4SI
3332 : 770989 : (plus:V4SI
3333 : 771003 : (mult:V4SI
3334 : 770989 : (sign_extend:V4SI
3335 : 770989 : (match_operand:V4HI 1 "nonimmediate_operand" "%0"))
3336 : 770989 : (sign_extend:V4SI
3337 : 770989 : (match_operand:V4HI 2 "nonimmediate_operand" "ym")))
3338 : 14 : (const_vector:V4SI [(const_int 32768) (const_int 32768)
3339 : 5070 : (const_int 32768) (const_int 32768)]))
3340 : 5056 : (const_int 16))))]
3341 : 5102 : "TARGET_3DNOW && ix86_binary_operator_ok (MULT, V4HImode, operands)"
3342 : 0 : "pmulhrw\t{%2, %0|%0, %2}"
3343 : : [(set_attr "type" "mmxmul")
3344 : : (set_attr "prefix_extra" "1")
3345 : 864 : (set_attr "mode" "DI")])
3346 : 864 :
3347 : 864 : (define_expand "sse2_umulv1siv1di3"
3348 : : [(set (match_operand:V1DI 0 "register_operand")
3349 : 864 : (mult:V1DI
3350 : 864 : (zero_extend:V1DI
3351 : : (vec_select:V1SI
3352 : 878 : (match_operand:V2SI 1 "register_mmxmem_operand")
3353 : 878 : (parallel [(const_int 0)])))
3354 : 878 : (zero_extend:V1DI
3355 : : (vec_select:V1SI
3356 : 864 : (match_operand:V2SI 2 "register_mmxmem_operand")
3357 : 864 : (parallel [(const_int 0)])))))]
3358 : 864 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE2"
3359 : 888 : "ix86_fixup_binary_operands_no_copy (MULT, V2SImode, operands);")
3360 : 864 :
3361 : : (define_insn "*sse2_umulv1siv1di3"
3362 : 256 : [(set (match_operand:V1DI 0 "register_operand" "=y,x,Yv")
3363 : 268 : (mult:V1DI
3364 : 174 : (zero_extend:V1DI
3365 : 268 : (vec_select:V1SI
3366 : 24 : (match_operand:V2SI 1 "register_mmxmem_operand" "%0,0,Yv")
3367 : 24 : (parallel [(const_int 0)])))
3368 : 12 : (zero_extend:V1DI
3369 : 12 : (vec_select:V1SI
3370 : : (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv")
3371 : : (parallel [(const_int 0)])))))]
3372 : 37 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3373 : 37 : && TARGET_SSE2
3374 : 37 : && ix86_binary_operator_ok (MULT, V2SImode, operands)"
3375 : 1 : "@
3376 : : pmuludq\t{%2, %0|%0, %2}
3377 : : pmuludq\t{%2, %0|%0, %2}
3378 : : vpmuludq\t{%2, %1, %0|%0, %1, %2}"
3379 : : [(set_attr "isa" "*,sse2_noavx,avx")
3380 : : (set_attr "mmx_isa" "native,*,*")
3381 : : (set_attr "type" "mmxmul,ssemul,ssemul")
3382 : 53902 : (set_attr "mode" "DI,TI,TI")])
3383 : 53914 :
3384 : 12 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3385 : 53212 : ;;
3386 : 53200 : ;; Parallel integral shifts
3387 : : ;;
3388 : 5979 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3389 : :
3390 : 955 : (define_insn "<code><mode>3"
3391 : 933 : [(set (match_operand:MMXMODE14 0 "register_operand" "=Yr,*x,Yv")
3392 : : (smaxmin:MMXMODE14
3393 : : (match_operand:MMXMODE14 1 "register_operand" "%0,0,Yv")
3394 : 22 : (match_operand:MMXMODE14 2 "register_operand" "Yr,*x,Yv")))]
3395 : 22 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
3396 : 22 : "@
3397 : 22 : p<maxmin_int><mmxvecsize>\t{%2, %0|%0, %2}
3398 : 22 : p<maxmin_int><mmxvecsize>\t{%2, %0|%0, %2}
3399 : 233 : vp<maxmin_int><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3400 : 129 : [(set_attr "isa" "noavx,noavx,avx")
3401 : : (set_attr "type" "sseiadd")
3402 : : (set_attr "prefix_extra" "1")
3403 : : (set_attr "prefix" "orig,orig,vex")
3404 : : (set_attr "mode" "TI")])
3405 : :
3406 : : (define_expand "mmx_<code>v4hi3"
3407 : : [(set (match_operand:V4HI 0 "register_operand")
3408 : : (smaxmin:V4HI
3409 : : (match_operand:V4HI 1 "register_mmxmem_operand")
3410 : : (match_operand:V4HI 2 "register_mmxmem_operand")))]
3411 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3412 : : && (TARGET_SSE || TARGET_3DNOW_A)"
3413 : 22 : "ix86_fixup_binary_operands_no_copy (<CODE>, V4HImode, operands);")
3414 : :
3415 : : (define_insn "*mmx_<code>v4hi3"
3416 : 44 : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
3417 : 44 : (smaxmin:V4HI
3418 : 44 : (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw")
3419 : 44 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")))]
3420 : 163 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3421 : 255 : && (TARGET_SSE || TARGET_3DNOW_A)
3422 : 315 : && ix86_binary_operator_ok (<CODE>, V4HImode, operands)"
3423 : 44 : "@
3424 : : p<maxmin_int>w\t{%2, %0|%0, %2}
3425 : : p<maxmin_int>w\t{%2, %0|%0, %2}
3426 : 50 : vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
3427 : 94 : [(set_attr "isa" "*,sse2_noavx,avx")
3428 : 44 : (set_attr "mmx_isa" "native,*,*")
3429 : 44 : (set_attr "type" "mmxadd,sseiadd,sseiadd")
3430 : : (set_attr "mode" "DI,TI,TI")])
3431 : :
3432 : : (define_expand "<code>v4hi3"
3433 : : [(set (match_operand:V4HI 0 "register_operand")
3434 : 33 : (smaxmin:V4HI
3435 : : (match_operand:V4HI 1 "register_operand")
3436 : : (match_operand:V4HI 2 "register_operand")))]
3437 : : "TARGET_MMX_WITH_SSE")
3438 : 33 :
3439 : 22 : (define_insn "<code><mode>3"
3440 : 22 : [(set (match_operand:VI1_16_32 0 "register_operand" "=Yr,*x,Yv")
3441 : 22 : (smaxmin:VI1_16_32
3442 : 22 : (match_operand:VI1_16_32 1 "register_operand" "%0,0,Yv")
3443 : 22 : (match_operand:VI1_16_32 2 "register_operand" "Yr,*x,Yv")))]
3444 : 72 : "TARGET_SSE4_1"
3445 : : "@
3446 : 11 : p<maxmin_int>b\t{%2, %0|%0, %2}
3447 : : p<maxmin_int>b\t{%2, %0|%0, %2}
3448 : 57 : vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
3449 : 2 : [(set_attr "isa" "noavx,noavx,avx")
3450 : 11 : (set_attr "type" "sseiadd")
3451 : : (set_attr "prefix_extra" "1")
3452 : : (set_attr "prefix" "orig,orig,vex")
3453 : : (set_attr "mode" "TI")])
3454 : :
3455 : : (define_insn "<code>v2hi3"
3456 : : [(set (match_operand:V2HI 0 "register_operand" "=x,Yw")
3457 : : (smaxmin:V2HI
3458 : 22 : (match_operand:V2HI 1 "register_operand" "%0,Yw")
3459 : : (match_operand:V2HI 2 "register_operand" "x,Yw")))]
3460 : 55 : "TARGET_SSE2"
3461 : : "@
3462 : 22 : p<maxmin_int>w\t{%2, %0|%0, %2}
3463 : 22 : vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
3464 : 22 : [(set_attr "isa" "noavx,avx")
3465 : 22 : (set_attr "type" "sseiadd")
3466 : 22 : (set_attr "mode" "TI")])
3467 : 22 :
3468 : 22 : (define_insn "<code><mode>3"
3469 : 64540 : [(set (match_operand:MMXMODE24 0 "register_operand" "=Yr,*x,Yv")
3470 : 64540 : (umaxmin:MMXMODE24
3471 : : (match_operand:MMXMODE24 1 "register_operand" "%0,0,Yv")
3472 : 0 : (match_operand:MMXMODE24 2 "register_operand" "Yr,*x,Yv")))]
3473 : 50 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
3474 : 5032863 : "@
3475 : 5032863 : p<maxmin_int><mmxvecsize>\t{%2, %0|%0, %2}
3476 : 5032863 : p<maxmin_int><mmxvecsize>\t{%2, %0|%0, %2}
3477 : 5033027 : vp<maxmin_int><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3478 : 12 : [(set_attr "isa" "noavx,noavx,avx")
3479 : 5032863 : (set_attr "type" "sseiadd")
3480 : 5032863 : (set_attr "prefix_extra" "1")
3481 : 5032863 : (set_attr "prefix" "orig,orig,vex")
3482 : 5032863 : (set_attr "mode" "TI")])
3483 : :
3484 : 2312081 : (define_expand "mmx_<code>v8qi3"
3485 : 2312081 : [(set (match_operand:V8QI 0 "register_operand")
3486 : 2312081 : (umaxmin:V8QI
3487 : 2312081 : (match_operand:V8QI 1 "register_mmxmem_operand")
3488 : 2312081 : (match_operand:V8QI 2 "register_mmxmem_operand")))]
3489 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3490 : 42129 : && (TARGET_SSE || TARGET_3DNOW_A)"
3491 : 42151 : "ix86_fixup_binary_operands_no_copy (<CODE>, V8QImode, operands);")
3492 : :
3493 : 42128 : (define_insn "*mmx_<code>v8qi3"
3494 : 42172 : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
3495 : 44 : (umaxmin:V8QI
3496 : 42172 : (match_operand:V8QI 1 "register_mmxmem_operand" "%0,0,Yw")
3497 : 44 : (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yw")))]
3498 : 54 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3499 : 210 : && (TARGET_SSE || TARGET_3DNOW_A)
3500 : 315 : && ix86_binary_operator_ok (<CODE>, V8QImode, operands)"
3501 : 69 : "@
3502 : : p<maxmin_int>b\t{%2, %0|%0, %2}
3503 : : p<maxmin_int>b\t{%2, %0|%0, %2}
3504 : 67 : vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
3505 : 111 : [(set_attr "isa" "*,sse2_noavx,avx")
3506 : 44 : (set_attr "mmx_isa" "native,*,*")
3507 : 44 : (set_attr "type" "mmxadd,sseiadd,sseiadd")
3508 : : (set_attr "mode" "DI,TI,TI")])
3509 : :
3510 : : (define_expand "<code>v8qi3"
3511 : : [(set (match_operand:V8QI 0 "register_operand")
3512 : 23 : (umaxmin:V8QI
3513 : : (match_operand:V8QI 1 "register_operand")
3514 : : (match_operand:V8QI 2 "register_operand")))]
3515 : : "TARGET_MMX_WITH_SSE")
3516 : 23 :
3517 : 22 : (define_insn "<code><mode>3"
3518 : 22 : [(set (match_operand:VI1_16_32 0 "register_operand" "=x,Yw")
3519 : 22 : (umaxmin:VI1_16_32
3520 : 22 : (match_operand:VI1_16_32 1 "register_operand" "%0,Yw")
3521 : 22 : (match_operand:VI1_16_32 2 "register_operand" "x,Yw")))]
3522 : 89 : "TARGET_SSE2"
3523 : : "@
3524 : 3 : p<maxmin_int>b\t{%2, %0|%0, %2}
3525 : : vp<maxmin_int>b\t{%2, %1, %0|%0, %1, %2}"
3526 : 10 : [(set_attr "isa" "noavx,avx")
3527 : 8 : (set_attr "type" "sseiadd")
3528 : 3 : (set_attr "mode" "TI")])
3529 : :
3530 : : (define_insn "<code>v2hi3"
3531 : : [(set (match_operand:V2HI 0 "register_operand" "=Yr,*x,Yv")
3532 : : (umaxmin:V2HI
3533 : : (match_operand:V2HI 1 "register_operand" "%0,0,Yv")
3534 : : (match_operand:V2HI 2 "register_operand" "Yr,*x,Yv")))]
3535 : 2 : "TARGET_SSE4_1"
3536 : 16 : "@
3537 : : p<maxmin_int>w\t{%2, %0|%0, %2}
3538 : : p<maxmin_int>w\t{%2, %0|%0, %2}
3539 : 16 : vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
3540 : : [(set_attr "isa" "noavx,noavx,avx")
3541 : : (set_attr "type" "sseiadd")
3542 : : (set_attr "prefix_extra" "1")
3543 : : (set_attr "prefix" "orig,orig,vex")
3544 : 187957 : (set_attr "mode" "TI")])
3545 : 187957 :
3546 : 117794 : (define_insn "ssse3_abs<mode>2"
3547 : 0 : [(set (match_operand:MMXMODEI 0 "register_operand" "=y,Yv")
3548 : 0 : (abs:MMXMODEI
3549 : 24 : (match_operand:MMXMODEI 1 "register_mmxmem_operand" "ym,Yv")))]
3550 : 38 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSSE3"
3551 : 2918204 : "@
3552 : 2918145 : pabs<mmxvecsize>\t{%1, %0|%0, %1}
3553 : : %vpabs<mmxvecsize>\t{%1, %0|%0, %1}"
3554 : 166 : [(set_attr "mmx_isa" "native,*")
3555 : 166 : (set_attr "type" "sselog1")
3556 : 175 : (set_attr "prefix_rep" "0")
3557 : 712903 : (set_attr "prefix_extra" "1")
3558 : 713024 : (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
3559 : 17 : (set_attr "mode" "DI,TI")])
3560 : :
3561 : : (define_expand "abs<mode>2"
3562 : 2104200 : [(set (match_operand:MMXMODEI 0 "register_operand")
3563 : 2104200 : (abs:MMXMODEI
3564 : 2104200 : (match_operand:MMXMODEI 1 "register_operand")))]
3565 : : "TARGET_SSSE3 && TARGET_MMX_WITH_SSE")
3566 : 43 :
3567 : : (define_insn "abs<mode>2"
3568 : 688045 : [(set (match_operand:VI_16_32 0 "register_operand" "=Yv")
3569 : 688045 : (abs:VI_16_32
3570 : 688088 : (match_operand:VI_16_32 1 "register_operand" "Yv")))]
3571 : 1 : "TARGET_SSSE3"
3572 : 21 : "%vpabs<mmxvecsize>\t{%1, %0|%0, %1}"
3573 : : [(set_attr "type" "sselog1")
3574 : 1379 : (set_attr "prefix_rep" "0")
3575 : 1379 : (set_attr "prefix_extra" "1")
3576 : 1395 : (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
3577 : 8 : (set_attr "mode" "TI")])
3578 : 202 :
3579 : 18 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3580 : 648 : ;;
3581 : 2074673 : ;; Parallel integral shifts
3582 : 842 : ;;
3583 : 648 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3584 : :
3585 : 2074137 : (define_insn "mmx_ashr<mode>3"
3586 : 112 : [(set (match_operand:MMXMODE24 0 "register_operand" "=y,x,<Yv_Yw>")
3587 : 2074025 : (ashiftrt:MMXMODE24
3588 : 2074025 : (match_operand:MMXMODE24 1 "register_operand" "0,0,<Yv_Yw>")
3589 : 2074025 : (match_operand:DI 2 "nonmemory_operand" "yN,xN,<Yv_Yw>N")))]
3590 : 2074533 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3591 : : "@
3592 : 1248032 : psra<mmxvecsize>\t{%2, %0|%0, %2}
3593 : 1248032 : psra<mmxvecsize>\t{%2, %0|%0, %2}
3594 : 1249343 : vpsra<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3595 : 1211 : [(set_attr "isa" "*,sse2_noavx,avx")
3596 : 1211 : (set_attr "mmx_isa" "native,*,*")
3597 : 1248032 : (set_attr "type" "mmxshft,sseishft,sseishft")
3598 : 1248032 : (set (attr "length_immediate")
3599 : : (if_then_else (match_operand 2 "const_int_operand")
3600 : 1226564 : (const_string "1")
3601 : 1226564 : (const_string "0")))
3602 : 1226890 : (set_attr "mode" "DI,TI,TI")])
3603 : 1226564 :
3604 : 1226564 : (define_expand "ashr<mode>3"
3605 : 1226564 : [(set (match_operand:MMXMODE24 0 "register_operand")
3606 : 1226890 : (ashiftrt:MMXMODE24
3607 : 1226564 : (match_operand:MMXMODE24 1 "register_operand")
3608 : 1226564 : (match_operand:DI 2 "nonmemory_operand")))]
3609 : 1226564 : "TARGET_MMX_WITH_SSE")
3610 : 1226564 :
3611 : 1226564 : (define_insn "mmx_<insn><mode>3"
3612 : 1226564 : [(set (match_operand:MMXMODE248 0 "register_operand" "=y,x,<Yv_Yw>")
3613 : 1209910 : (any_lshift:MMXMODE248
3614 : 242918 : (match_operand:MMXMODE248 1 "register_operand" "0,0,<Yv_Yw>")
3615 : 1226579 : (match_operand:DI 2 "nonmemory_operand" "yN,xN,<Yv_Yw>N")))]
3616 : 1902 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3617 : : "@
3618 : 318 : p<vshift><mmxvecsize>\t{%2, %0|%0, %2}
3619 : : p<vshift><mmxvecsize>\t{%2, %0|%0, %2}
3620 : 20772 : vp<vshift><mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3621 : 20772 : [(set_attr "isa" "*,sse2_noavx,avx")
3622 : 20772 : (set_attr "mmx_isa" "native,*,*")
3623 : : (set_attr "type" "mmxshft,sseishft,sseishft")
3624 : : (set (attr "length_immediate")
3625 : : (if_then_else (match_operand 2 "const_int_operand")
3626 : 511 : (const_string "1")
3627 : : (const_string "0")))
3628 : : (set_attr "mode" "DI,TI,TI")])
3629 : :
3630 : 511 : (define_expand "<insn><mode>3"
3631 : : [(set (match_operand:MMXMODE24 0 "register_operand")
3632 : : (any_lshift:MMXMODE24
3633 : : (match_operand:MMXMODE24 1 "register_operand")
3634 : : (match_operand:DI 2 "nonmemory_operand")))]
3635 : : "TARGET_MMX_WITH_SSE")
3636 : :
3637 : : (define_insn "mmx_<insn>v1si3"
3638 : 2 : [(set (match_operand:V1SI 0 "register_operand" "=x,Yw")
3639 : : (any_lshift:V1SI
3640 : : (match_operand:V1SI 1 "register_operand" "0,Yw")
3641 : : (match_operand:DI 2 "nonmemory_operand" "xN,YwN")))]
3642 : 1532 : "TARGET_SSE2"
3643 : 2 : "@
3644 : 2 : p<vshift>d\t{%2, %0|%0, %2}
3645 : 2 : vp<vshift>d\t{%2, %1, %0|%0, %1, %2}"
3646 : 94 : [(set_attr "isa" "noavx,avx")
3647 : 94 : (set_attr "type" "sseishft")
3648 : 94 : (set (attr "length_immediate")
3649 : : (if_then_else (match_operand 2 "const_int_operand")
3650 : : (const_string "1")
3651 : : (const_string "0")))
3652 : : (set_attr "mode" "TI")])
3653 : :
3654 : : (define_insn "<insn>v2hi3"
3655 : : [(set (match_operand:V2HI 0 "register_operand" "=x,Yw")
3656 : : (any_shift:V2HI
3657 : : (match_operand:V2HI 1 "register_operand" "0,Yw")
3658 : : (match_operand:DI 2 "nonmemory_operand" "xN,YwN")))]
3659 : 96 : "TARGET_SSE2"
3660 : : "@
3661 : : p<vshift>w\t{%2, %0|%0, %2}
3662 : : vp<vshift>w\t{%2, %1, %0|%0, %1, %2}"
3663 : 126 : [(set_attr "isa" "noavx,avx")
3664 : 126 : (set_attr "type" "sseishft")
3665 : 126 : (set (attr "length_immediate")
3666 : 126 : (if_then_else (match_operand 2 "const_int_operand")
3667 : : (const_string "1")
3668 : : (const_string "0")))
3669 : : (set_attr "mode" "TI")])
3670 : :
3671 : : (define_expand "<insn>v8qi3"
3672 : : [(set (match_operand:V8QI 0 "register_operand")
3673 : : (any_shift:V8QI (match_operand:V8QI 1 "register_operand")
3674 : : (match_operand:DI 2 "nonmemory_operand")))]
3675 : : "TARGET_MMX_WITH_SSE"
3676 : 8 : {
3677 : 2 : ix86_expand_vecop_qihi_partial (<CODE>, operands[0],
3678 : : operands[1], operands[2]);
3679 : 8 : DONE;
3680 : : })
3681 : :
3682 : : (define_expand "<insn>v4qi3"
3683 : : [(set (match_operand:V4QI 0 "register_operand")
3684 : : (any_shift:V4QI (match_operand:V4QI 1 "register_operand")
3685 : : (match_operand:DI 2 "nonmemory_operand")))]
3686 : : "TARGET_SSE2"
3687 : 24 : {
3688 : 24 : ix86_expand_vecop_qihi_partial (<CODE>, operands[0],
3689 : : operands[1], operands[2]);
3690 : 24 : DONE;
3691 : : })
3692 : :
3693 : : (define_insn_and_split "<insn>v2qi3"
3694 : : [(set (match_operand:V2QI 0 "register_operand" "=Q")
3695 : : (any_shift:V2QI
3696 : : (match_operand:V2QI 1 "register_operand" "0")
3697 : : (match_operand:QI 2 "nonmemory_operand" "cI")))
3698 : : (clobber (reg:CC FLAGS_REG))]
3699 : 198 : "!TARGET_PARTIAL_REG_STALL || optimize_size"
3700 : 6 : "#"
3701 : 86 : "(!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun))
3702 : 198 : && reload_completed"
3703 : 39 : [(parallel
3704 : 39 : [(set (zero_extract:HI (match_dup 3) (const_int 8) (const_int 8))
3705 : 8 : (subreg:HI
3706 : 139300 : (any_shift:QI
3707 : 139300 : (subreg:QI
3708 : 62647 : (zero_extract:HI (match_dup 4)
3709 : 24 : (const_int 8)
3710 : 35596 : (const_int 8)) 0)
3711 : 83 : (match_dup 2)) 0))
3712 : 329 : (clobber (reg:CC FLAGS_REG))])
3713 : 358 : (parallel
3714 : 357 : [(set (strict_low_part (match_dup 0))
3715 : 689 : (any_shift:QI (match_dup 1) (match_dup 2)))
3716 : 23 : (clobber (reg:CC FLAGS_REG))])]
3717 : 22 : {
3718 : 39 : operands[4] = lowpart_subreg (HImode, operands[1], V2QImode);
3719 : 39 : operands[3] = lowpart_subreg (HImode, operands[0], V2QImode);
3720 : 39 : operands[1] = lowpart_subreg (QImode, operands[1], V2QImode);
3721 : 40 : operands[0] = lowpart_subreg (QImode, operands[0], V2QImode);
3722 : 22 : }
3723 : 1 : [(set_attr "type" "multi")
3724 : : (set_attr "mode" "QI")])
3725 : 39 :
3726 : 39 : (define_expand "v<insn>v8qi3"
3727 : 39 : [(set (match_operand:V8QI 0 "register_operand")
3728 : 39 : (any_shift:V8QI
3729 : 39 : (match_operand:V8QI 1 "register_operand")
3730 : 39 : (match_operand:V8QI 2 "register_operand")))]
3731 : 39 : "TARGET_AVX512BW && TARGET_AVX512VL && TARGET_MMX_WITH_SSE"
3732 : 48 : {
3733 : 48 : ix86_expand_vecop_qihi_partial (<CODE>, operands[0],
3734 : 39 : operands[1], operands[2]);
3735 : 48 : DONE;
3736 : : })
3737 : :
3738 : : (define_expand "v<insn>v4qi3"
3739 : : [(set (match_operand:V4QI 0 "register_operand")
3740 : : (any_shift:V4QI
3741 : : (match_operand:V4QI 1 "register_operand")
3742 : : (match_operand:V4QI 2 "register_operand")))]
3743 : : "TARGET_AVX512BW && TARGET_AVX512VL"
3744 : 4 : {
3745 : 4 : ix86_expand_vecop_qihi_partial (<CODE>, operands[0],
3746 : : operands[1], operands[2]);
3747 : 4 : DONE;
3748 : : })
3749 : :
3750 : : (define_expand "vec_shl_<mode>"
3751 : : [(set (match_operand:V248FI 0 "register_operand")
3752 : 39 : (ashift:V1DI
3753 : : (match_operand:V248FI 1 "nonimmediate_operand")
3754 : : (match_operand:DI 2 "nonmemory_operand")))]
3755 : : "TARGET_MMX_WITH_SSE"
3756 : 7 : {
3757 : 21 : rtx op0 = gen_reg_rtx (V1DImode);
3758 : 7 : rtx op1 = force_reg (<MODE>mode, operands[1]);
3759 : :
3760 : 46 : emit_insn (gen_mmx_ashlv1di3
3761 : 46 : (op0, gen_lowpart (V1DImode, op1), operands[2]));
3762 : 14 : emit_move_insn (operands[0], gen_lowpart (<MODE>mode, op0));
3763 : 7 : DONE;
3764 : 7 : })
3765 : 7 :
3766 : 7 : (define_expand "vec_shl_<mode>"
3767 : 7 : [(set (match_operand:V24FI_32 0 "register_operand")
3768 : 38 : (ashift:V1SI
3769 : 3 : (match_operand:V24FI_32 1 "nonimmediate_operand")
3770 : 38 : (match_operand:DI 2 "nonmemory_operand")))]
3771 : 41 : "TARGET_SSE2"
3772 : 3 : {
3773 : 52 : rtx op0 = gen_reg_rtx (V1SImode);
3774 : 7 : rtx op1 = force_reg (<MODE>mode, operands[1]);
3775 : 44 :
3776 : 42 : emit_insn (gen_mmx_ashlv1si3
3777 : 7 : (op0, gen_lowpart (V1SImode, op1), operands[2]));
3778 : 42 : emit_move_insn (operands[0], gen_lowpart (<MODE>mode, op0));
3779 : 7 : DONE;
3780 : : })
3781 : :
3782 : : (define_expand "vec_shr_<mode>"
3783 : : [(set (match_operand:V248FI 0 "register_operand")
3784 : : (lshiftrt:V1DI
3785 : 8 : (match_operand:V248FI 1 "nonimmediate_operand")
3786 : : (match_operand:DI 2 "nonmemory_operand")))]
3787 : : "TARGET_MMX_WITH_SSE"
3788 : 929 : {
3789 : 1866 : rtx op0 = gen_reg_rtx (V1DImode);
3790 : 937 : rtx op1 = force_reg (<MODE>mode, operands[1]);
3791 : 8 :
3792 : 929 : emit_insn (gen_mmx_lshrv1di3
3793 : 929 : (op0, gen_lowpart (V1DImode, op1), operands[2]));
3794 : 929 : emit_move_insn (operands[0], gen_lowpart (<MODE>mode, op0));
3795 : 937 : DONE;
3796 : : })
3797 : :
3798 : : (define_expand "vec_shr_<mode>"
3799 : : [(set (match_operand:V24FI_32 0 "register_operand")
3800 : : (lshiftrt:V1SI
3801 : 507 : (match_operand:V24FI_32 1 "nonimmediate_operand")
3802 : : (match_operand:DI 2 "nonmemory_operand")))]
3803 : : "TARGET_SSE2"
3804 : 228 : {
3805 : 963 : rtx op0 = gen_reg_rtx (V1SImode);
3806 : 735 : rtx op1 = force_reg (<MODE>mode, operands[1]);
3807 : 507 :
3808 : 228 : emit_insn (gen_mmx_lshrv1si3
3809 : 228 : (op0, gen_lowpart (V1SImode, op1), operands[2]));
3810 : 228 : emit_move_insn (operands[0], gen_lowpart (<MODE>mode, op0));
3811 : 735 : DONE;
3812 : : })
3813 : :
3814 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3815 : : ;;
3816 : : ;; Parallel integral comparisons
3817 : 426 : ;;
3818 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3819 : :
3820 : : (define_expand "mmx_eq<mode>3"
3821 : 426 : [(set (match_operand:MMXMODEI 0 "register_operand")
3822 : 426 : (eq:MMXMODEI
3823 : 426 : (match_operand:MMXMODEI 1 "register_mmxmem_operand")
3824 : 426 : (match_operand:MMXMODEI 2 "register_mmxmem_operand")))]
3825 : 426 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3826 : 530 : "ix86_fixup_binary_operands_no_copy (EQ, <MODE>mode, operands);")
3827 : 426 :
3828 : : (define_insn "*mmx_eq<mode>3"
3829 : 104 : [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,x")
3830 : 104 : (eq:MMXMODEI
3831 : 104 : (match_operand:MMXMODEI 1 "register_mmxmem_operand" "%0,0,x")
3832 : 104 : (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,x")))]
3833 : 2700 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
3834 : 3613 : && ix86_binary_operator_ok (EQ, <MODE>mode, operands)"
3835 : 5935 : "@
3836 : 104 : pcmpeq<mmxvecsize>\t{%2, %0|%0, %2}
3837 : 263 : pcmpeq<mmxvecsize>\t{%2, %0|%0, %2}
3838 : 2083 : vpcmpeq<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3839 : 2083 : [(set_attr "isa" "*,sse2_noavx,avx")
3840 : 2654 : (set_attr "mmx_isa" "native,*,*")
3841 : 104 : (set_attr "type" "mmxcmp,ssecmp,ssecmp")
3842 : 1974 : (set_attr "mode" "DI,TI,TI")])
3843 : 1870 :
3844 : 2064 : (define_insn "*eq<mode>3"
3845 : : [(set (match_operand:VI_16_32 0 "register_operand" "=x,x")
3846 : : (eq:VI_16_32
3847 : 85 : (match_operand:VI_16_32 1 "register_operand" "%0,x")
3848 : : (match_operand:VI_16_32 2 "register_operand" "x,x")))]
3849 : 175 : "TARGET_SSE2"
3850 : : "@
3851 : 68 : pcmpeq<mmxvecsize>\t{%2, %0|%0, %2}
3852 : 68 : vpcmpeq<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3853 : 1060 : [(set_attr "isa" "noavx,avx")
3854 : 1128 : (set_attr "type" "ssecmp")
3855 : 1128 : (set_attr "mode" "TI")])
3856 : 85 :
3857 : 68 : (define_insn "mmx_gt<mode>3"
3858 : 17 : [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,x")
3859 : 17 : (gt:MMXMODEI
3860 : : (match_operand:MMXMODEI 1 "register_operand" "0,0,x")
3861 : : (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,x")))]
3862 : 3500 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
3863 : 6003 : "@
3864 : : pcmpgt<mmxvecsize>\t{%2, %0|%0, %2}
3865 : : pcmpgt<mmxvecsize>\t{%2, %0|%0, %2}
3866 : 3192 : vpcmpgt<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3867 : 3192 : [(set_attr "isa" "*,sse2_noavx,avx")
3868 : 3192 : (set_attr "mmx_isa" "native,*,*")
3869 : 245738 : (set_attr "type" "mmxcmp,ssecmp,ssecmp")
3870 : 247114 : (set_attr "mode" "DI,TI,TI")])
3871 : 1376 :
3872 : 1376 : (define_insn "*gt<mode>3"
3873 : 245738 : [(set (match_operand:VI_16_32 0 "register_operand" "=x,x")
3874 : 245738 : (gt:VI_16_32
3875 : 245738 : (match_operand:VI_16_32 1 "register_operand" "0,x")
3876 : : (match_operand:VI_16_32 2 "register_operand" "x,x")))]
3877 : 95 : "TARGET_SSE2"
3878 : 9566 : "@
3879 : 9566 : pcmpgt<mmxvecsize>\t{%2, %0|%0, %2}
3880 : : vpcmpgt<mmxvecsize>\t{%2, %1, %0|%0, %1, %2}"
3881 : 9549 : [(set_attr "isa" "noavx,avx")
3882 : 1062 : (set_attr "type" "ssecmp")
3883 : 1062 : (set_attr "mode" "TI")])
3884 : 46 :
3885 : 46 : (define_insn "*xop_maskcmp<mode>3"
3886 : 92 : [(set (match_operand:MMXMODEI 0 "register_operand" "=x")
3887 : 2081609 : (match_operator:MMXMODEI 1 "ix86_comparison_int_operator"
3888 : : [(match_operand:MMXMODEI 2 "register_operand" "x")
3889 : : (match_operand:MMXMODEI 3 "register_operand" "x")]))]
3890 : 0 : "TARGET_XOP"
3891 : 2081609 : "vpcom%Y1<mmxvecsize>\t{%3, %2, %0|%0, %2, %3}"
3892 : 2081609 : [(set_attr "type" "sse4arg")
3893 : 2081609 : (set_attr "mode" "TI")])
3894 : 2100490 :
3895 : 2100490 : (define_insn "*xop_maskcmp<mode>3"
3896 : 18881 : [(set (match_operand:VI_16_32 0 "register_operand" "=x")
3897 : 803967 : (match_operator:VI_16_32 1 "ix86_comparison_int_operator"
3898 : 803967 : [(match_operand:VI_16_32 2 "register_operand" "x")
3899 : 803967 : (match_operand:VI_16_32 3 "register_operand" "x")]))]
3900 : 0 : "TARGET_XOP"
3901 : : "vpcom%Y1<mmxvecsize>\t{%3, %2, %0|%0, %2, %3}"
3902 : : [(set_attr "type" "sse4arg")
3903 : 245738 : (set_attr "mode" "TI")])
3904 : 245738 :
3905 : 247726 : (define_insn "*xop_maskcmp_uns<mode>3"
3906 : 1988 : [(set (match_operand:MMXMODEI 0 "register_operand" "=x")
3907 : : (match_operator:MMXMODEI 1 "ix86_comparison_uns_operator"
3908 : : [(match_operand:MMXMODEI 2 "register_operand" "x")
3909 : 136080 : (match_operand:MMXMODEI 3 "register_operand" "x")]))]
3910 : 0 : "TARGET_XOP"
3911 : 136080 : "vpcom%Y1u<mmxvecsize>\t{%3, %2, %0|%0, %2, %3}"
3912 : : [(set_attr "type" "sse4arg")
3913 : 49 : (set_attr "mode" "TI")])
3914 : 2535691 :
3915 : 6930 : (define_insn "*xop_maskcmp_uns<mode>3"
3916 : 6881 : [(set (match_operand:VI_16_32 0 "register_operand" "=x")
3917 : 2528807 : (match_operator:VI_16_32 1 "ix86_comparison_uns_operator"
3918 : 2528807 : [(match_operand:VI_16_32 2 "register_operand" "x")
3919 : 46 : (match_operand:VI_16_32 3 "register_operand" "x")]))]
3920 : 2528807 : "TARGET_XOP"
3921 : : "vpcom%Y1u<mmxvecsize>\t{%3, %2, %0|%0, %2, %3}"
3922 : 2081609 : [(set_attr "type" "sse4arg")
3923 : 2081609 : (set_attr "mode" "TI")])
3924 : 2082752 :
3925 : 1143 : (define_expand "vec_cmp<mode><mode>"
3926 : 1143 : [(set (match_operand:MMXMODEI 0 "register_operand")
3927 : 2081609 : (match_operator:MMXMODEI 1 ""
3928 : 2081609 : [(match_operand:MMXMODEI 2 "register_operand")
3929 : 2081609 : (match_operand:MMXMODEI 3 "register_operand")]))]
3930 : : "TARGET_MMX_WITH_SSE"
3931 : 404 : {
3932 : 17 : bool ok = ix86_expand_int_vec_cmp (operands);
3933 : 404 : gcc_assert (ok);
3934 : 21262667 : DONE;
3935 : : })
3936 : 2518584 :
3937 : 2518584 : (define_expand "vec_cmp<mode><mode>"
3938 : 23780847 : [(set (match_operand:VI_16_32 0 "register_operand")
3939 : 23780847 : (match_operator:VI_16_32 1 ""
3940 : 23780847 : [(match_operand:VI_16_32 2 "register_operand")
3941 : 2518584 : (match_operand:VI_16_32 3 "register_operand")]))]
3942 : 21262263 : "TARGET_SSE2"
3943 : 21265256 : {
3944 : 3047 : bool ok = ix86_expand_int_vec_cmp (operands);
3945 : 2993 : gcc_assert (ok);
3946 : 21262317 : DONE;
3947 : : })
3948 : 196055 :
3949 : 196055 : (define_expand "vec_cmpu<mode><mode>"
3950 : 196055 : [(set (match_operand:MMXMODEI 0 "register_operand")
3951 : 196055 : (match_operator:MMXMODEI 1 ""
3952 : : [(match_operand:MMXMODEI 2 "register_operand")
3953 : 0 : (match_operand:MMXMODEI 3 "register_operand")]))]
3954 : 0 : "TARGET_MMX_WITH_SSE"
3955 : 108 : {
3956 : 216 : bool ok = ix86_expand_int_vec_cmp (operands);
3957 : 108 : gcc_assert (ok);
3958 : 501 : DONE;
3959 : : })
3960 : :
3961 : : (define_expand "vec_cmpu<mode><mode>"
3962 : : [(set (match_operand:VI_16_32 0 "register_operand")
3963 : 393 : (match_operator:VI_16_32 1 ""
3964 : 393 : [(match_operand:VI_16_32 2 "register_operand")
3965 : 393 : (match_operand:VI_16_32 3 "register_operand")]))]
3966 : 393 : "TARGET_SSE2"
3967 : 462 : {
3968 : 531 : bool ok = ix86_expand_int_vec_cmp (operands);
3969 : 69 : gcc_assert (ok);
3970 : 539 : DONE;
3971 : : })
3972 : :
3973 : : (define_expand "vcond<MMXMODE124:mode><MMXMODEI:mode>"
3974 : : [(set (match_operand:MMXMODE124 0 "register_operand")
3975 : 77 : (if_then_else:MMXMODE124
3976 : 77 : (match_operator 3 ""
3977 : 77 : [(match_operand:MMXMODEI 4 "register_operand")
3978 : 77 : (match_operand:MMXMODEI 5 "register_operand")])
3979 : 77 : (match_operand:MMXMODE124 1)
3980 : 77 : (match_operand:MMXMODE124 2)))]
3981 : 77 : "TARGET_MMX_WITH_SSE
3982 : 195 : && (GET_MODE_NUNITS (<MMXMODE124:MODE>mode)
3983 : : == GET_MODE_NUNITS (<MMXMODEI:MODE>mode))"
3984 : 357 : {
3985 : 714 : bool ok = ix86_expand_int_vcond (operands);
3986 : 357 : gcc_assert (ok);
3987 : 357 : DONE;
3988 : 118 : })
3989 : 118 :
3990 : 118 : (define_expand "vcond<mode><mode>"
3991 : 118 : [(set (match_operand:VI_16_32 0 "register_operand")
3992 : 118 : (if_then_else:VI_16_32
3993 : 118 : (match_operator 3 ""
3994 : 190 : [(match_operand:VI_16_32 4 "register_operand")
3995 : : (match_operand:VI_16_32 5 "register_operand")])
3996 : : (match_operand:VI_16_32 1)
3997 : : (match_operand:VI_16_32 2)))]
3998 : : "TARGET_SSE2"
3999 : 83 : {
4000 : 30 : bool ok = ix86_expand_int_vcond (operands);
4001 : 53 : gcc_assert (ok);
4002 : 95 : DONE;
4003 : 72 : })
4004 : 72 :
4005 : 72 : (define_expand "vcondu<MMXMODE124:mode><MMXMODEI:mode>"
4006 : 30 : [(set (match_operand:MMXMODE124 0 "register_operand")
4007 : 42 : (if_then_else:MMXMODE124
4008 : 42 : (match_operator 3 ""
4009 : 42 : [(match_operand:MMXMODEI 4 "register_operand")
4010 : 42 : (match_operand:MMXMODEI 5 "register_operand")])
4011 : : (match_operand:MMXMODE124 1)
4012 : : (match_operand:MMXMODE124 2)))]
4013 : : "TARGET_MMX_WITH_SSE
4014 : : && (GET_MODE_NUNITS (<MMXMODE124:MODE>mode)
4015 : : == GET_MODE_NUNITS (<MMXMODEI:MODE>mode))"
4016 : 63 : {
4017 : 126 : bool ok = ix86_expand_int_vcond (operands);
4018 : 395 : gcc_assert (ok);
4019 : 63 : DONE;
4020 : : })
4021 : :
4022 : : (define_expand "vcondu<mode><mode>"
4023 : : [(set (match_operand:VI_16_32 0 "register_operand")
4024 : : (if_then_else:VI_16_32
4025 : 332 : (match_operator 3 ""
4026 : 332 : [(match_operand:VI_16_32 4 "register_operand")
4027 : 332 : (match_operand:VI_16_32 5 "register_operand")])
4028 : 332 : (match_operand:VI_16_32 1)
4029 : 332 : (match_operand:VI_16_32 2)))]
4030 : 332 : "TARGET_SSE2"
4031 : 376 : {
4032 : 420 : bool ok = ix86_expand_int_vcond (operands);
4033 : 83 : gcc_assert (ok);
4034 : 376 : DONE;
4035 : : })
4036 : :
4037 : : (define_expand "vcond_mask_<mode><mmxintvecmodelower>"
4038 : : [(set (match_operand:MMXMODE124 0 "register_operand")
4039 : : (vec_merge:MMXMODE124
4040 : 39 : (match_operand:MMXMODE124 1 "register_operand")
4041 : 39 : (match_operand:MMXMODE124 2 "register_operand")
4042 : 39 : (match_operand:<mmxintvecmode> 3 "register_operand")))]
4043 : 39 : "TARGET_MMX_WITH_SSE"
4044 : 283 : {
4045 : 283 : ix86_expand_sse_movcc (operands[0], operands[3],
4046 : 39 : operands[1], operands[2]);
4047 : 244 : DONE;
4048 : 39 : })
4049 : 39 :
4050 : 72 : (define_expand "vcond_mask_<mode><mode>"
4051 : : [(set (match_operand:VI_16_32 0 "register_operand")
4052 : : (vec_merge:VI_16_32
4053 : : (match_operand:VI_16_32 1 "register_operand")
4054 : : (match_operand:VI_16_32 2 "register_operand")
4055 : : (match_operand:VI_16_32 3 "register_operand")))]
4056 : : "TARGET_SSE2"
4057 : 72 : {
4058 : 72 : ix86_expand_sse_movcc (operands[0], operands[3],
4059 : 72 : operands[1], operands[2]);
4060 : 0 : DONE;
4061 : 72 : })
4062 : 72 :
4063 : 72 : (define_insn "mmx_pblendvb_v8qi"
4064 : 72 : [(set (match_operand:V8QI 0 "register_operand" "=Yr,*x,x")
4065 : 118 : (unspec:V8QI
4066 : 72 : [(match_operand:V8QI 1 "register_operand" "0,0,x")
4067 : : (match_operand:V8QI 2 "register_operand" "Yr,*x,x")
4068 : : (match_operand:V8QI 3 "register_operand" "Yz,Yz,x")]
4069 : : UNSPEC_BLENDV))]
4070 : 899 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4071 : 14 : "@
4072 : 276 : pblendvb\t{%3, %2, %0|%0, %2, %3}
4073 : 32 : pblendvb\t{%3, %2, %0|%0, %2, %3}
4074 : 1194 : vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4075 : 1194 : [(set_attr "isa" "noavx,noavx,avx")
4076 : 1194 : (set_attr "type" "ssemov")
4077 : 14 : (set_attr "prefix_extra" "1")
4078 : 230 : (set_attr "length_immediate" "1")
4079 : 262 : (set_attr "prefix" "orig,orig,vex")
4080 : 262 : (set_attr "btver2_decode" "vector")
4081 : 32 : (set_attr "mode" "TI")])
4082 : 230 :
4083 : 230 : (define_insn_and_split "*mmx_pblendvb_v8qi_1"
4084 : 230 : [(set (match_operand:V8QI 0 "register_operand")
4085 : 0 : (unspec:V8QI
4086 : 0 : [(match_operand:V8QI 1 "register_operand")
4087 : : (match_operand:V8QI 2 "register_operand")
4088 : 0 : (eq:V8QI
4089 : 0 : (eq:V8QI
4090 : 0 : (match_operand:V8QI 3 "register_operand")
4091 : 0 : (match_operand:V8QI 4 "nonmemory_operand"))
4092 : 0 : (match_operand:V8QI 5 "const0_operand"))]
4093 : 0 : UNSPEC_BLENDV))]
4094 : 0 : "TARGET_MMX_WITH_SSE && ix86_pre_reload_split ()"
4095 : 0 : "#"
4096 : 0 : "&& 1"
4097 : 0 : [(set (match_dup 6)
4098 : 0 : (eq:V8QI (match_dup 3) (match_dup 7)))
4099 : 0 : (set (match_dup 0)
4100 : 0 : (unspec:V8QI
4101 : 0 : [(match_dup 2)
4102 : : (match_dup 1)
4103 : : (match_dup 6)]
4104 : : UNSPEC_BLENDV))]
4105 : 0 : {
4106 : 0 : operands[6] = gen_reg_rtx (V8QImode);
4107 : 0 : operands[7] = force_reg (V8QImode, operands[4]);
4108 : : })
4109 : :
4110 : : (define_insn_and_split "*mmx_pblendvb_v8qi_2"
4111 : 0 : [(set (match_operand:V8QI 0 "register_operand")
4112 : 0 : (unspec:V8QI
4113 : 0 : [(match_operand:V8QI 1 "register_operand")
4114 : 0 : (match_operand:V8QI 2 "register_operand")
4115 : 0 : (subreg:V8QI
4116 : 0 : (eq:MMXMODE24
4117 : 0 : (eq:MMXMODE24
4118 : 0 : (match_operand:MMXMODE24 3 "register_operand")
4119 : 0 : (match_operand:MMXMODE24 4 "nonmemory_operand"))
4120 : 0 : (match_operand:MMXMODE24 5 "const0_operand")) 0)]
4121 : 0 : UNSPEC_BLENDV))]
4122 : 36 : "TARGET_MMX_WITH_SSE && ix86_pre_reload_split ()"
4123 : 0 : "#"
4124 : 0 : "&& 1"
4125 : 0 : [(set (match_dup 6)
4126 : 12 : (eq:MMXMODE24 (match_dup 3) (match_dup 8)))
4127 : 24 : (set (match_dup 0)
4128 : 12 : (unspec:V8QI
4129 : 12 : [(match_dup 2)
4130 : : (match_dup 1)
4131 : 0 : (match_dup 7)]
4132 : : UNSPEC_BLENDV))]
4133 : 12 : {
4134 : 12 : operands[6] = gen_reg_rtx (<MODE>mode);
4135 : 12 : operands[7] = lowpart_subreg (V8QImode, operands[6], <MODE>mode);
4136 : 12 : operands[8] = force_reg (<MODE>mode, operands[4]);
4137 : : })
4138 : 0 :
4139 : 0 : (define_insn "mmx_pblendvb_<mode>"
4140 : 12 : [(set (match_operand:VI_16_32 0 "register_operand" "=Yr,*x,x")
4141 : 12 : (unspec:VI_16_32
4142 : 12 : [(match_operand:VI_16_32 1 "register_operand" "0,0,x")
4143 : 12 : (match_operand:VI_16_32 2 "register_operand" "Yr,*x,x")
4144 : 12 : (match_operand:VI_16_32 3 "register_operand" "Yz,Yz,x")]
4145 : 12 : UNSPEC_BLENDV))]
4146 : 594 : "TARGET_SSE4_1"
4147 : 12 : "@
4148 : 24 : pblendvb\t{%3, %2, %0|%0, %2, %3}
4149 : 24 : pblendvb\t{%3, %2, %0|%0, %2, %3}
4150 : 369 : vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4151 : 369 : [(set_attr "isa" "noavx,noavx,avx")
4152 : 369 : (set_attr "type" "ssemov")
4153 : 24 : (set_attr "prefix_extra" "1")
4154 : 24 : (set_attr "length_immediate" "1")
4155 : 24 : (set_attr "prefix" "orig,orig,vex")
4156 : 24 : (set_attr "btver2_decode" "vector")
4157 : 24 : (set_attr "mode" "TI")])
4158 : 24 :
4159 : 0 : (define_insn_and_split "*mmx_pblendvb_<mode>_1"
4160 : 12 : [(set (match_operand:VI_16_32 0 "register_operand")
4161 : : (unspec:VI_16_32
4162 : 12 : [(match_operand:VI_16_32 1 "register_operand")
4163 : : (match_operand:VI_16_32 2 "register_operand")
4164 : : (eq:VI_16_32
4165 : : (eq:VI_16_32
4166 : : (match_operand:VI_16_32 3 "register_operand")
4167 : : (match_operand:VI_16_32 4 "nonmemory_operand"))
4168 : : (match_operand:VI_16_32 5 "const0_operand"))]
4169 : 12 : UNSPEC_BLENDV))]
4170 : 12 : "TARGET_SSE2 && ix86_pre_reload_split ()"
4171 : 12 : "#"
4172 : : "&& 1"
4173 : 0 : [(set (match_dup 6)
4174 : 0 : (eq:VI_16_32 (match_dup 3) (match_dup 7)))
4175 : 0 : (set (match_dup 0)
4176 : 0 : (unspec:VI_16_32
4177 : 0 : [(match_dup 2)
4178 : : (match_dup 1)
4179 : 0 : (match_dup 6)]
4180 : 3127 : UNSPEC_BLENDV))]
4181 : 3127 : {
4182 : 3243 : operands[6] = gen_reg_rtx (<MODE>mode);
4183 : 3255 : operands[7] = force_reg (<MODE>mode, operands[4]);
4184 : 24 : })
4185 : 3243 :
4186 : 3243 : (define_insn_and_split "*mmx_pblendvb_v4qi_2"
4187 : 3243 : [(set (match_operand:V4QI 0 "register_operand")
4188 : 3243 : (unspec:V4QI
4189 : 3243 : [(match_operand:V4QI 1 "register_operand")
4190 : 3243 : (match_operand:V4QI 2 "register_operand")
4191 : 3243 : (subreg:V4QI
4192 : 0 : (eq:V2HI
4193 : 3243 : (eq:V2HI
4194 : 0 : (match_operand:V2HI 3 "register_operand")
4195 : 868 : (match_operand:V2HI 4 "nonmemory_operand"))
4196 : 868 : (match_operand:V2HI 5 "const0_operand")) 0)]
4197 : 868 : UNSPEC_BLENDV))]
4198 : 36 : "TARGET_SSE2 && ix86_pre_reload_split ()"
4199 : 0 : "#"
4200 : 0 : "&& 1"
4201 : 0 : [(set (match_dup 6)
4202 : 12 : (eq:V2HI (match_dup 3) (match_dup 8)))
4203 : 0 : (set (match_dup 0)
4204 : : (unspec:V4QI
4205 : : [(match_dup 2)
4206 : 300 : (match_dup 1)
4207 : 300 : (match_dup 7)]
4208 : : UNSPEC_BLENDV))]
4209 : 12 : {
4210 : 12 : operands[6] = gen_reg_rtx (V2HImode);
4211 : 12 : operands[7] = lowpart_subreg (V4QImode, operands[6], V2HImode);
4212 : 19014 : operands[8] = force_reg (V2HImode, operands[4]);
4213 : 19002 : })
4214 : 0 :
4215 : 2 : ;; XOP parallel XMM conditional moves
4216 : 16 : (define_insn "*xop_pcmov_<mode>"
4217 : 12 : [(set (match_operand:MMXMODE124 0 "register_operand" "=x")
4218 : 12 : (if_then_else:MMXMODE124
4219 : 12 : (match_operand:MMXMODE124 3 "register_operand" "x")
4220 : 12 : (match_operand:MMXMODE124 1 "register_operand" "x")
4221 : 12 : (match_operand:MMXMODE124 2 "register_operand" "x")))]
4222 : 24 : "TARGET_XOP && TARGET_MMX_WITH_SSE"
4223 : 12 : "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4224 : 24 : [(set_attr "type" "sse4arg")
4225 : 24 : (set_attr "mode" "TI")])
4226 : 214 :
4227 : 214 : (define_insn "*xop_pcmov_<mode>"
4228 : 214 : [(set (match_operand:V4F_64 0 "register_operand" "=x")
4229 : 24 : (if_then_else:V4F_64
4230 : 24 : (match_operand:V4F_64 3 "register_operand" "x")
4231 : 24 : (match_operand:V4F_64 1 "register_operand" "x")
4232 : 24 : (match_operand:V4F_64 2 "register_operand" "x")))]
4233 : 0 : "TARGET_XOP && TARGET_MMX_WITH_SSE"
4234 : 24 : "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4235 : 0 : [(set_attr "type" "sse4arg")
4236 : 12 : (set_attr "mode" "TI")])
4237 : 4 :
4238 : 16 : (define_insn "*xop_pcmov_<mode>"
4239 : 4 : [(set (match_operand:VI_16_32 0 "register_operand" "=x")
4240 : : (if_then_else:VI_16_32
4241 : : (match_operand:VI_16_32 3 "register_operand" "x")
4242 : : (match_operand:VI_16_32 1 "register_operand" "x")
4243 : : (match_operand:VI_16_32 2 "register_operand" "x")))]
4244 : 0 : "TARGET_XOP"
4245 : 12 : "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4246 : 12 : [(set_attr "type" "sse4arg")
4247 : 12 : (set_attr "mode" "TI")])
4248 : 164 :
4249 : 164 : (define_insn "*xop_pcmov_<mode>"
4250 : 164 : [(set (match_operand:V2F_32 0 "register_operand" "=x")
4251 : : (if_then_else:V2F_32
4252 : 2 : (match_operand:V2F_32 3 "register_operand" "x")
4253 : : (match_operand:V2F_32 1 "register_operand" "x")
4254 : : (match_operand:V2F_32 2 "register_operand" "x")))]
4255 : 6 : "TARGET_XOP"
4256 : 2 : "vpcmov\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4257 : 2 : [(set_attr "type" "sse4arg")
4258 : 2 : (set_attr "mode" "TI")])
4259 : 6 :
4260 : 6 : ;; XOP permute instructions
4261 : 6 : (define_insn "mmx_ppermv64"
4262 : : [(set (match_operand:V8QI 0 "register_operand" "=x")
4263 : 274 : (unspec:V8QI
4264 : 274 : [(match_operand:V8QI 1 "register_operand" "x")
4265 : : (match_operand:V8QI 2 "register_operand" "x")
4266 : 260 : (match_operand:V16QI 3 "nonimmediate_operand" "xm")]
4267 : 260 : UNSPEC_XOP_PERMUTE))]
4268 : : "TARGET_XOP && TARGET_MMX_WITH_SSE"
4269 : 260 : "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4270 : 260 : [(set_attr "type" "sse4arg")
4271 : : (set_attr "mode" "TI")])
4272 : 243 :
4273 : 0 : (define_insn "mmx_ppermv32"
4274 : 0 : [(set (match_operand:V4QI 0 "register_operand" "=x")
4275 : 243 : (unspec:V4QI
4276 : 243 : [(match_operand:V4QI 1 "register_operand" "x")
4277 : : (match_operand:V4QI 2 "register_operand" "x")
4278 : 242 : (match_operand:V16QI 3 "nonimmediate_operand" "xm")]
4279 : 242 : UNSPEC_XOP_PERMUTE))]
4280 : 0 : "TARGET_XOP"
4281 : 242 : "vpperm\t{%3, %2, %1, %0|%0, %1, %2, %3}"
4282 : : [(set_attr "type" "sse4arg")
4283 : 238 : (set_attr "mode" "TI")])
4284 : :
4285 : 60 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4286 : 60 : ;;
4287 : 60 : ;; Parallel integral logical operations
4288 : 11428 : ;;
4289 : 11428 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4290 : :
4291 : 4 : (define_expand "one_cmpl<mode>2"
4292 : 4 : [(set (match_operand:MMXMODEI 0 "register_operand")
4293 : 4 : (xor:MMXMODEI
4294 : : (match_operand:MMXMODEI 1 "register_operand")
4295 : 4 : (match_dup 2)))]
4296 : 4 : "TARGET_MMX_WITH_SSE"
4297 : 6 : "operands[2] = force_reg (<MODE>mode, CONSTM1_RTX (<MODE>mode));")
4298 : :
4299 : 4 : (define_insn "one_cmpl<mode>2"
4300 : 23 : [(set (match_operand:VI_16_32 0 "register_operand" "=?r,&x,&v")
4301 : 23 : (not:VI_16_32
4302 : 23 : (match_operand:VI_16_32 1 "register_operand" "0,x,v")))]
4303 : 23 : ""
4304 : 19 : "#"
4305 : 19 : [(set_attr "isa" "*,sse2,avx512vl")
4306 : 0 : (set_attr "type" "negnot,sselog1,sselog1")
4307 : 19 : (set_attr "mode" "SI,TI,TI")])
4308 : :
4309 : : (define_split
4310 : : [(set (match_operand:VI_16_32 0 "general_reg_operand")
4311 : 19 : (not:VI_16_32
4312 : 19 : (match_operand:VI_16_32 1 "general_reg_operand")))]
4313 : 20 : "reload_completed"
4314 : 3 : [(set (match_dup 0)
4315 : 318489 : (not:SI (match_dup 1)))]
4316 : 5 : {
4317 : 5 : operands[1] = lowpart_subreg (SImode, operands[1], <MODE>mode);
4318 : 318511 : operands[0] = lowpart_subreg (SImode, operands[0], <MODE>mode);
4319 : 1 : })
4320 : :
4321 : 18 : (define_split
4322 : 21 : [(set (match_operand:VI_16_32 0 "sse_reg_operand")
4323 : 17 : (not:VI_16_32
4324 : 1 : (match_operand:VI_16_32 1 "sse_reg_operand")))]
4325 : 3 : "TARGET_SSE2 && reload_completed"
4326 : 7 : [(set (match_dup 0) (match_dup 2))
4327 : 318497 : (set (match_dup 0)
4328 : 35 : (xor:V16QI
4329 : 38 : (match_dup 0) (match_dup 1)))]
4330 : 318518 : {
4331 : 6 : operands[2] = CONSTM1_RTX (V16QImode);
4332 : 3 : operands[1] = lowpart_subreg (V16QImode, operands[1], <MODE>mode);
4333 : 3 : operands[0] = lowpart_subreg (V16QImode, operands[0], <MODE>mode);
4334 : : })
4335 : :
4336 : : (define_insn "mmx_andnot<mode>3"
4337 : 5 : [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,x,v")
4338 : 3 : (and:MMXMODEI
4339 : 5 : (not:MMXMODEI (match_operand:MMXMODEI 1 "register_operand" "0,0,x,v"))
4340 : 5 : (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,x,v")))]
4341 : 234 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4342 : 2 : "@
4343 : 3 : pandn\t{%2, %0|%0, %2}
4344 : 2 : pandn\t{%2, %0|%0, %2}
4345 : 2151 : vpandn\t{%2, %1, %0|%0, %1, %2}
4346 : 1982 : vpandnd\t{%2, %1, %0|%0, %1, %2}"
4347 : 2148 : [(set_attr "isa" "*,sse2_noavx,avx,avx512vl")
4348 : 155 : (set_attr "mmx_isa" "native,*,*,*")
4349 : 14 : (set_attr "type" "mmxadd,sselog,sselog,sselog")
4350 : 14 : (set_attr "mode" "DI,TI,TI,TI")])
4351 : 3 :
4352 : 80 : (define_insn "*andnot<mode>3"
4353 : 80 : [(set (match_operand:VI_16_32 0 "register_operand" "=?&r,?r,x,x,v")
4354 : 80 : (and:VI_16_32
4355 : 80 : (not:VI_16_32
4356 : 0 : (match_operand:VI_16_32 1 "register_operand" "0,r,0,x,v"))
4357 : 3 : (match_operand:VI_16_32 2 "register_operand" "r,r,x,x,v")))
4358 : : (clobber (reg:CC FLAGS_REG))]
4359 : 115 : ""
4360 : 115 : "#"
4361 : 115 : [(set_attr "isa" "*,bmi,sse2_noavx,avx,avx512vl")
4362 : 107 : (set_attr "type" "alu,bitmanip,sselog,sselog,sselog")
4363 : 11 : (set_attr "mode" "SI,SI,TI,TI,TI")])
4364 : 8 :
4365 : 3 : (define_split
4366 : 0 : [(set (match_operand:VI_16_32 0 "general_reg_operand")
4367 : 0 : (and:VI_16_32
4368 : 0 : (not:VI_16_32 (match_operand:VI_16_32 1 "general_reg_operand"))
4369 : : (match_operand:VI_16_32 2 "general_reg_operand")))
4370 : : (clobber (reg:CC FLAGS_REG))]
4371 : 1 : "TARGET_BMI && reload_completed"
4372 : 0 : [(parallel
4373 : 3 : [(set (match_dup 0)
4374 : : (and:SI (not:SI (match_dup 1)) (match_dup 2)))
4375 : : (clobber (reg:CC FLAGS_REG))])]
4376 : 0 : {
4377 : 0 : operands[2] = lowpart_subreg (SImode, operands[2], <MODE>mode);
4378 : 0 : operands[1] = lowpart_subreg (SImode, operands[1], <MODE>mode);
4379 : 0 : operands[0] = lowpart_subreg (SImode, operands[0], <MODE>mode);
4380 : : })
4381 : :
4382 : : (define_split
4383 : 0 : [(set (match_operand:VI_16_32 0 "general_reg_operand")
4384 : 0 : (and:VI_16_32
4385 : 0 : (not:VI_16_32 (match_operand:VI_16_32 1 "general_reg_operand"))
4386 : 0 : (match_operand:VI_16_32 2 "general_reg_operand")))
4387 : 0 : (clobber (reg:CC FLAGS_REG))]
4388 : 3 : "!TARGET_BMI && reload_completed"
4389 : 3 : [(set (match_dup 0)
4390 : : (not:SI (match_dup 1)))
4391 : 146 : (parallel
4392 : 63 : [(set (match_dup 0)
4393 : 63 : (and:SI (match_dup 0) (match_dup 2)))
4394 : 146 : (clobber (reg:CC FLAGS_REG))])]
4395 : 3 : {
4396 : 3 : operands[2] = lowpart_subreg (SImode, operands[2], <MODE>mode);
4397 : 3 : operands[1] = lowpart_subreg (SImode, operands[1], <MODE>mode);
4398 : 3 : operands[0] = lowpart_subreg (SImode, operands[0], <MODE>mode);
4399 : 0 : })
4400 : :
4401 : : (define_split
4402 : 3 : [(set (match_operand:VI_16_32 0 "sse_reg_operand")
4403 : 3 : (and:VI_16_32
4404 : 3 : (not:VI_16_32 (match_operand:VI_16_32 1 "sse_reg_operand"))
4405 : 4 : (match_operand:VI_16_32 2 "sse_reg_operand")))
4406 : 3 : (clobber (reg:CC FLAGS_REG))]
4407 : 67 : "TARGET_SSE2 && reload_completed"
4408 : 86 : [(set (match_dup 0)
4409 : 64 : (and:V16QI (not:V16QI (match_dup 1)) (match_dup 2)))]
4410 : 64 : {
4411 : 2002 : operands[2] = lowpart_subreg (V16QImode, operands[2], <MODE>mode);
4412 : 1998 : operands[1] = lowpart_subreg (V16QImode, operands[1], <MODE>mode);
4413 : 1999 : operands[0] = lowpart_subreg (V16QImode, operands[0], <MODE>mode);
4414 : : })
4415 : 80 :
4416 : 2 : (define_expand "mmx_<code><mode>3"
4417 : 145 : [(set (match_operand:MMXMODEI 0 "register_operand")
4418 : 3 : (any_logic:MMXMODEI
4419 : 5 : (match_operand:MMXMODEI 1 "register_mmxmem_operand")
4420 : 66 : (match_operand:MMXMODEI 2 "register_mmxmem_operand")))]
4421 : 63 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4422 : 167 : "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);")
4423 : 63 :
4424 : : (define_expand "<code><mode>3"
4425 : 104 : [(set (match_operand:MMXMODEI 0 "register_operand")
4426 : 133 : (any_logic:MMXMODEI
4427 : 104 : (match_operand:MMXMODEI 1 "register_operand")
4428 : 63 : (match_operand:MMXMODEI 2 "register_operand")))]
4429 : 63 : "TARGET_MMX_WITH_SSE")
4430 : 196 :
4431 : 29 : (define_insn "*mmx_<code><mode>3"
4432 : 133 : [(set (match_operand:MMXMODEI 0 "register_operand" "=y,x,x,v")
4433 : 0 : (any_logic:MMXMODEI
4434 : 29 : (match_operand:MMXMODEI 1 "register_mmxmem_operand" "%0,0,x,v")
4435 : 0 : (match_operand:MMXMODEI 2 "register_mmxmem_operand" "ym,x,x,v")))]
4436 : 402 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
4437 : 10553 : && ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4438 : 140 : "@
4439 : 36 : p<logic>\t{%2, %0|%0, %2}
4440 : 0 : p<logic>\t{%2, %0|%0, %2}
4441 : 13890 : vp<logic>\t{%2, %1, %0|%0, %1, %2}
4442 : 13890 : vp<logic>d\t{%2, %1, %0|%0, %1, %2}"
4443 : 10829 : [(set_attr "isa" "*,sse2_noavx,avx,avx512vl")
4444 : 36 : (set_attr "mmx_isa" "native,*,*,*")
4445 : 0 : (set_attr "type" "mmxadd,sselog,sselog,sselog")
4446 : : (set_attr "mode" "DI,TI,TI,TI")])
4447 : 159 :
4448 : 104 : (define_expand "<code><mode>3"
4449 : 104 : [(set (match_operand:VI_16_32 0 "nonimmediate_operand")
4450 : 104 : (any_logic:VI_16_32
4451 : 104 : (match_operand:VI_16_32 1 "nonimmediate_operand")
4452 : 104 : (match_operand:VI_16_32 2 "nonimmediate_or_x86_64_const_vector_operand")))]
4453 : 104 : ""
4454 : 464 : "ix86_expand_binary_operator (<CODE>, <MODE>mode, operands); DONE;")
4455 : 41 :
4456 : : (define_insn "*<code><mode>3"
4457 : : [(set (match_operand:VI_16_32 0 "nonimmediate_operand" "=?r,m,x,x,v")
4458 : : (any_logic:VI_16_32
4459 : 41 : (match_operand:VI_16_32 1 "nonimmediate_operand" "%0,0,0,x,v")
4460 : : (match_operand:VI_16_32 2 "nonimmediate_or_x86_64_const_vector_operand" "r,i,x,x,v")))
4461 : : (clobber (reg:CC FLAGS_REG))]
4462 : 2095 : "ix86_binary_operator_ok (<CODE>, <MODE>mode, operands)"
4463 : : "#"
4464 : 566 : [(set_attr "isa" "*,*,sse2_noavx,avx,avx512vl")
4465 : 566 : (set_attr "type" "alu,alu,sselog,sselog,sselog")
4466 : 622 : (set_attr "mode" "SI,SI,TI,TI,TI")])
4467 : 644 :
4468 : 418 : (define_split
4469 : 310 : [(set (match_operand:VI_16_32 0 "nonimmediate_gr_operand")
4470 : 310 : (any_logic:VI_16_32
4471 : 354 : (match_operand:VI_16_32 1 "nonimmediate_gr_operand")
4472 : 298 : (match_operand:VI_16_32 2 "reg_or_const_vector_operand")))
4473 : : (clobber (reg:CC FLAGS_REG))]
4474 : 216 : "reload_completed"
4475 : 694 : [(parallel
4476 : 814 : [(set (match_dup 0)
4477 : 198 : (any_logic:<mmxinsnmode> (match_dup 1) (match_dup 2)))
4478 : 200 : (clobber (reg:CC FLAGS_REG))])]
4479 : 2548 : {
4480 : 694 : if (!register_operand (operands[2], <MODE>mode))
4481 : 433 : {
4482 : 11 : HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (operands[2],
4483 : 1040 : <MODE>mode);
4484 : 11 : operands[2] = GEN_INT (val);
4485 : 431 : }
4486 : : else
4487 : 254 : operands[2] = lowpart_subreg (<mmxinsnmode>mode, operands[2], <MODE>mode);
4488 : 263 : operands[1] = lowpart_subreg (<mmxinsnmode>mode, operands[1], <MODE>mode);
4489 : 263 : operands[0] = lowpart_subreg (<mmxinsnmode>mode, operands[0], <MODE>mode);
4490 : : })
4491 : 65 :
4492 : : (define_split
4493 : 263 : [(set (match_operand:VI_16_32 0 "sse_reg_operand")
4494 : 263 : (any_logic:VI_16_32
4495 : 65 : (match_operand:VI_16_32 1 "sse_reg_operand")
4496 : 263 : (match_operand:VI_16_32 2 "sse_reg_operand")))
4497 : 263 : (clobber (reg:CC FLAGS_REG))]
4498 : 461 : "TARGET_SSE2 && reload_completed"
4499 : 877 : [(set (match_dup 0)
4500 : 198 : (any_logic:V16QI (match_dup 1) (match_dup 2)))]
4501 : 198 : {
4502 : 649 : operands[2] = lowpart_subreg (V16QImode, operands[2], <MODE>mode);
4503 : 649 : operands[1] = lowpart_subreg (V16QImode, operands[1], <MODE>mode);
4504 : 258 : operands[0] = lowpart_subreg (V16QImode, operands[0], <MODE>mode);
4505 : 56 : })
4506 : 704 :
4507 : 271 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4508 : 461 : ;;
4509 : 198 : ;; Parallel integral element swizzling
4510 : 198 : ;;
4511 : 198 : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4512 : 198 :
4513 : 198 : (define_insn_and_split "mmx_packsswb"
4514 : 459 : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
4515 : 787 : (vec_concat:V8QI
4516 : 291 : (ss_truncate:V4QI
4517 : 291 : (match_operand:V4HI 1 "register_operand" "0,0,Yw"))
4518 : 198 : (ss_truncate:V4QI
4519 : 985 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw"))))]
4520 : 527 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4521 : 0 : "@
4522 : 291 : packsswb\t{%2, %0|%0, %2}
4523 : : #
4524 : 168 : #"
4525 : 92 : "&& reload_completed
4526 : 260 : && SSE_REGNO_P (REGNO (operands[0]))"
4527 : 457 : [(const_int 0)]
4528 : 92 : "ix86_split_mmx_pack (operands, SS_TRUNCATE); DONE;"
4529 : 46 : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4530 : 114 : (set_attr "type" "mmxshft,sselog,sselog")
4531 : 731 : (set_attr "mode" "DI,TI,TI")])
4532 : 168 :
4533 : 0 : ;; This instruction does unsigned saturation of signed source
4534 : 168 : ;; and is different from generic us_truncate RTX.
4535 : : (define_insn_and_split "mmx_packuswb"
4536 : : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
4537 : : (unspec:V8QI
4538 : : [(match_operand:V4HI 1 "register_operand" "0,0,Yw")
4539 : 157 : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")]
4540 : 636 : UNSPEC_US_TRUNCATE))]
4541 : 3019 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4542 : 636 : "@
4543 : 793 : packuswb\t{%2, %0|%0, %2}
4544 : 0 : #
4545 : 995 : #"
4546 : 1631 : "&& reload_completed
4547 : 636 : && SSE_REGNO_P (REGNO (operands[0]))"
4548 : : [(const_int 0)]
4549 : 1272 : "ix86_split_mmx_pack (operands, US_TRUNCATE); DONE;"
4550 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4551 : 313 : (set_attr "type" "mmxshft,sselog,sselog")
4552 : 560 : (set_attr "mode" "DI,TI,TI")])
4553 : :
4554 : : (define_insn_and_split "mmx_packssdw"
4555 : 33 : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
4556 : 33 : (vec_concat:V4HI
4557 : 33 : (ss_truncate:V2HI
4558 : 33 : (match_operand:V2SI 1 "register_operand" "0,0,Yw"))
4559 : 33 : (ss_truncate:V2HI
4560 : 33 : (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yw"))))]
4561 : 315 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4562 : : "@
4563 : 57 : packssdw\t{%2, %0|%0, %2}
4564 : 57 : #
4565 : 0 : #"
4566 : 171 : "&& reload_completed
4567 : 57 : && SSE_REGNO_P (REGNO (operands[0]))"
4568 : : [(const_int 0)]
4569 : 114 : "ix86_split_mmx_pack (operands, SS_TRUNCATE); DONE;"
4570 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4571 : : (set_attr "type" "mmxshft,sselog,sselog")
4572 : : (set_attr "mode" "DI,TI,TI")])
4573 : :
4574 : : (define_insn_and_split "mmx_packusdw"
4575 : 712745 : [(set (match_operand:V4HI 0 "register_operand" "=Yr,*x,Yw")
4576 : : (unspec:V4HI
4577 : 442448 : [(match_operand:V2SI 1 "register_operand" "0,0,Yw")
4578 : : (match_operand:V2SI 2 "register_operand" "Yr,*x,Yw")]
4579 : 1155193 : UNSPEC_US_TRUNCATE))]
4580 : 280 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4581 : 1155333 : "#"
4582 : 280 : "&& reload_completed"
4583 : 1155333 : [(const_int 0)]
4584 : 442868 : "ix86_split_mmx_pack (operands, US_TRUNCATE); DONE;"
4585 : 712745 : [(set_attr "isa" "noavx,noavx,avx")
4586 : 712885 : (set_attr "type" "sselog")
4587 : 308004 : (set_attr "mode" "TI")])
4588 : 447740 :
4589 : 447740 : (define_insn_and_split "mmx_punpckhbw"
4590 : 464833 : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
4591 : 464833 : (vec_select:V8QI
4592 : 84542 : (vec_concat:V16QI
4593 : 17093 : (match_operand:V8QI 1 "register_operand" "0,0,Yw")
4594 : 308004 : (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yw"))
4595 : 55194 : (parallel [(const_int 4) (const_int 12)
4596 : 319835 : (const_int 5) (const_int 13)
4597 : 87371 : (const_int 6) (const_int 14)
4598 : 421 : (const_int 7) (const_int 15)])))]
4599 : 431 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4600 : 4617 : "@
4601 : 4878 : punpckhbw\t{%2, %0|%0, %2}
4602 : 4472 : #
4603 : 7159 : #"
4604 : 500 : "&& reload_completed
4605 : 2092 : && SSE_REGNO_P (REGNO (operands[0]))"
4606 : : [(const_int 0)]
4607 : 812 : "ix86_split_mmx_punpck (operands, true); DONE;"
4608 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4609 : 894 : (set_attr "type" "mmxcvt,sselog,sselog")
4610 : 1788 : (set_attr "mode" "DI,TI,TI")])
4611 : :
4612 : : (define_insn_and_split "mmx_punpckhbw_low"
4613 : : [(set (match_operand:V4QI 0 "register_operand" "=x,Yw")
4614 : : (vec_select:V4QI
4615 : : (vec_concat:V8QI
4616 : : (match_operand:V4QI 1 "register_operand" "0,Yw")
4617 : : (match_operand:V4QI 2 "register_operand" "x,Yw"))
4618 : : (parallel [(const_int 2) (const_int 6)
4619 : 300 : (const_int 3) (const_int 7)])))]
4620 : 2481 : "TARGET_SSE2"
4621 : 300 : "#"
4622 : 900 : "&& reload_completed"
4623 : 0 : [(const_int 0)]
4624 : 600 : "ix86_split_mmx_punpck (operands, true); DONE;"
4625 : 4268 : [(set_attr "isa" "noavx,avx")
4626 : 2310 : (set_attr "type" "sselog")
4627 : 4620 : (set_attr "mode" "TI")])
4628 : :
4629 : : (define_insn_and_split "mmx_punpcklbw"
4630 : : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
4631 : : (vec_select:V8QI
4632 : : (vec_concat:V16QI
4633 : : (match_operand:V8QI 1 "register_operand" "0,0,Yw")
4634 : : (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yw"))
4635 : : (parallel [(const_int 0) (const_int 8)
4636 : 447 : (const_int 1) (const_int 9)
4637 : : (const_int 2) (const_int 10)
4638 : 447 : (const_int 3) (const_int 11)])))]
4639 : 4393 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4640 : 0 : "@
4641 : 447 : punpcklbw\t{%2, %0|%0, %k2}
4642 : : #
4643 : 1881 : #"
4644 : 2775 : "&& reload_completed
4645 : 447 : && SSE_REGNO_P (REGNO (operands[0]))"
4646 : : [(const_int 0)]
4647 : 894 : "ix86_split_mmx_punpck (operands, false); DONE;"
4648 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4649 : 600 : (set_attr "type" "mmxcvt,sselog,sselog")
4650 : 600 : (set_attr "mode" "DI,TI,TI")])
4651 : :
4652 : : (define_insn_and_split "mmx_punpcklbw_low"
4653 : : [(set (match_operand:V4QI 0 "register_operand" "=x,Yw")
4654 : : (vec_select:V4QI
4655 : : (vec_concat:V8QI
4656 : : (match_operand:V4QI 1 "register_operand" "0,Yw")
4657 : : (match_operand:V4QI 2 "register_operand" "x,Yw"))
4658 : : (parallel [(const_int 0) (const_int 4)
4659 : 369 : (const_int 1) (const_int 5)])))]
4660 : 2263 : "TARGET_SSE2"
4661 : 369 : "#"
4662 : 1107 : "&& reload_completed"
4663 : 0 : [(const_int 0)]
4664 : 738 : "ix86_split_mmx_punpck (operands, false); DONE;"
4665 : 4487 : [(set_attr "isa" "noavx,avx")
4666 : 3208 : (set_attr "type" "sselog")
4667 : 6416 : (set_attr "mode" "TI")])
4668 : :
4669 : : (define_insn_and_split "mmx_punpckhwd"
4670 : : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
4671 : : (vec_select:V4HI
4672 : : (vec_concat:V8HI
4673 : : (match_operand:V4HI 1 "register_operand" "0,0,Yw")
4674 : : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw"))
4675 : : (parallel [(const_int 2) (const_int 6)
4676 : 1155 : (const_int 3) (const_int 7)])))]
4677 : 6539 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4678 : 1155 : "@
4679 : 1155 : punpckhwd\t{%2, %0|%0, %2}
4680 : 0 : #
4681 : 2680 : #"
4682 : 3835 : "&& reload_completed
4683 : 1155 : && SSE_REGNO_P (REGNO (operands[0]))"
4684 : : [(const_int 0)]
4685 : 2310 : "ix86_split_mmx_punpck (operands, true); DONE;"
4686 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4687 : 738 : (set_attr "type" "mmxcvt,sselog,sselog")
4688 : 738 : (set_attr "mode" "DI,TI,TI")])
4689 : :
4690 : : (define_insn_and_split "mmx_punpcklwd"
4691 : : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
4692 : : (vec_select:V4HI
4693 : : (vec_concat:V8HI
4694 : : (match_operand:V4HI 1 "register_operand" "0,0,Yw")
4695 : : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw"))
4696 : : (parallel [(const_int 0) (const_int 4)
4697 : 1604 : (const_int 1) (const_int 5)])))]
4698 : 7647 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4699 : 1604 : "@
4700 : 1604 : punpcklwd\t{%2, %0|%0, %k2}
4701 : 0 : #
4702 : 1604 : #"
4703 : 3208 : "&& reload_completed
4704 : 1604 : && SSE_REGNO_P (REGNO (operands[0]))"
4705 : : [(const_int 0)]
4706 : 3208 : "ix86_split_mmx_punpck (operands, false); DONE;"
4707 : 2319 : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4708 : 2324 : (set_attr "type" "mmxcvt,sselog,sselog")
4709 : : (set_attr "mode" "DI,TI,TI")])
4710 : :
4711 : : (define_insn_and_split "mmx_punpckhdq"
4712 : 498384 : [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv")
4713 : 498384 : (vec_select:V2SI
4714 : 498384 : (vec_concat:V4SI
4715 : 498384 : (match_operand:V2SI 1 "register_operand" "0,0,Yv")
4716 : : (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv"))
4717 : 325611 : (parallel [(const_int 1)
4718 : 325703 : (const_int 3)])))]
4719 : 327958 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4720 : 92 : "@
4721 : 92 : punpckhdq\t{%2, %0|%0, %2}
4722 : 0 : #
4723 : 36398 : #"
4724 : 184 : "&& reload_completed
4725 : 36398 : && SSE_REGNO_P (REGNO (operands[0]))"
4726 : 92 : [(const_int 0)]
4727 : 98812 : "ix86_split_mmx_punpck (operands, true); DONE;"
4728 : 98720 : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4729 : 96223 : (set_attr "type" "mmxcvt,sselog,sselog")
4730 : 33 : (set_attr "mode" "DI,TI,TI")])
4731 : 33 :
4732 : 8623 : (define_insn_and_split "mmx_punpckldq"
4733 : 44046 : [(set (match_operand:V2SI 0 "register_operand" "=y,x,Yv")
4734 : 44046 : (vec_select:V2SI
4735 : 44046 : (vec_concat:V4SI
4736 : : (match_operand:V2SI 1 "register_operand" "0,0,Yv")
4737 : 0 : (match_operand:V2SI 2 "register_mmxmem_operand" "ym,x,Yv"))
4738 : 0 : (parallel [(const_int 0)
4739 : 105 : (const_int 2)])))]
4740 : 3518 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
4741 : 105 : "@
4742 : 105 : punpckldq\t{%2, %0|%0, %k2}
4743 : 0 : #
4744 : 940 : #"
4745 : 1045 : "&& reload_completed
4746 : 105 : && SSE_REGNO_P (REGNO (operands[0]))"
4747 : 105 : [(const_int 0)]
4748 : 105 : "ix86_split_mmx_punpck (operands, false); DONE;"
4749 : : [(set_attr "mmx_isa" "native,sse_noavx,avx")
4750 : 94 : (set_attr "type" "mmxcvt,sselog,sselog")
4751 : 94 : (set_attr "mode" "DI,TI,TI")])
4752 : :
4753 : : (define_insn "sse4_1_<code>v4qiv4hi2"
4754 : : [(set (match_operand:V4HI 0 "register_operand" "=Yr,*x,Yw")
4755 : : (any_extend:V4HI
4756 : : (vec_select:V4QI
4757 : : (match_operand:V8QI 1 "register_operand" "Yr,*x,Yw")
4758 : : (parallel [(const_int 0) (const_int 1)
4759 : 4 : (const_int 2) (const_int 3)]))))]
4760 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4761 : : "%vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
4762 : 4 : [(set_attr "isa" "noavx,noavx,avx")
4763 : 4 : (set_attr "type" "ssemov")
4764 : 4750 : (set_attr "prefix_extra" "1")
4765 : 4750 : (set_attr "prefix" "orig,orig,maybe_evex")
4766 : 4 : (set_attr "mode" "TI")])
4767 : 585 :
4768 : 581 : (define_expand "<insn>v4qiv4hi2"
4769 : : [(set (match_operand:V4HI 0 "register_operand")
4770 : : (any_extend:V4HI
4771 : : (match_operand:V4QI 1 "register_operand")))]
4772 : : "TARGET_MMX_WITH_SSE"
4773 : 21 : {
4774 : 4 : if (!TARGET_SSE4_1)
4775 : : {
4776 : 17 : ix86_expand_sse_extend (operands[0], operands[1], <u_bool>);
4777 : 17 : DONE;
4778 : : }
4779 : :
4780 : 4 : rtx op1 = force_reg (V4QImode, operands[1]);
4781 : 4 : op1 = lowpart_subreg (V8QImode, op1, V4QImode);
4782 : 4 : emit_insn (gen_sse4_1_<code>v4qiv4hi2 (operands[0], op1));
4783 : 4 : DONE;
4784 : : })
4785 : :
4786 : : (define_insn "sse4_1_<code>v2hiv2si2"
4787 : : [(set (match_operand:V2SI 0 "register_operand" "=Yr,*x,v")
4788 : : (any_extend:V2SI
4789 : : (vec_select:V2HI
4790 : : (match_operand:V4HI 1 "register_operand" "Yr,*x,v")
4791 : : (parallel [(const_int 0) (const_int 1)]))))]
4792 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4793 : : "%vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
4794 : : [(set_attr "isa" "noavx,noavx,avx")
4795 : : (set_attr "type" "ssemov")
4796 : 5 : (set_attr "prefix_extra" "1")
4797 : 5 : (set_attr "prefix" "orig,orig,maybe_evex")
4798 : : (set_attr "mode" "TI")])
4799 : :
4800 : : (define_expand "<insn>v2hiv2si2"
4801 : : [(set (match_operand:V2SI 0 "register_operand")
4802 : 38 : (any_extend:V2SI
4803 : : (match_operand:V2HI 1 "register_operand")))]
4804 : : "TARGET_MMX_WITH_SSE"
4805 : 72 : {
4806 : 38 : if (!TARGET_SSE4_1)
4807 : 38 : {
4808 : 22 : ix86_expand_sse_extend (operands[0], operands[1], <u_bool>);
4809 : 22 : DONE;
4810 : 38 : }
4811 : :
4812 : 12 : rtx op1 = force_reg (V2HImode, operands[1]);
4813 : 12 : op1 = lowpart_subreg (V4HImode, op1, V2HImode);
4814 : 12 : emit_insn (gen_sse4_1_<code>v2hiv2si2 (operands[0], op1));
4815 : 12 : DONE;
4816 : : })
4817 : :
4818 : : (define_insn "sse4_1_<code>v2qiv2si2"
4819 : : [(set (match_operand:V2SI 0 "register_operand" "=Yr,*x,v")
4820 : : (any_extend:V2SI
4821 : : (vec_select:V2QI
4822 : : (match_operand:V4QI 1 "register_operand" "Yr,*x,v")
4823 : : (parallel [(const_int 0) (const_int 1)]))))]
4824 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4825 : : "%vpmov<extsuffix>bd\t{%1, %0|%0, %1}"
4826 : : [(set_attr "isa" "noavx,noavx,avx")
4827 : : (set_attr "type" "ssemov")
4828 : 8 : (set_attr "prefix_extra" "1")
4829 : 8 : (set_attr "prefix" "orig,orig,maybe_evex")
4830 : : (set_attr "mode" "TI")])
4831 : :
4832 : : (define_expand "<insn>v2qiv2si2"
4833 : : [(set (match_operand:V2SI 0 "register_operand")
4834 : 14 : (any_extend:V2SI
4835 : : (match_operand:V2QI 1 "register_operand")))]
4836 : : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
4837 : 18 : {
4838 : 14 : rtx op1 = force_reg (V2QImode, operands[1]);
4839 : 4 : op1 = lowpart_subreg (V4QImode, op1, V2QImode);
4840 : 4 : emit_insn (gen_sse4_1_<code>v2qiv2si2 (operands[0], op1));
4841 : 4 : DONE;
4842 : 14 : })
4843 : :
4844 : : (define_insn "sse4_1_<code>v2qiv2hi2"
4845 : : [(set (match_operand:V2HI 0 "register_operand" "=Yr,*x,Yw")
4846 : : (any_extend:V2HI
4847 : : (vec_select:V2QI
4848 : : (match_operand:V4QI 1 "register_operand" "Yr,*x,Yw")
4849 : : (parallel [(const_int 0) (const_int 1)]))))]
4850 : 8 : "TARGET_SSE4_1"
4851 : : "%vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
4852 : : [(set_attr "isa" "noavx,noavx,avx")
4853 : : (set_attr "type" "ssemov")
4854 : : (set_attr "prefix_extra" "1")
4855 : : (set_attr "prefix" "orig,orig,maybe_evex")
4856 : : (set_attr "mode" "TI")])
4857 : :
4858 : 50348 : (define_expand "<insn>v2qiv2hi2"
4859 : 50348 : [(set (match_operand:V2HI 0 "register_operand")
4860 : 34 : (any_extend:V2HI
4861 : 50351 : (match_operand:V2QI 1 "register_operand")))]
4862 : : "TARGET_SSE2"
4863 : 92 : {
4864 : 34 : if (!TARGET_SSE4_1)
4865 : 34 : {
4866 : 54 : ix86_expand_sse_extend (operands[0], operands[1], <u_bool>);
4867 : 54 : DONE;
4868 : 31 : }
4869 : :
4870 : 4 : rtx op1 = force_reg (V2QImode, operands[1]);
4871 : 4 : op1 = lowpart_subreg (V4QImode, op1, V2QImode);
4872 : 773595 : emit_insn (gen_sse4_1_<code>v2qiv2hi2 (operands[0], op1));
4873 : 773595 : DONE;
4874 : 773591 : })
4875 : 773591 :
4876 : 773591 : (define_insn "truncv2hiv2qi2"
4877 : 773591 : [(set (match_operand:V2QI 0 "register_operand" "=v")
4878 : 773591 : (truncate:V2QI
4879 : 773591 : (match_operand:V2HI 1 "register_operand" "v")))]
4880 : 773600 : "TARGET_AVX512VL && TARGET_AVX512BW"
4881 : : "vpmovwb\t{%1, %0|%0, %1}"
4882 : 479973 : [(set_attr "type" "ssemov")
4883 : 479973 : (set_attr "prefix" "evex")
4884 : 3 : (set_attr "mode" "TI")])
4885 : 479976 :
4886 : 434137 : (define_mode_iterator V2QI_V2HI [V2QI V2HI])
4887 : 904134 : (define_insn "truncv2si<mode>2"
4888 : : [(set (match_operand:V2QI_V2HI 0 "register_operand" "=v")
4889 : : (truncate:V2QI_V2HI
4890 : : (match_operand:V2SI 1 "register_operand" "v")))]
4891 : 14 : "TARGET_AVX512VL && TARGET_MMX_WITH_SSE"
4892 : 277 : "vpmovd<mmxvecsize>\t{%1, %0|%0, %1}"
4893 : 16 : [(set_attr "type" "ssemov")
4894 : 9 : (set_attr "prefix" "evex")
4895 : 46 : (set_attr "mode" "TI")])
4896 : 30 :
4897 : 247 : ;; Pack/unpack vector modes
4898 : 277 : (define_mode_attr mmxpackmode
4899 : 314 : [(V4HI "V8QI") (V2SI "V4HI")])
4900 : 58 :
4901 : 284 : (define_expand "vec_pack_trunc_<mode>"
4902 : 247 : [(match_operand:<mmxpackmode> 0 "register_operand")
4903 : : (match_operand:MMXMODE24 1 "register_operand")
4904 : : (match_operand:MMXMODE24 2 "register_operand")]
4905 : : "TARGET_MMX_WITH_SSE"
4906 : 783 : {
4907 : 247 : rtx op1 = gen_lowpart (<mmxpackmode>mode, operands[1]);
4908 : 783 : rtx op2 = gen_lowpart (<mmxpackmode>mode, operands[2]);
4909 : 783 : ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
4910 : 783 : DONE;
4911 : : })
4912 : :
4913 : : (define_expand "vec_pack_trunc_v2hi"
4914 : : [(match_operand:V4QI 0 "register_operand")
4915 : : (match_operand:V2HI 1 "register_operand")
4916 : : (match_operand:V2HI 2 "register_operand")]
4917 : : "TARGET_SSE2"
4918 : 32 : {
4919 : 64 : rtx op1 = gen_lowpart (V4QImode, operands[1]);
4920 : 32 : rtx op2 = gen_lowpart (V4QImode, operands[2]);
4921 : 32 : ix86_expand_vec_extract_even_odd (operands[0], op1, op2, 0);
4922 : 32 : DONE;
4923 : : })
4924 : :
4925 : : (define_mode_attr mmxunpackmode
4926 : : [(V8QI "V4HI") (V4HI "V2SI")])
4927 : :
4928 : : (define_expand "vec_unpacks_lo_<mode>"
4929 : : [(match_operand:<mmxunpackmode> 0 "register_operand")
4930 : : (match_operand:MMXMODE12 1 "register_operand")]
4931 : 568 : "TARGET_MMX_WITH_SSE"
4932 : 275 : "ix86_expand_sse_unpack (operands[0], operands[1], false, false); DONE;")
4933 : :
4934 : : (define_expand "vec_unpacks_hi_<mode>"
4935 : 568 : [(match_operand:<mmxunpackmode> 0 "register_operand")
4936 : 568 : (match_operand:MMXMODE12 1 "register_operand")]
4937 : 568 : "TARGET_MMX_WITH_SSE"
4938 : 275 : "ix86_expand_sse_unpack (operands[0], operands[1], false, true); DONE;")
4939 : 568 :
4940 : 568 : (define_expand "vec_unpacku_lo_<mode>"
4941 : 568 : [(match_operand:<mmxunpackmode> 0 "register_operand")
4942 : : (match_operand:MMXMODE12 1 "register_operand")]
4943 : 70 : "TARGET_MMX_WITH_SSE"
4944 : 385 : "ix86_expand_sse_unpack (operands[0], operands[1], true, false); DONE;")
4945 : :
4946 : 70 : (define_expand "vec_unpacku_hi_<mode>"
4947 : 70 : [(match_operand:<mmxunpackmode> 0 "register_operand")
4948 : 70 : (match_operand:MMXMODE12 1 "register_operand")]
4949 : 345 : "TARGET_MMX_WITH_SSE"
4950 : 385 : "ix86_expand_sse_unpack (operands[0], operands[1], true, true); DONE;")
4951 : 70 :
4952 : 275 : (define_expand "vec_unpacks_lo_v4qi"
4953 : 275 : [(match_operand:V2HI 0 "register_operand")
4954 : 275 : (match_operand:V4QI 1 "register_operand")]
4955 : 620 : "TARGET_SSE2"
4956 : 0 : "ix86_expand_sse_unpack (operands[0], operands[1], false, false); DONE;")
4957 : 275 :
4958 : 345 : (define_expand "vec_unpacks_hi_v4qi"
4959 : 345 : [(match_operand:V2HI 0 "register_operand")
4960 : 345 : (match_operand:V4QI 1 "register_operand")]
4961 : 730 : "TARGET_SSE2"
4962 : 0 : "ix86_expand_sse_unpack (operands[0], operands[1], false, true); DONE;")
4963 : 345 :
4964 : 385 : (define_expand "vec_unpacku_lo_v4qi"
4965 : 385 : [(match_operand:V2HI 0 "register_operand")
4966 : 385 : (match_operand:V4QI 1 "register_operand")]
4967 : 630 : "TARGET_SSE2"
4968 : 2 : "ix86_expand_sse_unpack (operands[0], operands[1], true, false); DONE;")
4969 : 385 :
4970 : 245 : (define_expand "vec_unpacku_hi_v4qi"
4971 : 245 : [(match_operand:V2HI 0 "register_operand")
4972 : 245 : (match_operand:V4QI 1 "register_operand")]
4973 : 245 : "TARGET_SSE2"
4974 : 2 : "ix86_expand_sse_unpack (operands[0], operands[1], true, true); DONE;")
4975 : 245 :
4976 : 0 : (define_insn "*mmx_pinsrd"
4977 : 0 : [(set (match_operand:V2SI 0 "register_operand" "=x,Yv")
4978 : 0 : (vec_merge:V2SI
4979 : 2 : (vec_duplicate:V2SI
4980 : 0 : (match_operand:SI 2 "nonimmediate_operand" "jrjm,rm"))
4981 : 0 : (match_operand:V2SI 1 "register_operand" "0,Yv")
4982 : 2 : (match_operand:SI 3 "const_int_operand")))]
4983 : 96 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE
4984 : 96 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
4985 : 98 : < GET_MODE_NUNITS (V2SImode))"
4986 : 98 : {
4987 : 38 : operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
4988 : 20 : switch (which_alternative)
4989 : 18 : {
4990 : 18 : case 1:
4991 : 18 : return "vpinsrd\t{%3, %2, %1, %0|%0, %1, %2, %3}";
4992 : 5 : case 0:
4993 : 2 : return "pinsrd\t{%3, %2, %0|%0, %2, %3}";
4994 : 3 : default:
4995 : 3 : gcc_unreachable ();
4996 : 3 : }
4997 : 3 : }
4998 : 3 : [(set_attr "isa" "noavx,avx")
4999 : 3 : (set_attr "addr" "gpr16,*")
5000 : 0 : (set_attr "prefix_extra" "1")
5001 : 3 : (set_attr "type" "sselog")
5002 : : (set_attr "length_immediate" "1")
5003 : : (set_attr "prefix" "orig,vex")
5004 : : (set_attr "mode" "TI")])
5005 : :
5006 : : (define_insn "*mmx_pinsrw"
5007 : : [(set (match_operand:V4FI_64 0 "register_operand" "=y,x,YW,&x")
5008 : : (vec_merge:V4FI_64
5009 : : (vec_duplicate:V4FI_64
5010 : : (match_operand:<mmxscalarmode> 2 "nonimmediate_operand" "rm,rm,rm,x"))
5011 : : (match_operand:V4FI_64 1 "register_operand" "0,0,YW,x")
5012 : : (match_operand:SI 3 "const_int_operand")))]
5013 : 40 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5014 : 238 : && (TARGET_SSE || TARGET_3DNOW_A)
5015 : 238 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5016 : 10 : < GET_MODE_NUNITS (V4HImode))"
5017 : 217 : {
5018 : 39 : operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
5019 : 39 : switch (which_alternative)
5020 : 400 : {
5021 : 400 : case 3:
5022 : 628 : return "#";
5023 : 16 : case 2:
5024 : 16 : if (MEM_P (operands[2]))
5025 : : return "vpinsrw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5026 : : else
5027 : 16 : return "vpinsrw\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
5028 : 23 : case 1:
5029 : 23 : case 0:
5030 : 23 : if (MEM_P (operands[2]))
5031 : : return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
5032 : : else
5033 : 16 : return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
5034 : 0 : default:
5035 : 0 : gcc_unreachable ();
5036 : : }
5037 : : }
5038 : : [(set_attr "isa" "*,sse2_noavx,avx,sse4")
5039 : : (set_attr "mmx_isa" "native,*,*,*")
5040 : : (set_attr "type" "mmxcvt,sselog,sselog,sselog")
5041 : 39 : (set_attr "length_immediate" "1")
5042 : : (set_attr "mode" "DI,TI,TI,TI")])
5043 : :
5044 : : ;; For TARGET_SSE2, implement insert from XMM reg with PSHULFW + PBLENDW.
5045 : : (define_split
5046 : : [(set (match_operand:V4FI_64 0 "sse_reg_operand")
5047 : : (vec_merge:V4FI_64
5048 : : (vec_duplicate:V4FI_64
5049 : : (match_operand:<mmxscalarmode> 2 "sse_reg_operand"))
5050 : : (match_operand:V4FI_64 1 "sse_reg_operand")
5051 : : (match_operand:SI 3 "const_int_operand")))]
5052 : 4 : "TARGET_MMX_WITH_SSE && TARGET_SSE4_1 && reload_completed
5053 : 4 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5054 : 3 : < GET_MODE_NUNITS (<MODE>mode))"
5055 : 116 : [(set (match_dup 0)
5056 : 4 : (vec_duplicate:V4FI_64 (match_dup 2)))
5057 : : (set (match_dup 0)
5058 : 116 : (vec_merge:V4FI_64 (match_dup 1) (match_dup 0) (match_dup 3)))]
5059 : 120 : "operands[3] = GEN_INT (~INTVAL (operands[3]) & 0xf);")
5060 : 117 :
5061 : : (define_insn "*mmx_pinsrb"
5062 : 4 : [(set (match_operand:V8QI 0 "register_operand" "=x,YW")
5063 : 4 : (vec_merge:V8QI
5064 : 4 : (vec_duplicate:V8QI
5065 : 4 : (match_operand:QI 2 "nonimmediate_operand" "jrjm,rm"))
5066 : 4 : (match_operand:V8QI 1 "register_operand" "0,YW")
5067 : 4 : (match_operand:SI 3 "const_int_operand")))]
5068 : 4 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE
5069 : 4 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5070 : 4 : < GET_MODE_NUNITS (V8QImode))"
5071 : 0 : {
5072 : 0 : operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
5073 : 4 : switch (which_alternative)
5074 : 6 : {
5075 : 6 : case 1:
5076 : 6 : if (MEM_P (operands[2]))
5077 : : return "vpinsrb\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5078 : 4 : else
5079 : 4 : return "vpinsrb\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
5080 : 4 : case 0:
5081 : 0 : if (MEM_P (operands[2]))
5082 : : return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
5083 : : else
5084 : 0 : return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
5085 : 75 : default:
5086 : 1 : gcc_unreachable ();
5087 : : }
5088 : 1 : }
5089 : 76 : [(set_attr "isa" "noavx,avx")
5090 : 75 : (set_attr "type" "sselog")
5091 : 76 : (set_attr "addr" "gpr16,*")
5092 : 76 : (set_attr "prefix_extra" "1")
5093 : 1 : (set_attr "length_immediate" "1")
5094 : 0 : (set_attr "prefix" "orig,vex")
5095 : 1 : (set_attr "mode" "TI")])
5096 : :
5097 : : (define_insn "*mmx_pextrw"
5098 : : [(set (match_operand:HI 0 "register_sse4nonimm_operand" "=r,r,jm,m")
5099 : 8 : (vec_select:HI
5100 : : (match_operand:V4HI 1 "register_operand" "y,YW,YW,YW")
5101 : : (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
5102 : 1447 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5103 : 1447 : && (TARGET_SSE || TARGET_3DNOW_A)"
5104 : : "@
5105 : : pextrw\t{%2, %1, %k0|%k0, %1, %2}
5106 : : %vpextrw\t{%2, %1, %k0|%k0, %1, %2}
5107 : 337 : pextrw\t{%2, %1, %0|%0, %1, %2}
5108 : 337 : vpextrw\t{%2, %1, %0|%0, %1, %2}"
5109 : 337 : [(set_attr "isa" "*,sse2,sse4_noavx,avx")
5110 : 337 : (set_attr "addr" "*,*,gpr16,*")
5111 : : (set_attr "mmx_isa" "native,*,*,*")
5112 : : (set_attr "type" "mmxcvt,sselog1,sselog1,sselog1")
5113 : : (set_attr "length_immediate" "1")
5114 : : (set_attr "prefix" "orig,maybe_vex,maybe_vex,maybe_evex")
5115 : : (set_attr "mode" "DI,TI,TI,TI")])
5116 : :
5117 : : (define_insn "*mmx_pextrw<mode>"
5118 : : [(set (match_operand:<mmxscalarmode> 0 "register_sse4nonimm_operand" "=?r,?r,jm,m,x,Yw")
5119 : : (vec_select:<mmxscalarmode>
5120 : : (match_operand:V4F_64 1 "register_operand" "y,YW,YW,YW,0,YW")
5121 : : (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
5122 : 12 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5123 : : && (TARGET_SSE || TARGET_3DNOW_A)"
5124 : 8 : {
5125 : 8 : switch (which_alternative)
5126 : : {
5127 : 4 : case 0:
5128 : 4 : case 1:
5129 : 4 : return "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}";
5130 : 8 : case 2:
5131 : 4 : case 3:
5132 : 4 : return "%vpextrw\t{%2, %1, %0|%0, %1, %2}";
5133 : 4 : case 4:
5134 : 4 : operands[2] = GEN_INT (INTVAL (operands[2]) * 2);
5135 : 4 : return "psrldq\t{%2, %0|%0, %2}";
5136 : 0 : case 5:
5137 : 0 : operands[2] = GEN_INT (INTVAL (operands[2]) * 2);
5138 : 0 : return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5139 : :
5140 : 0 : default:
5141 : 0 : gcc_unreachable ();
5142 : : }
5143 : : }
5144 : : [(set_attr "isa" "*,sse2,sse4_noavx,avx,noavx,avx")
5145 : : (set_attr "addr" "*,*,gpr16,*,*,*")
5146 : : (set_attr "mmx_isa" "native,*,*,*,*,*")
5147 : 0 : (set_attr "type" "mmxcvt,sselog1,sselog1,sselog1,sseishft1,sseishft1")
5148 : : (set_attr "length_immediate" "1")
5149 : : (set_attr "prefix" "orig,maybe_vex,maybe_vex,maybe_evex,orig,maybe_evex")
5150 : : (set_attr "mode" "DI,TI,TI,TI,TI,TI")])
5151 : :
5152 : : (define_insn "*mmx_pextrw_zext"
5153 : : [(set (match_operand:SWI48 0 "register_operand" "=r,r")
5154 : : (zero_extend:SWI48
5155 : : (vec_select:HI
5156 : : (match_operand:V4HI 1 "register_operand" "y,YW")
5157 : : (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
5158 : 2034 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5159 : 2034 : && (TARGET_SSE || TARGET_3DNOW_A)"
5160 : : "@
5161 : : pextrw\t{%2, %1, %k0|%k0, %1, %2}
5162 : : %vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
5163 : 1318 : [(set_attr "isa" "*,sse2")
5164 : 1318 : (set_attr "mmx_isa" "native,*")
5165 : : (set_attr "type" "mmxcvt,sselog1")
5166 : : (set_attr "length_immediate" "1")
5167 : : (set_attr "prefix" "orig,maybe_vex")
5168 : : (set_attr "mode" "DI,TI")])
5169 : :
5170 : : (define_insn "*mmx_pextrb"
5171 : : [(set (match_operand:QI 0 "nonimmediate_operand" "=jr,jm,r,m")
5172 : : (vec_select:QI
5173 : : (match_operand:V8QI 1 "register_operand" "YW,YW,YW,YW")
5174 : 0 : (parallel [(match_operand:SI 2 "const_0_to_7_operand")])))]
5175 : 3062 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
5176 : : "@
5177 : : pextrb\t{%2, %1, %k0|%k0, %1, %2}
5178 : : pextrb\t{%2, %1, %0|%0, %1, %2}
5179 : 18 : vpextrb\t{%2, %1, %k0|%k0, %1, %2}
5180 : 18 : vpextrb\t{%2, %1, %0|%0, %1, %2}"
5181 : 18 : [(set_attr "isa" "noavx,noavx,avx,avx")
5182 : 18 : (set_attr "addr" "*,gpr16,*,*")
5183 : : (set_attr "type" "sselog1")
5184 : : (set_attr "prefix_extra" "1")
5185 : : (set_attr "length_immediate" "1")
5186 : : (set_attr "prefix" "maybe_vex")
5187 : : (set_attr "mode" "TI")])
5188 : :
5189 : : (define_insn "*mmx_pextrb_zext"
5190 : : [(set (match_operand:SWI248 0 "register_operand" "=jr,r")
5191 : : (zero_extend:SWI248
5192 : : (vec_select:QI
5193 : : (match_operand:V8QI 1 "register_operand" "YW,YW")
5194 : : (parallel [(match_operand:SI 2 "const_0_to_7_operand")]))))]
5195 : 1230 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
5196 : : "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
5197 : : [(set_attr "isa" "noavx,avx")
5198 : : (set_attr "type" "sselog1")
5199 : 9 : (set_attr "prefix_extra" "1")
5200 : 9 : (set_attr "length_immediate" "1")
5201 : : (set_attr "prefix" "maybe_vex")
5202 : : (set_attr "mode" "TI")])
5203 : :
5204 : : (define_insn "mmx_pshufbv8qi3"
5205 : : [(set (match_operand:V8QI 0 "register_operand" "=x,Yw")
5206 : : (unspec:V8QI
5207 : : [(match_operand:V8QI 1 "register_operand" "0,Yw")
5208 : : (match_operand:V16QI 2 "vector_operand" "xja,Ywm")]
5209 : : UNSPEC_PSHUFB))]
5210 : : "TARGET_SSSE3 && TARGET_MMX_WITH_SSE"
5211 : 325 : "@
5212 : : pshufb\t{%2, %0|%0, %2}
5213 : : vpshufb\t{%2, %1, %0|%0, %1, %2}"
5214 : 1359 : [(set_attr "isa" "noavx,avx")
5215 : 1359 : (set_attr "addr" "gpr16,*")
5216 : 1359 : (set_attr "type" "sselog1")
5217 : 1359 : (set_attr "prefix_extra" "1")
5218 : 1359 : (set_attr "prefix" "orig,maybe_evex")
5219 : : (set_attr "btver2_decode" "vector")
5220 : : (set_attr "mode" "TI")])
5221 : :
5222 : : (define_insn "mmx_pshufbv4qi3"
5223 : : [(set (match_operand:V4QI 0 "register_operand" "=x,Yw")
5224 : : (unspec:V4QI
5225 : : [(match_operand:V4QI 1 "register_operand" "0,Yw")
5226 : : (match_operand:V16QI 2 "vector_operand" "xja,Ywm")]
5227 : : UNSPEC_PSHUFB))]
5228 : 1187 : "TARGET_SSSE3"
5229 : 172 : "@
5230 : : pshufb\t{%2, %0|%0, %2}
5231 : : vpshufb\t{%2, %1, %0|%0, %1, %2}"
5232 : : [(set_attr "isa" "noavx,avx")
5233 : : (set_attr "addr" "gpr16,*")
5234 : : (set_attr "type" "sselog1")
5235 : : (set_attr "prefix_extra" "1")
5236 : 28810 : (set_attr "prefix" "orig,maybe_evex")
5237 : 28810 : (set_attr "btver2_decode" "vector")
5238 : : (set_attr "mode" "TI")])
5239 : 5282 :
5240 : 5282 : (define_expand "mmx_pshufw"
5241 : 5282 : [(match_operand:V4HI 0 "register_operand")
5242 : : (match_operand:V4HI 1 "register_mmxmem_operand")
5243 : 5206 : (match_operand:SI 2 "const_int_operand")]
5244 : 5206 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5245 : 5206 : && (TARGET_SSE || TARGET_3DNOW_A)"
5246 : 75 : {
5247 : 4512 : int mask = INTVAL (operands[2]);
5248 : 4512 : emit_insn (gen_mmx_pshufwv4hi_1 (operands[0], operands[1],
5249 : 4437 : GEN_INT ((mask >> 0) & 3),
5250 : 6432 : GEN_INT ((mask >> 2) & 3),
5251 : 75 : GEN_INT ((mask >> 4) & 3),
5252 : 75 : GEN_INT ((mask >> 6) & 3)));
5253 : 75 : DONE;
5254 : : })
5255 : :
5256 : : (define_insn "mmx_pshufw<mode>_1"
5257 : : [(set (match_operand:V4FI_64 0 "register_operand" "=y,Yw")
5258 : : (vec_select:V4FI_64
5259 : : (match_operand:V4FI_64 1 "register_mmxmem_operand" "ym,Yw")
5260 : : (parallel [(match_operand 2 "const_0_to_3_operand")
5261 : : (match_operand 3 "const_0_to_3_operand")
5262 : : (match_operand 4 "const_0_to_3_operand")
5263 : : (match_operand 5 "const_0_to_3_operand")])))]
5264 : 261 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5265 : : && (TARGET_SSE || TARGET_3DNOW_A)"
5266 : 6379 : {
5267 : 1137 : int mask = 0;
5268 : 1137 : mask |= INTVAL (operands[2]) << 0;
5269 : 9923 : mask |= INTVAL (operands[3]) << 2;
5270 : 9923 : mask |= INTVAL (operands[4]) << 4;
5271 : 6926 : mask |= INTVAL (operands[5]) << 6;
5272 : 5789 : operands[2] = GEN_INT (mask);
5273 : 12643 :
5274 : 1137 : switch (which_alternative)
5275 : 11 : {
5276 : : case 0:
5277 : 11 : return "pshufw\t{%2, %1, %0|%0, %1, %2}";
5278 : 1148 : case 1:
5279 : 2105348 : return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
5280 : 0 : default:
5281 : 11 : gcc_unreachable ();
5282 : : }
5283 : 2104200 : }
5284 : 2104200 : [(set_attr "isa" "*,sse2")
5285 : 2104200 : (set_attr "mmx_isa" "native,*")
5286 : 2104200 : (set_attr "type" "mmxcvt,sselog1")
5287 : 2105949 : (set_attr "length_immediate" "1")
5288 : 2104200 : (set_attr "mode" "DI,TI")])
5289 : :
5290 : 2104200 : (define_insn "*mmx_pshufd_1"
5291 : 2104200 : [(set (match_operand:V2SI 0 "register_operand" "=Yv")
5292 : 2104200 : (vec_select:V2SI
5293 : 2104200 : (match_operand:V2SI 1 "register_operand" "Yv")
5294 : : (parallel [(match_operand 2 "const_0_to_1_operand")
5295 : 880706 : (match_operand 3 "const_0_to_1_operand")])))]
5296 : 2609 : "TARGET_MMX_WITH_SSE"
5297 : 881318 : {
5298 : 881318 : int mask = 0;
5299 : 612 : mask |= INTVAL (operands[2]) << 0;
5300 : 1088263 : mask |= INTVAL (operands[3]) << 2;
5301 : 1088263 : mask |= 2 << 4;
5302 : 626 : mask |= 3 << 6;
5303 : 626 : operands[2] = GEN_INT (mask);
5304 : 14 :
5305 : 98104 : return "%vpshufd\t{%2, %1, %0|%0, %1, %2}";
5306 : : }
5307 : 97492 : [(set_attr "type" "sselog1")
5308 : : (set_attr "prefix_data16" "1")
5309 : 1089 : (set_attr "length_immediate" "1")
5310 : 1089 : (set_attr "mode" "TI")])
5311 : :
5312 : : (define_insn "*mmx_pblendw64"
5313 : : [(set (match_operand:V4FI_64 0 "register_operand" "=Yr,*x,x")
5314 : : (vec_merge:V4FI_64
5315 : : (match_operand:V4FI_64 2 "register_operand" "Yr,*x,x")
5316 : : (match_operand:V4FI_64 1 "register_operand" "0,0,x")
5317 : : (match_operand:SI 3 "const_0_to_15_operand")))]
5318 : 3 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
5319 : : "@
5320 : : pblendw\t{%3, %2, %0|%0, %2, %3}
5321 : : pblendw\t{%3, %2, %0|%0, %2, %3}
5322 : 305 : vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
5323 : 305 : [(set_attr "isa" "noavx,noavx,avx")
5324 : 305 : (set_attr "type" "ssemov")
5325 : : (set_attr "prefix_extra" "1")
5326 : : (set_attr "length_immediate" "1")
5327 : : (set_attr "prefix" "orig,orig,vex")
5328 : : (set_attr "mode" "TI")])
5329 : :
5330 : : (define_insn "*mmx_pblendw32"
5331 : : [(set (match_operand:V2FI_32 0 "register_operand" "=Yr,*x,x")
5332 : : (vec_merge:V2FI_32
5333 : : (match_operand:V2FI_32 2 "register_operand" "Yr,*x,x")
5334 : : (match_operand:V2FI_32 1 "register_operand" "0,0,x")
5335 : : (match_operand:SI 3 "const_0_to_7_operand")))]
5336 : 1 : "TARGET_SSE4_1"
5337 : : "@
5338 : : pblendw\t{%3, %2, %0|%0, %2, %3}
5339 : : pblendw\t{%3, %2, %0|%0, %2, %3}
5340 : 0 : vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
5341 : 0 : [(set_attr "isa" "noavx,noavx,avx")
5342 : 0 : (set_attr "type" "ssemov")
5343 : 58496 : (set_attr "prefix_extra" "1")
5344 : : (set_attr "length_immediate" "1")
5345 : 22696 : (set_attr "prefix" "orig,orig,vex")
5346 : 22696 : (set_attr "mode" "TI")])
5347 : :
5348 : 1049 : ;; Optimize V2SImode load from memory, swapping the elements and
5349 : 1049 : ;; storing back into the memory into DImode rotate of the memory by 32.
5350 : 1049 : (define_split
5351 : : [(set (match_operand:V2SI 0 "memory_operand")
5352 : : (vec_select:V2SI (match_dup 0)
5353 : : (parallel [(const_int 1) (const_int 0)])))]
5354 : 11 : "TARGET_64BIT && (TARGET_READ_MODIFY_WRITE || optimize_insn_for_size_p ())"
5355 : 11 : [(set (match_dup 0)
5356 : : (rotate:DI (match_dup 0) (const_int 32)))]
5357 : 11 : "operands[0] = adjust_address (operands[0], DImode, 0);")
5358 : :
5359 : : (define_insn "mmx_pswapdv2si2"
5360 : 11 : [(set (match_operand:V2SI 0 "register_operand" "=y,Yv")
5361 : 11 : (vec_select:V2SI
5362 : 441892 : (match_operand:V2SI 1 "register_mmxmem_operand" "ym,Yv")
5363 : : (parallel [(const_int 1) (const_int 0)])))]
5364 : 269119 : "TARGET_3DNOW_A"
5365 : 345435 : "@
5366 : 215303 : pswapd\t{%1, %0|%0, %1}
5367 : 11 : %vpshufd\t{$0xe1, %1, %0|%0, %1, 0xe1}";
5368 : 633834 : [(set_attr "isa" "*,sse2")
5369 : 35750 : (set_attr "mmx_isa" "native,*")
5370 : 558327 : (set_attr "type" "mmxcvt,sselog1")
5371 : 145304 : (set_attr "prefix_extra" "1,*")
5372 : 522577 : (set_attr "length_immediate" "*,1")
5373 : 29622 : (set_attr "mode" "DI,TI")])
5374 : 29496 :
5375 : 390568 : (define_insn "*vec_dupv4hi"
5376 : 3 : [(set (match_operand:V4HI 0 "register_operand" "=y,Yw")
5377 : 129 : (vec_duplicate:V4HI
5378 : 29454 : (truncate:HI
5379 : 126 : (match_operand:SI 1 "register_operand" "0,Yw"))))]
5380 : 168 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5381 : 3013 : && (TARGET_SSE || TARGET_3DNOW_A)"
5382 : 126 : "@
5383 : 126 : pshufw\t{$0, %0, %0|%0, %0, 0}
5384 : : %vpshuflw\t{$0, %1, %0|%0, %1, 0}"
5385 : 237 : [(set_attr "isa" "*,sse2")
5386 : 237 : (set_attr "mmx_isa" "native,*")
5387 : 237 : (set_attr "type" "mmxcvt,sselog1")
5388 : 237 : (set_attr "length_immediate" "1")
5389 : : (set_attr "mode" "DI,TI")])
5390 : :
5391 : : (define_insn "*vec_dup<mode>"
5392 : : [(set (match_operand:V4FI_64 0 "register_operand" "=Yw")
5393 : : (vec_duplicate:V4FI_64
5394 : : (match_operand:<mmxscalarmode> 1 "register_operand" "Yw")))]
5395 : : "TARGET_MMX_WITH_SSE"
5396 : 107 : "%vpshuflw\t{$0, %1, %0|%0, %1, 0}"
5397 : : [(set_attr "isa" "sse2")
5398 : : (set_attr "type" "sselog1")
5399 : 5393 : (set_attr "length_immediate" "1")
5400 : 5393 : (set_attr "mode" "TI")])
5401 : 4271 :
5402 : 4271 : (define_insn "*vec_dupv2si"
5403 : 6835 : [(set (match_operand:V2SI 0 "register_operand" "=y,Yv")
5404 : : (vec_duplicate:V2SI
5405 : : (match_operand:SI 1 "register_operand" "0,Yv")))]
5406 : 2823 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
5407 : 1024 : "@
5408 : : punpckldq\t%0, %0
5409 : : %vpshufd\t{$0xe0, %1, %0|%0, %1, 0xe0}"
5410 : 13 : [(set_attr "isa" "*,sse2")
5411 : 13 : (set_attr "mmx_isa" "native,*")
5412 : 10 : (set_attr "type" "mmxcvt,sselog1")
5413 : 10 : (set_attr "prefix_data16" "*,1")
5414 : 13 : (set_attr "length_immediate" "*,1")
5415 : : (set_attr "mode" "DI,TI")])
5416 : :
5417 : : (define_insn "*mmx_concatv2si"
5418 : : [(set (match_operand:V2SI 0 "register_operand" "=y,y")
5419 : : (vec_concat:V2SI
5420 : : (match_operand:SI 1 "nonimmediate_operand" " 0,rm")
5421 : : (match_operand:SI 2 "nonimm_or_0_operand" "ym,C")))]
5422 : 202589 : "TARGET_MMX && !TARGET_SSE"
5423 : : "@
5424 : 202589 : punpckldq\t{%2, %0|%0, %2}
5425 : : movd\t{%1, %0|%0, %1}"
5426 : : [(set_attr "type" "mmxcvt,mmxmov")
5427 : : (set_attr "mode" "DI")])
5428 : :
5429 : : (define_expand "vec_setv2si"
5430 : : [(match_operand:V2SI 0 "register_operand")
5431 : : (match_operand:SI 1 "register_operand")
5432 : : (match_operand 2 "vec_setm_mmx_operand")]
5433 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
5434 : 126 : {
5435 : 126 : if (CONST_INT_P (operands[2]))
5436 : 124 : ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
5437 : 124 : INTVAL (operands[2]));
5438 : : else
5439 : 2 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
5440 : 126 : DONE;
5441 : : })
5442 : :
5443 : : ;; Avoid combining registers from different units in a single alternative,
5444 : : ;; see comment above inline_secondary_memory_needed function in i386.cc
5445 : : (define_insn_and_split "*vec_extractv2si_0"
5446 : : [(set (match_operand:SI 0 "nonimmediate_operand" "=x,m,y, m,r,r")
5447 : : (vec_select:SI
5448 : : (match_operand:V2SI 1 "nonimmediate_operand" "xm,x,ym,y,m,x")
5449 : : (parallel [(const_int 0)])))]
5450 : 8394 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5451 : 8394 : && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5452 : : "#"
5453 : 3016 : "&& reload_completed"
5454 : 1503 : [(set (match_dup 0) (match_dup 1))]
5455 : 161035 : "operands[1] = gen_lowpart (SImode, operands[1]);"
5456 : 159532 : [(set_attr "isa" "*,*,*,*,*,sse2")
5457 : 159532 : (set_attr "mmx_isa" "*,*,native,native,*,*")
5458 : 121315 : (set (attr "preferred_for_speed")
5459 : 121315 : (cond [(eq_attr "alternative" "5")
5460 : 1503 : (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
5461 : 1503 : ]
5462 : 1503 : (symbol_ref "true")))])
5463 : :
5464 : 1503 : (define_insn "*vec_extractv2si_0_zext_sse4"
5465 : 1503 : [(set (match_operand:DI 0 "register_operand" "=r,x")
5466 : 3006 : (zero_extend:DI
5467 : 1503 : (vec_select:SI
5468 : 0 : (match_operand:V2SI 1 "register_operand" "x,x")
5469 : 1503 : (parallel [(const_int 0)]))))]
5470 : 780 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE4_1"
5471 : : "#"
5472 : 945 : [(set_attr "isa" "x64,*")
5473 : : (set (attr "preferred_for_speed")
5474 : 165 : (cond [(eq_attr "alternative" "0")
5475 : 165 : (symbol_ref "TARGET_INTER_UNIT_MOVES_FROM_VEC")
5476 : 165 : ]
5477 : 165 : (symbol_ref "true")))])
5478 : 0 :
5479 : 165 : (define_insn "*vec_extractv2si_0_zext"
5480 : : [(set (match_operand:DI 0 "register_operand" "=r")
5481 : : (zero_extend:DI
5482 : : (vec_select:SI
5483 : : (match_operand:V2SI 1 "register_operand" "x")
5484 : : (parallel [(const_int 0)]))))]
5485 : 0 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5486 : 780 : && TARGET_64BIT && TARGET_SSE2 && TARGET_INTER_UNIT_MOVES_FROM_VEC"
5487 : : "#")
5488 : :
5489 : : (define_split
5490 : : [(set (match_operand:DI 0 "register_operand")
5491 : 2765 : (zero_extend:DI
5492 : 2765 : (vec_select:SI
5493 : : (match_operand:V2SI 1 "register_operand")
5494 : 2597 : (parallel [(const_int 0)]))))]
5495 : 0 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5496 : 330 : && TARGET_SSE2 && reload_completed"
5497 : 165 : [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
5498 : 165 : "operands[1] = gen_lowpart (SImode, operands[1]);")
5499 : :
5500 : 1330 : ;; Avoid combining registers from different units in a single alternative,
5501 : 1495 : ;; see comment above inline_secondary_memory_needed function in i386.cc
5502 : 1495 : (define_insn "*vec_extractv2si_1"
5503 : 165 : [(set (match_operand:SI 0 "nonimmediate_operand" "=y,jrjm,rm,x,x,y,x,r")
5504 : 165 : (vec_select:SI
5505 : 165 : (match_operand:V2SI 1 "nonimmediate_operand" " 0,x, x ,x,0,o,o,o")
5506 : : (parallel [(const_int 1)])))]
5507 : 3384 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5508 : 3549 : && !(MEM_P (operands[0]) && MEM_P (operands[1]))"
5509 : 165 : "@
5510 : 165 : punpckhdq\t%0, %0
5511 : : pextrd\t{$1, %1, %0|%0, %1, 1}
5512 : 67167 : vpextrd\t{$1, %1, %0|%0, %1, 1}
5513 : 67167 : %vpshufd\t{$0xe5, %1, %0|%0, %1, 0xe5}
5514 : 63436 : shufps\t{$0xe5, %0, %0|%0, %0, 0xe5}
5515 : 63436 : #
5516 : 129171 : #
5517 : : #"
5518 : 3 : [(set_attr "isa" "*,sse4_noavx,avx,sse2,noavx,*,*,*")
5519 : 3 : (set (attr "addr")
5520 : 3 : (if_then_else (eq_attr "alternative" "1")
5521 : 3 : (const_string "gpr16")
5522 : 0 : (const_string "*")))
5523 : 3 : (set_attr "mmx_isa" "native,*,*,*,*,native,*,*")
5524 : : (set_attr "type" "mmxcvt,ssemov,ssemov,sseshuf1,sseshuf1,mmxmov,ssemov,imov")
5525 : : (set (attr "length_immediate")
5526 : : (if_then_else (eq_attr "alternative" "1,2,3,4")
5527 : : (const_string "1")
5528 : : (const_string "*")))
5529 : : (set_attr "prefix" "orig,orig,maybe_evex,maybe_vex,orig,orig,orig,orig")
5530 : : (set_attr "mode" "DI,TI,TI,TI,V4SF,SI,SI,SI")])
5531 : :
5532 : : (define_split
5533 : : [(set (match_operand:SI 0 "register_operand")
5534 : : (vec_select:SI
5535 : : (match_operand:V2SI 1 "memory_operand")
5536 : : (parallel [(const_int 1)])))]
5537 : 3 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && reload_completed"
5538 : 3 : [(set (match_dup 0) (match_dup 1))]
5539 : 3 : "operands[1] = adjust_address (operands[1], SImode, 4);")
5540 : :
5541 : 3201 : (define_insn "*vec_extractv2si_1_zext"
5542 : 3204 : [(set (match_operand:DI 0 "register_operand" "=jr,r")
5543 : 2154 : (zero_extend:DI
5544 : 2154 : (vec_select:SI
5545 : 3226 : (match_operand:V2SI 1 "register_operand" "x,x")
5546 : 3 : (parallel [(const_int 1)]))))]
5547 : 640 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
5548 : 643 : && TARGET_64BIT && TARGET_SSE4_1"
5549 : 3 : "%vpextrd\t{$1, %1, %k0|%k0, %1, 1}"
5550 : 3 : [(set_attr "isa" "noavx,avx")
5551 : : (set_attr "type" "sselog1")
5552 : : (set_attr "prefix_extra" "1")
5553 : : (set_attr "length_immediate" "1")
5554 : : (set_attr "prefix" "maybe_vex")
5555 : 2137 : (set_attr "mode" "TI")])
5556 : 2137 :
5557 : : (define_insn_and_split "*vec_extractv2si_zext_mem"
5558 : 805 : [(set (match_operand:DI 0 "register_operand" "=y,x,r")
5559 : 805 : (zero_extend:DI
5560 : 0 : (vec_select:SI
5561 : 805 : (match_operand:V2SI 1 "memory_operand" "o,o,o")
5562 : 0 : (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))))]
5563 : 0 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_64BIT"
5564 : 805 : "#"
5565 : 0 : "&& reload_completed"
5566 : 165 : [(set (match_dup 0) (zero_extend:DI (match_dup 1)))]
5567 : 0 : {
5568 : 1321 : operands[1] = adjust_address (operands[1], SImode, INTVAL (operands[2]) * 4);
5569 : 720 : }
5570 : 2041 : [(set_attr "isa" "*,sse2,*")
5571 : 1321 : (set_attr "mmx_isa" "native,*,*")])
5572 : 720 :
5573 : 0 : (define_expand "vec_extractv2sisi"
5574 : 0 : [(match_operand:SI 0 "register_operand")
5575 : 0 : (match_operand:V2SI 1 "register_operand")
5576 : 0 : (match_operand 2 "const_int_operand")]
5577 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
5578 : 10277 : {
5579 : 0 : ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
5580 : 0 : operands[1], INTVAL (operands[2]));
5581 : 10277 : DONE;
5582 : : })
5583 : :
5584 : : (define_expand "vec_initv2sisi"
5585 : : [(match_operand:V2SI 0 "register_operand")
5586 : 10277 : (match_operand 1)]
5587 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
5588 : 34972 : {
5589 : 34972 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
5590 : 10277 : operands[1]);
5591 : 45249 : DONE;
5592 : 10277 : })
5593 : 10277 :
5594 : 10277 : (define_expand "vec_set<mode>"
5595 : 10277 : [(match_operand:V4FI_64 0 "register_operand")
5596 : 10277 : (match_operand:<mmxscalarmode> 1 "register_operand")
5597 : : (match_operand 2 "vec_setm_mmx_operand")]
5598 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
5599 : 9 : {
5600 : 9 : if (CONST_INT_P (operands[2]))
5601 : 6 : ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
5602 : 6 : INTVAL (operands[2]));
5603 : : else
5604 : 3 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
5605 : 9 : DONE;
5606 : 34972 : })
5607 : 34972 :
5608 : 34972 : (define_expand "vec_extract<mode><mmxscalarmodelower>"
5609 : 34974 : [(match_operand:<mmxscalarmode> 0 "register_operand")
5610 : 34972 : (match_operand:V4FI_64 1 "register_operand")
5611 : : (match_operand 2 "const_int_operand")]
5612 : : "TARGET_MMX || TARGET_MMX_WITH_SSE"
5613 : 592 : {
5614 : 2 : ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
5615 : 592 : operands[1], INTVAL (operands[2]));
5616 : 590 : DONE;
5617 : 2 : })
5618 : 2 :
5619 : 2 : (define_expand "vec_initv4hihi"
5620 : : [(match_operand:V4HI 0 "register_operand")
5621 : : (match_operand 1)]
5622 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
5623 : 3702 : {
5624 : 3702 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
5625 : : operands[1]);
5626 : 3718 : DONE;
5627 : : })
5628 : :
5629 : : (define_expand "vec_init<mode><mmxscalarmodelower>"
5630 : 16 : [(match_operand:V4F_64 0 "register_operand")
5631 : 16 : (match_operand 1)]
5632 : 16 : "TARGET_MMX_WITH_SSE"
5633 : 35 : {
5634 : 35 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
5635 : 16 : operands[1]);
5636 : 35 : DONE;
5637 : 4283 : })
5638 : :
5639 : : (define_expand "vec_setv8qi"
5640 : 3702 : [(match_operand:V8QI 0 "register_operand")
5641 : 3702 : (match_operand:QI 1 "register_operand")
5642 : 581 : (match_operand 2 "vec_setm_mmx_operand")]
5643 : 4283 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
5644 : 4300 : {
5645 : 3702 : if (CONST_INT_P (operands[2]))
5646 : 581 : ix86_expand_vector_set (TARGET_MMX_WITH_SSE, operands[0], operands[1],
5647 : 581 : INTVAL (operands[2]));
5648 : 15 : else
5649 : 2 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
5650 : 2 : DONE;
5651 : 15 : })
5652 : 15 :
5653 : : (define_expand "vec_extractv8qiqi"
5654 : 6 : [(match_operand:QI 0 "register_operand")
5655 : : (match_operand:V8QI 1 "register_operand")
5656 : : (match_operand 2 "const_int_operand")]
5657 : 4 : "TARGET_SSE4_1 && TARGET_MMX_WITH_SSE"
5658 : 4 : {
5659 : 2 : ix86_expand_vector_extract (TARGET_MMX_WITH_SSE, operands[0],
5660 : 500 : operands[1], INTVAL (operands[2]));
5661 : 494 : DONE;
5662 : 4 : })
5663 : 2 :
5664 : 2 : (define_expand "vec_initv8qiqi"
5665 : : [(match_operand:V8QI 0 "register_operand")
5666 : : (match_operand 1)]
5667 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && TARGET_SSE"
5668 : 386 : {
5669 : 386 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
5670 : : operands[1]);
5671 : 386 : DONE;
5672 : : })
5673 : :
5674 : : (define_insn "*pinsrw"
5675 : 494 : [(set (match_operand:V2FI_32 0 "register_operand" "=x,YW,&x")
5676 : 494 : (vec_merge:V2FI_32
5677 : 494 : (vec_duplicate:V2FI_32
5678 : 494 : (match_operand:<mmxscalarmode> 2 "nonimmediate_operand" "rm,rm,x"))
5679 : 494 : (match_operand:V2FI_32 1 "register_operand" "0,YW,x")
5680 : 494 : (match_operand:SI 3 "const_int_operand")))]
5681 : 500 : "TARGET_SSE2
5682 : 456 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5683 : 6 : < GET_MODE_NUNITS (V2HImode))"
5684 : 124 : {
5685 : 402 : operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
5686 : 402 : switch (which_alternative)
5687 : 558 : {
5688 : 558 : case 2:
5689 : 622 : return "#";
5690 : 386 : case 1:
5691 : 0 : if (MEM_P (operands[2]))
5692 : 1 : return "vpinsrw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5693 : 1 : else
5694 : 1 : return "vpinsrw\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
5695 : 17 : case 0:
5696 : 17 : if (MEM_P (operands[2]))
5697 : 1 : return "pinsrw\t{%3, %2, %0|%0, %2, %3}";
5698 : 0 : else
5699 : 14 : return "pinsrw\t{%3, %k2, %0|%0, %k2, %3}";
5700 : 0 : default:
5701 : 0 : gcc_unreachable ();
5702 : : }
5703 : : }
5704 : : [(set_attr "isa" "noavx,avx,sse4")
5705 : : (set_attr "type" "sselog")
5706 : : (set_attr "length_immediate" "1")
5707 : 16 : (set_attr "mode" "TI")])
5708 : :
5709 : : ;; For TARGET_SSE2, implement insert from XMM reg with PSHULFW + PBLENDW.
5710 : : (define_split
5711 : : [(set (match_operand:V2FI_32 0 "sse_reg_operand")
5712 : : (vec_merge:V2FI_32
5713 : : (vec_duplicate:V2FI_32
5714 : : (match_operand:<mmxscalarmode> 2 "sse_reg_operand"))
5715 : : (match_operand:V2FI_32 1 "sse_reg_operand")
5716 : : (match_operand:SI 3 "const_int_operand")))]
5717 : 1 : "TARGET_SSE4_1 && reload_completed
5718 : 1 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5719 : 1 : < GET_MODE_NUNITS (<MODE>mode))"
5720 : 70 : [(set (match_dup 0)
5721 : 1 : (vec_duplicate:V2FI_32 (match_dup 2)))
5722 : : (set (match_dup 0)
5723 : 69 : (vec_merge:V2FI_32 (match_dup 1) (match_dup 0) (match_dup 3)))]
5724 : 70 : "operands[3] = GEN_INT (~INTVAL (operands[3]) & 0x3);")
5725 : 69 :
5726 : :
5727 : 1 : (define_insn "*pinsrb"
5728 : 1 : [(set (match_operand:V4QI 0 "register_operand" "=x,YW")
5729 : 1290326 : (vec_merge:V4QI
5730 : 1 : (vec_duplicate:V4QI
5731 : 1290326 : (match_operand:QI 2 "nonimmediate_operand" "jrjm,rm"))
5732 : 1290326 : (match_operand:V4QI 1 "register_operand" "0,YW")
5733 : 1290326 : (match_operand:SI 3 "const_int_operand")))]
5734 : 1 : "TARGET_SSE4_1
5735 : 1 : && ((unsigned) exact_log2 (INTVAL (operands[3]))
5736 : 0 : < GET_MODE_NUNITS (V4QImode))"
5737 : 0 : {
5738 : 1290326 : operands[3] = GEN_INT (exact_log2 (INTVAL (operands[3])));
5739 : 1290325 : switch (which_alternative)
5740 : : {
5741 : 25858 : case 1:
5742 : 25858 : if (MEM_P (operands[2]))
5743 : 1 : return "vpinsrb\t{%3, %2, %1, %0|%0, %1, %2, %3}";
5744 : 4040 : else
5745 : 4040 : return "vpinsrb\t{%3, %k2, %1, %0|%0, %1, %k2, %3}";
5746 : 1713 : case 0:
5747 : 27 : if (MEM_P (operands[2]))
5748 : 27 : return "pinsrb\t{%3, %2, %0|%0, %2, %3}";
5749 : 1713 : else
5750 : 1715 : return "pinsrb\t{%3, %k2, %0|%0, %k2, %3}";
5751 : 3426 : default:
5752 : 0 : gcc_unreachable ();
5753 : 1713 : }
5754 : 1715 : }
5755 : 1715 : [(set_attr "isa" "noavx,avx")
5756 : 2 : (set_attr "addr" "gpr16,*")
5757 : 1663 : (set_attr "type" "sselog")
5758 : 0 : (set_attr "prefix_extra" "1")
5759 : 330 : (set_attr "length_immediate" "1")
5760 : 330 : (set_attr "prefix" "orig,vex")
5761 : 330 : (set_attr "mode" "TI")])
5762 : :
5763 : : (define_insn "*pextrw"
5764 : 1 : [(set (match_operand:HI 0 "register_sse4nonimm_operand" "=r,jm,m")
5765 : : (vec_select:HI
5766 : : (match_operand:V2HI 1 "register_operand" "YW,YW,YW")
5767 : : (parallel [(match_operand:SI 2 "const_0_to_1_operand")])))]
5768 : 337 : "TARGET_SSE2"
5769 : : "@
5770 : : %vpextrw\t{%2, %1, %k0|%k0, %1, %2}
5771 : : pextrw\t{%2, %1, %0|%0, %1, %2}
5772 : 30663 : vpextrw\t{%2, %1, %0|%0, %1, %2}"
5773 : 30663 : [(set_attr "isa" "*,sse4_noavx,avx")
5774 : 17168 : (set_attr "addr" "*,gpr16,*")
5775 : 47831 : (set_attr "type" "sselog1")
5776 : : (set_attr "length_immediate" "1")
5777 : : (set_attr "prefix" "maybe_vex")
5778 : : (set_attr "mode" "TI")])
5779 : :
5780 : : (define_insn "*pextrw<mode>"
5781 : : [(set (match_operand:<mmxscalarmode> 0 "register_sse4nonimm_operand" "=?r,jm,m,x,Yw")
5782 : : (vec_select:<mmxscalarmode>
5783 : : (match_operand:V2F_32 1 "register_operand" "YW,YW,YW,0,YW")
5784 : : (parallel [(match_operand:SI 2 "const_0_to_1_operand")])))]
5785 : 4 : "TARGET_SSE2"
5786 : 1 : {
5787 : 1 : switch (which_alternative)
5788 : : {
5789 : 1920 : case 0:
5790 : 1920 : return "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}";
5791 : 1781 : case 1:
5792 : 3701 : return "pextrw\t{%2, %1, %0|%0, %1, %2}";
5793 : 0 : case 2:
5794 : 0 : return "vpextrw\t{%2, %1, %0|%0, %1, %2}";
5795 : 1 : case 3:
5796 : 1 : operands[2] = GEN_INT (INTVAL (operands[2]) * 2);
5797 : 1 : return "psrldq\t{%2, %0|%0, %2}";
5798 : 0 : case 4:
5799 : 0 : operands[2] = GEN_INT (INTVAL (operands[2]) * 2);
5800 : 0 : return "vpsrldq\t{%2, %1, %0|%0, %1, %2}";
5801 : :
5802 : 0 : default:
5803 : 0 : gcc_unreachable ();
5804 : : }
5805 : : }
5806 : : [(set_attr "isa" "*,sse4_noavx,avx,noavx,avx")
5807 : : (set_attr "addr" "*,gpr16,*,*,*")
5808 : : (set_attr "type" "sselog1,sselog1,sselog1,sseishft1,sseishft1")
5809 : 0 : (set_attr "length_immediate" "1")
5810 : : (set_attr "prefix" "maybe_vex,orig,maybe_evex,orig,maybe_evex")
5811 : : (set_attr "mode" "TI")])
5812 : :
5813 : : (define_insn "*pextrw_zext"
5814 : : [(set (match_operand:SWI48 0 "register_operand" "=r")
5815 : : (zero_extend:SWI48
5816 : 0 : (vec_select:HI
5817 : : (match_operand:V2HI 1 "register_operand" "YW")
5818 : : (parallel [(match_operand:SI 2 "const_0_to_1_operand")]))))]
5819 : 1318 : "TARGET_SSE2"
5820 : : "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
5821 : : [(set_attr "type" "sselog1")
5822 : : (set_attr "length_immediate" "1")
5823 : 14182 : (set_attr "prefix" "maybe_vex")
5824 : 14182 : (set_attr "mode" "TI")])
5825 : :
5826 : : (define_insn "*pextrb"
5827 : : [(set (match_operand:QI 0 "nonimmediate_operand" "=jr,jm,r,m")
5828 : : (vec_select:QI
5829 : : (match_operand:V4QI 1 "register_operand" "YW,YW,YW,YW")
5830 : : (parallel [(match_operand:SI 2 "const_0_to_3_operand")])))]
5831 : 18 : "TARGET_SSE4_1"
5832 : : "@
5833 : : pextrb\t{%2, %1, %k0|%k0, %1, %2}
5834 : : pextrb\t{%2, %1, %0|%0, %1, %2}
5835 : : vpextrb\t{%2, %1, %k0|%k0, %1, %2}
5836 : : vpextrb\t{%2, %1, %0|%0, %1, %2}"
5837 : : [(set_attr "isa" "noavx,noavx,avx,avx")
5838 : : (set_attr "addr" "*,gpr16,*,*")
5839 : 5566 : (set_attr "type" "sselog1")
5840 : 5566 : (set_attr "prefix_extra" "1")
5841 : 3015 : (set_attr "length_immediate" "1")
5842 : 8581 : (set_attr "prefix" "maybe_vex")
5843 : : (set_attr "mode" "TI")])
5844 : :
5845 : : (define_insn "*pextrb_zext"
5846 : : [(set (match_operand:SWI248 0 "register_operand" "=jr,r")
5847 : : (zero_extend:SWI248
5848 : : (vec_select:QI
5849 : : (match_operand:V4QI 1 "register_operand" "YW,YW")
5850 : : (parallel [(match_operand:SI 2 "const_0_to_3_operand")]))))]
5851 : 9 : "TARGET_SSE4_1"
5852 : : "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
5853 : : [(set_attr "isa" "noavx,avx")
5854 : : (set_attr "type" "sselog1")
5855 : 5723 : (set_attr "prefix_extra" "1")
5856 : 5723 : (set_attr "length_immediate" "1")
5857 : : (set_attr "prefix" "maybe_vex")
5858 : : (set_attr "mode" "TI")])
5859 : :
5860 : : (define_expand "vec_set<mode>"
5861 : : [(match_operand:V2FI_32 0 "register_operand")
5862 : : (match_operand:<mmxscalarmode> 1 "register_operand")
5863 : : (match_operand 2 "vec_setm_sse41_operand")]
5864 : : "TARGET_SSE2"
5865 : 7 : {
5866 : 2 : if (CONST_INT_P (operands[2]))
5867 : 4 : ix86_expand_vector_set (false, operands[0], operands[1],
5868 : 4 : INTVAL (operands[2]));
5869 : : else
5870 : 3 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
5871 : 7 : DONE;
5872 : : })
5873 : :
5874 : : (define_expand "vec_extract<mode><mmxscalarmodelower>"
5875 : : [(match_operand:<mmxscalarmode> 0 "register_operand")
5876 : : (match_operand:V2FI_32 1 "register_operand")
5877 : : (match_operand 2 "const_int_operand")]
5878 : : "TARGET_SSE2"
5879 : 319 : {
5880 : 319 : ix86_expand_vector_extract (false, operands[0],
5881 : 319 : operands[1], INTVAL (operands[2]));
5882 : 319 : DONE;
5883 : : })
5884 : :
5885 : : (define_expand "vec_setv4qi"
5886 : : [(match_operand:V4QI 0 "register_operand")
5887 : : (match_operand:QI 1 "register_operand")
5888 : : (match_operand 2 "vec_setm_mmx_operand")]
5889 : : "TARGET_SSE4_1"
5890 : 2 : {
5891 : 2 : if (CONST_INT_P (operands[2]))
5892 : 6 : ix86_expand_vector_set (false, operands[0], operands[1],
5893 : 0 : INTVAL (operands[2]));
5894 : : else
5895 : 2 : ix86_expand_vector_set_var (operands[0], operands[1], operands[2]);
5896 : 2 : DONE;
5897 : 6 : })
5898 : 6 :
5899 : 6 : (define_expand "vec_extractv4qiqi"
5900 : 6 : [(match_operand:QI 0 "register_operand")
5901 : 6 : (match_operand:V4QI 1 "register_operand")
5902 : 6 : (match_operand 2 "const_int_operand")]
5903 : 320 : "TARGET_SSE4_1"
5904 : 28 : {
5905 : 28 : ix86_expand_vector_extract (false, operands[0],
5906 : 28 : operands[1], INTVAL (operands[2]));
5907 : 28 : DONE;
5908 : 320 : })
5909 : 320 :
5910 : 320 : (define_insn_and_split "*punpckwd"
5911 : 320 : [(set (match_operand:V2FI_32 0 "register_operand" "=x,Yw")
5912 : 320 : (vec_select:V2FI_32
5913 : 320 : (vec_concat:<mmxdoublevecmode>
5914 : : (match_operand:V2FI_32 1 "register_operand" "0,Yw")
5915 : : (match_operand:V2FI_32 2 "register_operand" "x,Yw"))
5916 : : (parallel [(match_operand 3 "const_0_to_3_operand")
5917 : 28 : (match_operand 4 "const_0_to_3_operand")])))]
5918 : 0 : "TARGET_SSE2"
5919 : : "#"
5920 : 0 : "&& reload_completed"
5921 : 28 : [(set (match_dup 5)
5922 : 85 : (vec_select:<mmxxmmmode>
5923 : 237 : (match_dup 5)
5924 : 142 : (parallel [(match_dup 3) (match_dup 4)
5925 : 142 : (const_int 2) (const_int 3)
5926 : 2982 : (const_int 4) (const_int 5)
5927 : 2982 : (const_int 6) (const_int 7)])))]
5928 : 869 : {
5929 : 879 : rtx dest = lowpart_subreg (<mmxxmmmode>mode, operands[0], <MODE>mode);
5930 : 57 : rtx op1 = lowpart_subreg (<mmxxmmmode>mode, operands[1], <MODE>mode);
5931 : 57 : rtx op2 = lowpart_subreg (<mmxxmmmode>mode, operands[2], <MODE>mode);
5932 : 0 :
5933 : 57 : emit_insn (gen_vec_interleave_low<mmxxmmmodelower> (dest, op1, op2));
5934 : 0 :
5935 : 57 : static const int map[4] = { 0, 2, 1, 3 };
5936 : 0 :
5937 : 57 : int sel0 = map[INTVAL (operands[3])];
5938 : 0 : int sel1 = map[INTVAL (operands[4])];
5939 : 0 :
5940 : 57 : if (sel0 == 0 && sel1 == 1)
5941 : 13 : DONE;
5942 : :
5943 : 44 : operands[3] = GEN_INT (sel0);
5944 : 44 : operands[4] = GEN_INT (sel1);
5945 : 44 : operands[5] = dest;
5946 : : }
5947 : : [(set_attr "isa" "noavx,avx")
5948 : : (set_attr "type" "sselog")
5949 : 44 : (set_attr "mode" "TI")])
5950 : 44 :
5951 : 44 : (define_insn "*pshufw<mode>_1"
5952 : 44 : [(set (match_operand:V2FI_32 0 "register_operand" "=Yw")
5953 : 44 : (vec_select:V2FI_32
5954 : 44 : (match_operand:V2FI_32 1 "register_operand" "Yw")
5955 : 44 : (parallel [(match_operand 2 "const_0_to_1_operand")
5956 : 44 : (match_operand 3 "const_0_to_1_operand")])))]
5957 : 44 : "TARGET_SSE2"
5958 : 101 : {
5959 : 101 : int mask = 0;
5960 : 101 : mask |= INTVAL (operands[2]) << 0;
5961 : 665 : mask |= INTVAL (operands[3]) << 2;
5962 : 621 : mask |= 2 << 4;
5963 : 561 : mask |= 3 << 6;
5964 : 504 : operands[2] = GEN_INT (mask);
5965 : 819 :
5966 : 76373 : return "%vpshuflw\t{%2, %1, %0|%0, %1, %2}";
5967 : 14188 : }
5968 : 9226 : [(set_attr "type" "sselog1")
5969 : 993 : (set_attr "length_immediate" "1")
5970 : 993 : (set_attr "mode" "TI")])
5971 : 76415 :
5972 : : (define_insn "*vec_dupv2hi"
5973 : : [(set (match_operand:V2HI 0 "register_operand" "=Yw")
5974 : 44 : (vec_duplicate:V2HI
5975 : 44 : (truncate:HI
5976 : 44 : (match_operand:SI 1 "register_operand" "Yw"))))]
5977 : 237 : "TARGET_SSE2"
5978 : : "%vpshuflw\t{$0, %1, %0|%0, %1, 0}"
5979 : : [(set_attr "type" "sselog1")
5980 : : (set_attr "length_immediate" "1")
5981 : 23 : (set_attr "mode" "TI")])
5982 : 57 :
5983 : : (define_insn "*vec_dup<mode>"
5984 : 80 : [(set (match_operand:V2FI_32 0 "register_operand" "=Yw")
5985 : 23 : (vec_duplicate:V2FI_32
5986 : 80 : (match_operand:<mmxscalarmode> 1 "register_operand" "Yw")))]
5987 : 90 : "TARGET_SSE2"
5988 : 274 : "%vpshuflw\t{$0, %1, %0|%0, %1, 0}"
5989 : 80 : [(set_attr "type" "sselog1")
5990 : 57 : (set_attr "length_immediate" "1")
5991 : 2062 : (set_attr "mode" "TI")])
5992 : 626 :
5993 : 496 : (define_expand "vec_init<mode><mmxscalarmodelower>"
5994 : 439 : [(match_operand:V2FI_32 0 "register_operand")
5995 : 1061 : (match_operand 1)]
5996 : 641 : "TARGET_SSE2"
5997 : 1959 : {
5998 : 2043 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
5999 : 2020 : operands[1]);
6000 : 1221 : DONE;
6001 : 1379 : })
6002 : 641 :
6003 : 1379 : (define_expand "vec_initv4qiqi"
6004 : 1379 : [(match_operand:V2HI 0 "register_operand")
6005 : 404 : (match_operand 1)]
6006 : 404 : "TARGET_SSE2"
6007 : 6099 : {
6008 : 5893 : ix86_expand_vector_init (TARGET_MMX_WITH_SSE, operands[0],
6009 : 644 : operands[1]);
6010 : 5249 : DONE;
6011 : 114 : })
6012 : 228 :
6013 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6014 : : ;;
6015 : : ;; Miscellaneous
6016 : : ;;
6017 : : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6018 : 5806 :
6019 : : (define_expand "mmx_uavg<mode>3"
6020 : : [(set (match_operand:MMXMODE12 0 "register_operand")
6021 : 5806 : (truncate:MMXMODE12
6022 : 5806 : (lshiftrt:<mmxdoublemode>
6023 : 5806 : (plus:<mmxdoublemode>
6024 : 5806 : (plus:<mmxdoublemode>
6025 : 5806 : (zero_extend:<mmxdoublemode>
6026 : 5806 : (match_operand:MMXMODE12 1 "register_mmxmem_operand"))
6027 : : (zero_extend:<mmxdoublemode>
6028 : 39 : (match_operand:MMXMODE12 2 "register_mmxmem_operand")))
6029 : : (match_dup 3))
6030 : : (const_int 1))))]
6031 : : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
6032 : 39 : && (TARGET_SSE || TARGET_3DNOW)"
6033 : 100 : {
6034 : 39 : operands[3] = CONST1_RTX(<mmxdoublemode>mode);
6035 : 61 : ix86_fixup_binary_operands_no_copy (PLUS, <MODE>mode, operands);
6036 : 39 : })
6037 : 39 :
6038 : 39 : (define_insn "*mmx_uavgv8qi3"
6039 : 39 : [(set (match_operand:V8QI 0 "register_operand" "=y,x,Yw")
6040 : 61 : (truncate:V8QI
6041 : 61 : (lshiftrt:V8HI
6042 : 61 : (plus:V8HI
6043 : 61 : (plus:V8HI
6044 : 61 : (zero_extend:V8HI
6045 : 61 : (match_operand:V8QI 1 "register_mmxmem_operand" "%0,0,Yw"))
6046 : 61 : (zero_extend:V8HI
6047 : : (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yw")))
6048 : 61 : (const_vector:V8HI [(const_int 1) (const_int 1)
6049 : : (const_int 1) (const_int 1)
6050 : : (const_int 1) (const_int 1)
6051 : : (const_int 1) (const_int 1)]))
6052 : : (const_int 1))))]
6053 : 129 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
6054 : 129 : && (TARGET_SSE || TARGET_3DNOW)
6055 : 129 : && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
6056 : 157 : {
6057 : 42 : switch (which_alternative)
6058 : : {
6059 : 157 : case 2:
6060 : 157 : return "vpavgb\t{%2, %1, %0|%0, %1, %2}";
6061 : 173 : case 1:
6062 : 16 : case 0:
6063 : 96 : /* These two instructions have the same operation, but their encoding
6064 : 96 : is different. Prefer the one that is de facto standard. */
6065 : 16 : if (TARGET_SSE || TARGET_3DNOW_A)
6066 : 121 : return "pavgb\t{%2, %0|%0, %2}";
6067 : 96 : else
6068 : 0 : return "pavgusb\t{%2, %0|%0, %2}";
6069 : 96 : default:
6070 : 121 : gcc_unreachable ();
6071 : 25 : }
6072 : 121 : }
6073 : 25 : [(set_attr "isa" "*,sse2_noavx,avx")
6074 : 109 : (set_attr "mmx_isa" "native,*,*")
6075 : 109 : (set_attr "type" "mmxshft,sseiadd,sseiadd")
6076 : 98 : (set (attr "prefix_extra")
6077 : 106 : (if_then_else
6078 : 71 : (not (ior (match_test "TARGET_SSE")
6079 : : (match_test "TARGET_3DNOW_A")))
6080 : : (const_string "1")
6081 : 0 : (const_string "*")))
6082 : : (set_attr "mode" "DI,TI,TI")])
6083 : :
6084 : : (define_insn "*mmx_uavgv4hi3"
6085 : : [(set (match_operand:V4HI 0 "register_operand" "=y,x,Yw")
6086 : : (truncate:V4HI
6087 : : (lshiftrt:V4SI
6088 : 134303 : (plus:V4SI
6089 : 134303 : (plus:V4SI
6090 : 134303 : (zero_extend:V4SI
6091 : 134303 : (match_operand:V4HI 1 "register_mmxmem_operand" "%0,0,Yw"))
6092 : 134303 : (zero_extend:V4SI
6093 : : (match_operand:V4HI 2 "register_mmxmem_operand" "ym,x,Yw")))
6094 : : (const_vector:V4SI [(const_int 1) (const_int 1)
6095 : : (const_int 1) (const_int 1)]))
6096 : : (const_int 1))))]
6097 : 73 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
6098 : 73 : && (TARGET_SSE || TARGET_3DNOW_A)
6099 : 73 : && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
6100 : : "@
6101 : 68 : pavgw\t{%2, %0|%0, %2}
6102 : 68 : pavgw\t{%2, %0|%0, %2}
6103 : 80 : vpavgw\t{%2, %1, %0|%0, %1, %2}"
6104 : 80 : [(set_attr "isa" "*,sse2_noavx,avx")
6105 : 80 : (set_attr "mmx_isa" "native,*,*")
6106 : 68 : (set_attr "type" "mmxshft,sseiadd,sseiadd")
6107 : : (set_attr "mode" "DI,TI,TI")])
6108 : :
6109 : 5919 : (define_expand "uavg<mode>3_ceil"
6110 : : [(set (match_operand:MMXMODE12 0 "register_operand")
6111 : : (truncate:MMXMODE12
6112 : : (lshiftrt:<mmxdoublemode>
6113 : : (plus:<mmxdoublemode>
6114 : : (plus:<mmxdoublemode>
6115 : 76 : (zero_extend:<mmxdoublemode>
6116 : 76 : (match_operand:MMXMODE12 1 "register_operand"))
6117 : 76 : (zero_extend:<mmxdoublemode>
6118 : 76 : (match_operand:MMXMODE12 2 "register_operand")))
6119 : 76 : (match_dup 3))
6120 : : (const_int 1))))]
6121 : : "TARGET_MMX_WITH_SSE"
6122 : 4 : "operands[3] = CONST1_RTX(<mmxdoublemode>mode);")
6123 : :
6124 : : (define_insn "uavgv4qi3_ceil"
6125 : 4 : [(set (match_operand:V4QI 0 "register_operand" "=x,Yw")
6126 : 4 : (truncate:V4QI
6127 : 4 : (lshiftrt:V4HI
6128 : 489113 : (plus:V4HI
6129 : 489113 : (plus:V4HI
6130 : 489113 : (zero_extend:V4HI
6131 : 4 : (match_operand:V4QI 1 "register_operand" "%0,Yw"))
6132 : 4 : (zero_extend:V4HI
6133 : : (match_operand:V4QI 2 "register_operand" "x,Yw")))
6134 : 4 : (const_vector:V4HI [(const_int 1) (const_int 1)
6135 : : (const_int 1) (const_int 1)]))
6136 : : (const_int 1))))]
6137 : 1 : "TARGET_SSE2"
6138 : : "@
6139 : : pavgb\t{%2, %0|%0, %2}
6140 : : vpavgb\t{%2, %1, %0|%0, %1, %2}"
6141 : : [(set_attr "isa" "noavx,avx")
6142 : : (set_attr "type" "sseiadd")
6143 : : (set_attr "mode" "TI")])
6144 : :
6145 : 118 : (define_insn "uavgv2qi3_ceil"
6146 : 118 : [(set (match_operand:V2QI 0 "register_operand" "=x,Yw")
6147 : 118 : (truncate:V2QI
6148 : : (lshiftrt:V2HI
6149 : 114 : (plus:V2HI
6150 : 114 : (plus:V2HI
6151 : : (zero_extend:V2HI
6152 : 367 : (match_operand:V2QI 1 "register_operand" "%0,Yw"))
6153 : : (zero_extend:V2HI
6154 : 102 : (match_operand:V2QI 2 "register_operand" "x,Yw")))
6155 : 102 : (const_vector:V2HI [(const_int 1) (const_int 1)]))
6156 : 355 : (const_int 1))))]
6157 : 272 : "TARGET_SSE2"
6158 : 1 : "@
6159 : 253 : pavgb\t{%2, %0|%0, %2}
6160 : 253 : vpavgb\t{%2, %1, %0|%0, %1, %2}"
6161 : 265 : [(set_attr "isa" "noavx,avx")
6162 : 265 : (set_attr "type" "sseiadd")
6163 : 13 : (set_attr "mode" "TI")])
6164 : :
6165 : : (define_insn "uavgv2hi3_ceil"
6166 : : [(set (match_operand:V2HI 0 "register_operand" "=x,Yw")
6167 : : (truncate:V2HI
6168 : : (lshiftrt:V2SI
6169 : : (plus:V2SI
6170 : : (plus:V2SI
6171 : : (zero_extend:V2SI
6172 : : (match_operand:V2HI 1 "register_operand" "%0,Yw"))
6173 : : (zero_extend:V2SI
6174 : : (match_operand:V2HI 2 "register_operand" "x,Yw")))
6175 : : (const_vector:V2SI [(const_int 1) (const_int 1)]))
6176 : : (const_int 1))))]
6177 : 1 : "TARGET_SSE2"
6178 : : "@
6179 : : pavgw\t{%2, %0|%0, %2}
6180 : : vpavgw\t{%2, %1, %0|%0, %1, %2}"
6181 : : [(set_attr "isa" "noavx,avx")
6182 : : (set_attr "type" "sseiadd")
6183 : : (set_attr "mode" "TI")])
6184 : :
6185 : : (define_expand "mmx_psadbw"
6186 : : [(set (match_operand:V1DI 0 "register_operand")
6187 : : (unspec:V1DI [(match_operand:V8QI 1 "register_mmxmem_operand")
6188 : : (match_operand:V8QI 2 "register_mmxmem_operand")]
6189 : 319 : UNSPEC_PSADBW))]
6190 : 319 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && (TARGET_SSE || TARGET_3DNOW_A)"
6191 : 571 : "ix86_fixup_binary_operands_no_copy (PLUS, V8QImode, operands);")
6192 : :
6193 : 309 : (define_insn "*mmx_psadbw"
6194 : 561 : [(set (match_operand:V1DI 0 "register_operand" "=y,x,Yw")
6195 : 561 : (unspec:V1DI [(match_operand:V8QI 1 "register_mmxmem_operand" "%0,0,Yw")
6196 : 561 : (match_operand:V8QI 2 "register_mmxmem_operand" "ym,x,Yw")]
6197 : 561 : UNSPEC_PSADBW))]
6198 : 2172 : "(TARGET_MMX || TARGET_MMX_WITH_SSE) && (TARGET_SSE || TARGET_3DNOW_A)
6199 : 2172 : && ix86_binary_operator_ok (PLUS, V8QImode, operands)"
6200 : 2520 : "@
6201 : 561 : psadbw\t{%2, %0|%0, %2}
6202 : 309 : psadbw\t{%2, %0|%0, %2}
6203 : 431 : vpsadbw\t{%2, %1, %0|%0, %1, %2}"
6204 : 431 : [(set_attr "isa" "*,sse2_noavx,avx")
6205 : 91 : (set_attr "mmx_isa" "native,*,*")
6206 : 516 : (set_attr "type" "mmxshft,sseiadd,sseiadd")
6207 : 319 : (set_attr "mode" "DI,TI,TI")])
6208 : 319 :
6209 : 424 : (define_expand "reduc_<code>_scal_<mode>"
6210 : 195 : [(any_logic:MMXMODE12
6211 : : (match_operand:<mmxscalarmode> 0 "register_operand")
6212 : : (match_operand:MMXMODE12 1 "register_operand"))]
6213 : : "TARGET_MMX_WITH_SSE"
6214 : 8 : {
6215 : 12 : rtx tmp = gen_reg_rtx (<MODE>mode);
6216 : 6 : ix86_expand_reduc (gen_<code><mode>3, tmp, operands[1]);
6217 : 6 : emit_insn (gen_vec_extract<mode><mmxscalarmodelower> (operands[0],
6218 : 2 : tmp, const0_rtx));
6219 : 6 : DONE;
6220 : 2 : })
6221 : 2 :
6222 : 2 : (define_expand "reduc_<code>_scal_v4qi"
6223 : : [(any_logic:V4QI
6224 : : (match_operand:QI 0 "register_operand")
6225 : : (match_operand:V4QI 1 "register_operand"))]
6226 : : "TARGET_SSE2"
6227 : 19 : {
6228 : 38 : rtx tmp = gen_reg_rtx (V4QImode);
6229 : 19 : ix86_expand_reduc (gen_<code>v4qi3, tmp, operands[1]);
6230 : 19 : emit_insn (gen_vec_extractv4qiqi (operands[0], tmp, const0_rtx));
6231 : 19 : DONE;
6232 : : })
6233 : :
6234 : : (define_expand "reduc_plus_scal_v8qi"
6235 : : [(plus:V8QI
6236 : : (match_operand:QI 0 "register_operand")
6237 : : (match_operand:V8QI 1 "register_operand"))]
6238 : 4 : "TARGET_MMX_WITH_SSE"
6239 : 224 : {
6240 : 448 : rtx tmp = gen_reg_rtx (V8QImode);
6241 : 224 : emit_move_insn (tmp, CONST0_RTX (V8QImode));
6242 : 228 : rtx tmp2 = gen_reg_rtx (V1DImode);
6243 : 224 : emit_insn (gen_mmx_psadbw (tmp2, operands[1], tmp));
6244 : 224 : tmp2 = gen_lowpart (V8QImode, tmp2);
6245 : 224 : emit_insn (gen_vec_extractv8qiqi (operands[0], tmp2, const0_rtx));
6246 : 228 : DONE;
6247 : : })
6248 : :
6249 : : (define_expand "reduc_plus_scal_v4hi"
6250 : 243 : [(plus:V4HI
6251 : : (match_operand:HI 0 "register_operand")
6252 : : (match_operand:V4HI 1 "register_operand"))]
6253 : 243 : "TARGET_MMX_WITH_SSE"
6254 : 243 : {
6255 : 725 : rtx tmp = gen_reg_rtx (V4HImode);
6256 : 241 : ix86_expand_reduc (gen_addv4hi3, tmp, operands[1]);
6257 : 241 : emit_insn (gen_vec_extractv4hihi (operands[0], tmp, const0_rtx));
6258 : 484 : DONE;
6259 : : })
6260 : :
6261 : : (define_expand "reduc_<code>_scal_v4hi"
6262 : : [(smaxmin:V4HI
6263 : : (match_operand:HI 0 "register_operand")
6264 : : (match_operand:V4HI 1 "register_operand"))]
6265 : 241 : "TARGET_MMX_WITH_SSE"
6266 : 4 : {
6267 : 8 : rtx tmp = gen_reg_rtx (V4HImode);
6268 : 4 : ix86_expand_reduc (gen_<code>v4hi3, tmp, operands[1]);
6269 : 245 : emit_insn (gen_vec_extractv4hihi (operands[0], tmp, const0_rtx));
6270 : 4 : DONE;
6271 : 241 : })
6272 : 241 :
6273 : 241 : (define_expand "reduc_<code>_scal_v4qi"
6274 : : [(smaxmin:V4QI
6275 : : (match_operand:QI 0 "register_operand")
6276 : : (match_operand:V4QI 1 "register_operand"))]
6277 : 2 : "TARGET_SSE4_1"
6278 : 4 : {
6279 : 8 : rtx tmp = gen_reg_rtx (V4QImode);
6280 : 4 : ix86_expand_reduc (gen_<code>v4qi3, tmp, operands[1]);
6281 : 6 : emit_insn (gen_vec_extractv4qiqi (operands[0], tmp, const0_rtx));
6282 : 4 : DONE;
6283 : 2 : })
6284 : 2 :
6285 : 2 : (define_expand "reduc_<code>_scal_v4hi"
6286 : : [(umaxmin:V4HI
6287 : : (match_operand:HI 0 "register_operand")
6288 : : (match_operand:V4HI 1 "register_operand"))]
6289 : 4 : "TARGET_MMX_WITH_SSE && TARGET_SSE4_1"
6290 : 6 : {
6291 : 12 : rtx tmp = gen_reg_rtx (V4HImode);
6292 : 6 : ix86_expand_reduc (gen_<code>v4hi3, tmp, operands[1]);
6293 : 10 : emit_insn (gen_vec_extractv4hihi (operands[0], tmp, const0_rtx));
6294 : 6 : DONE;
6295 : 4 : })
6296 : 4 :
6297 : 4 : (define_expand "reduc_<code>_scal_v4qi"
6298 : : [(umaxmin:V4QI
6299 : : (match_operand:QI 0 "register_operand")
6300 : : (match_operand:V4QI 1 "register_operand"))]
6301 : 6 : "TARGET_SSE4_1"
6302 : 4 : {
6303 : 8 : rtx tmp = gen_reg_rtx (V4QImode);
6304 : 4 : ix86_expand_reduc (gen_<code>v4qi3, tmp, operands[1]);
6305 : 10 : emit_insn (gen_vec_extractv4qiqi (operands[0], tmp, const0_rtx));
6306 : 4 : DONE;
6307 : 6 : })
6308 : 6 :
6309 : 6 : (define_expand "reduc_plus_scal_v4qi"
6310 : : [(plus:V4QI
6311 : : (match_operand:QI 0 "register_operand")
6312 : : (match_operand:V4QI 1 "register_operand"))]
6313 : 4 : "TARGET_SSE2"
6314 : 210 : {
6315 : 420 : rtx op1 = gen_reg_rtx (V16QImode);
6316 : 210 : emit_insn (gen_vec_setv4si_0 (lowpart_subreg (V4SImode, op1, V16QImode),
6317 : 4 : CONST0_RTX (V4SImode),
6318 : 4 : lowpart_subreg (SImode,
6319 : 4 : operands[1],
6320 : 4 : V4QImode)));
6321 : 214 : rtx tmp = gen_reg_rtx (V16QImode);
6322 : 210 : emit_move_insn (tmp, CONST0_RTX (V16QImode));
6323 : 210 : rtx tmp2 = gen_reg_rtx (V2DImode);
6324 : 210 : emit_insn (gen_sse2_psadbw (tmp2, op1, tmp));
6325 : 212 : tmp2 = gen_lowpart (V16QImode, tmp2);
6326 : 210 : emit_insn (gen_vec_extractv16qiqi (operands[0], tmp2, const0_rtx));
6327 : 210 : DONE;
6328 : 212 : })
6329 : 212 :
6330 : 212 : (define_expand "usadv8qi"
6331 : 212 : [(match_operand:V2SI 0 "register_operand")
6332 : 212 : (match_operand:V8QI 1 "register_operand")
6333 : 212 : (match_operand:V8QI 2 "register_operand")
6334 : : (match_operand:V2SI 3 "register_operand")]
6335 : : "TARGET_MMX_WITH_SSE"
6336 : 5 : {
6337 : 10 : rtx t1 = gen_reg_rtx (V1DImode);
6338 : 5 : rtx t2 = gen_reg_rtx (V2SImode);
6339 : 5 : emit_insn (gen_mmx_psadbw (t1, operands[1], operands[2]));
6340 : 5 : convert_move (t2, t1, 0);
6341 : 5 : emit_insn (gen_addv2si3 (operands[0], t2, operands[3]));
6342 : 5 : DONE;
6343 : : })
6344 : :
6345 : : (define_insn_and_split "mmx_pmovmskb"
6346 : 5 : [(set (match_operand:SI 0 "register_operand" "=r,r,jr")
6347 : : (unspec:SI [(match_operand:V8QI 1 "register_operand" "y,x,x")]
6348 : : UNSPEC_MOVMSK))]
6349 : 71 : "(TARGET_MMX || TARGET_MMX_WITH_SSE)
6350 : 71 : && (TARGET_SSE || TARGET_3DNOW_A)"
6351 : 5 : "@
6352 : 5 : pmovmskb\t{%1, %0|%0, %1}
6353 : 5 : #
6354 : 65 : #"
6355 : 109 : "TARGET_SSE2 && reload_completed
6356 : 87 : && SSE_REGNO_P (REGNO (operands[1]))"
6357 : 27 : [(set (match_dup 0)
6358 : 3425 : (unspec:SI [(match_dup 1)] UNSPEC_MOVMSK))
6359 : 3420 : (set (match_dup 0)
6360 : : (zero_extend:SI (match_dup 2)))]
6361 : 401 : {
6362 : 379 : /* Generate SSE pmovmskb and zero-extend from QImode to SImode. */
6363 : 44 : operands[1] = lowpart_subreg (V16QImode, operands[1],
6364 : 22 : GET_MODE (operands[1]));
6365 : 44 : operands[2] = lowpart_subreg (QImode, operands[0],
6366 : 22 : GET_MODE (operands[0]));
6367 : 22 : }
6368 : 0 : [(set_attr "mmx_isa" "native,sse_noavx,avx")
6369 : 22 : (set_attr "type" "mmxcvt,ssemov,ssemov")
6370 : 44 : (set_attr "mode" "DI,TI,TI")])
6371 : 44 :
6372 : 44 : (define_expand "mmx_maskmovq"
6373 : 22 : [(set (match_operand:V8QI 0 "memory_operand")
6374 : 0 : (unspec:V8QI [(match_operand:V8QI 1 "register_operand")
6375 : 22 : (match_operand:V8QI 2 "register_operand")
6376 : 22 : (match_dup 0)]
6377 : : UNSPEC_MASKMOV))]
6378 : : "TARGET_SSE || TARGET_3DNOW_A")
6379 : :
6380 : : (define_insn "*mmx_maskmovq"
6381 : 22 : [(set (mem:V8QI (match_operand:P 0 "register_operand" "D"))
6382 : : (unspec:V8QI [(match_operand:V8QI 1 "register_operand" "y")
6383 : : (match_operand:V8QI 2 "register_operand" "y")
6384 : 22 : (mem:V8QI (match_dup 0))]
6385 : 22 : UNSPEC_MASKMOV))]
6386 : 26 : "TARGET_SSE || TARGET_3DNOW_A"
6387 : : ;; @@@ check ordering of operands in intel/nonintel syntax
6388 : : "maskmovq\t{%2, %1|%1, %2}"
6389 : : [(set_attr "type" "mmxcvt")
6390 : : (set_attr "znver1_decode" "vector")
6391 : 1 : (set_attr "mode" "DI")])
6392 : :
6393 : : (define_int_iterator EMMS
6394 : 105 : [(UNSPECV_EMMS "TARGET_MMX")
6395 : 1 : (UNSPECV_FEMMS "TARGET_3DNOW")])
6396 : 0 :
6397 : 0 : (define_int_attr emms
6398 : 0 : [(UNSPECV_EMMS "emms")
6399 : 15 : (UNSPECV_FEMMS "femms")])
6400 : 0 :
6401 : 94399 : (define_expand "mmx_<emms>"
6402 : 94399 : [(parallel
6403 : 94399 : [(unspec_volatile [(const_int 0)] EMMS)
6404 : 94399 : (clobber (reg:XF ST0_REG))
6405 : 31798697 : (clobber (reg:XF ST1_REG))
6406 : 106 : (clobber (reg:XF ST2_REG))
6407 : : (clobber (reg:XF ST3_REG))
6408 : 106 : (clobber (reg:XF ST4_REG))
6409 : 31798803 : (clobber (reg:XF ST5_REG))
6410 : 31798803 : (clobber (reg:XF ST6_REG))
6411 : 31798697 : (clobber (reg:XF ST7_REG))
6412 : 31798697 : (clobber (reg:DI MM0_REG))
6413 : 31798697 : (clobber (reg:DI MM1_REG))
6414 : : (clobber (reg:DI MM2_REG))
6415 : 191 : (clobber (reg:DI MM3_REG))
6416 : 191 : (clobber (reg:DI MM4_REG))
6417 : 144 : (clobber (reg:DI MM5_REG))
6418 : : (clobber (reg:DI MM6_REG))
6419 : 142 : (clobber (reg:DI MM7_REG))])]
6420 : 142 : "TARGET_MMX || TARGET_MMX_WITH_SSE"
6421 : 121 : {
6422 : 248 : if (!TARGET_MMX)
6423 : 142 : {
6424 : 143 : emit_insn (gen_nop ());
6425 : 1 : DONE;
6426 : : }
6427 : : })
6428 : :
6429 : : (define_insn "*mmx_<emms>"
6430 : : [(unspec_volatile [(const_int 0)] EMMS)
6431 : 120 : (clobber (reg:XF ST0_REG))
6432 : : (clobber (reg:XF ST1_REG))
6433 : : (clobber (reg:XF ST2_REG))
6434 : : (clobber (reg:XF ST3_REG))
6435 : : (clobber (reg:XF ST4_REG))
6436 : : (clobber (reg:XF ST5_REG))
6437 : : (clobber (reg:XF ST6_REG))
6438 : : (clobber (reg:XF ST7_REG))
6439 : : (clobber (reg:DI MM0_REG))
6440 : : (clobber (reg:DI MM1_REG))
6441 : : (clobber (reg:DI MM2_REG))
6442 : : (clobber (reg:DI MM3_REG))
6443 : : (clobber (reg:DI MM4_REG))
6444 : : (clobber (reg:DI MM5_REG))
6445 : : (clobber (reg:DI MM6_REG))
6446 : : (clobber (reg:DI MM7_REG))]
6447 : : ""
6448 : : "<emms>"
6449 : : [(set_attr "type" "mmx")
6450 : : (set_attr "modrm" "0")
6451 : : (set_attr "memory" "none")])
6452 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6453 : 120 : /* (content generated from line coverage data) */
6454 : 120 : /* ... */
6455 : 120 : /* ... */
6456 : : /* ... */
6457 : : /* ... */
6458 : : /* ... */
6459 : : /* ... */
6460 : 13130 : /* ... */
6461 : : /* ... */
6462 : 15 : /* ... */
6463 : 15 : /* ... */
6464 : 13130 : /* ... */
6465 : 13115 : /* ... */
6466 : 13115 : /* ... */
6467 : 13115 : /* ... */
6468 : 13115 : /* ... */
6469 : : /* ... */
6470 : : /* ... */
6471 : : /* ... */
6472 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6473 : : /* (content generated from line coverage data) */
6474 : : /* ... */
6475 : : /* ... */
6476 : : /* ... */
6477 : : /* ... */
6478 : : /* ... */
6479 : : /* ... */
6480 : : /* ... */
6481 : : /* ... */
6482 : : /* ... */
6483 : : /* ... */
6484 : : /* ... */
6485 : : /* ... */
6486 : : /* ... */
6487 : : /* ... */
6488 : : /* ... */
6489 : : /* ... */
6490 : : /* ... */
6491 : : /* ... */
6492 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6493 : : /* (content generated from line coverage data) */
6494 : : /* ... */
6495 : : /* ... */
6496 : : /* ... */
6497 : : /* ... */
6498 : : /* ... */
6499 : : /* ... */
6500 : : /* ... */
6501 : : /* ... */
6502 : : /* ... */
6503 : : /* ... */
6504 : : /* ... */
6505 : : /* ... */
6506 : : /* ... */
6507 : : /* ... */
6508 : : /* ... */
6509 : : /* ... */
6510 : : /* ... */
6511 : : /* ... */
6512 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6513 : : /* (content generated from line coverage data) */
6514 : : /* ... */
6515 : : /* ... */
6516 : : /* ... */
6517 : : /* ... */
6518 : : /* ... */
6519 : : /* ... */
6520 : : /* ... */
6521 : : /* ... */
6522 : : /* ... */
6523 : : /* ... */
6524 : : /* ... */
6525 : : /* ... */
6526 : : /* ... */
6527 : : /* ... */
6528 : : /* ... */
6529 : : /* ... */
6530 : : /* ... */
6531 : : /* ... */
6532 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6533 : : /* (content generated from line coverage data) */
6534 : : /* ... */
6535 : : /* ... */
6536 : : /* ... */
6537 : : /* ... */
6538 : : /* ... */
6539 : : /* ... */
6540 : : /* ... */
6541 : : /* ... */
6542 : : /* ... */
6543 : : /* ... */
6544 : : /* ... */
6545 : : /* ... */
6546 : : /* ... */
6547 : : /* ... */
6548 : : /* ... */
6549 : : /* ... */
6550 : : /* ... */
6551 : : /* ... */
6552 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6553 : : /* (content generated from line coverage data) */
6554 : : /* ... */
6555 : : /* ... */
6556 : : /* ... */
6557 : : /* ... */
6558 : : /* ... */
6559 : : /* ... */
6560 : : /* ... */
6561 : : /* ... */
6562 : : /* ... */
6563 : : /* ... */
6564 : : /* ... */
6565 : : /* ... */
6566 : : /* ... */
6567 : : /* ... */
6568 : : /* ... */
6569 : : /* ... */
6570 : : /* ... */
6571 : : /* ... */
6572 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6573 : : /* (content generated from line coverage data) */
6574 : : /* ... */
6575 : : /* ... */
6576 : : /* ... */
6577 : : /* ... */
6578 : : /* ... */
6579 : : /* ... */
6580 : : /* ... */
6581 : : /* ... */
6582 : : /* ... */
6583 : : /* ... */
6584 : : /* ... */
6585 : : /* ... */
6586 : : /* ... */
6587 : : /* ... */
6588 : : /* ... */
6589 : : /* ... */
6590 : : /* ... */
6591 : : /* ... */
6592 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6593 : : /* (content generated from line coverage data) */
6594 : : /* ... */
6595 : : /* ... */
6596 : : /* ... */
6597 : : /* ... */
6598 : : /* ... */
6599 : : /* ... */
6600 : : /* ... */
6601 : : /* ... */
6602 : : /* ... */
6603 : : /* ... */
6604 : : /* ... */
6605 : : /* ... */
6606 : : /* ... */
6607 : : /* ... */
6608 : : /* ... */
6609 : : /* ... */
6610 : : /* ... */
6611 : : /* ... */
6612 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6613 : : /* (content generated from line coverage data) */
6614 : : /* ... */
6615 : : /* ... */
6616 : : /* ... */
6617 : : /* ... */
6618 : : /* ... */
6619 : : /* ... */
6620 : : /* ... */
6621 : : /* ... */
6622 : : /* ... */
6623 : : /* ... */
6624 : : /* ... */
6625 : : /* ... */
6626 : : /* ... */
6627 : : /* ... */
6628 : : /* ... */
6629 : : /* ... */
6630 : : /* ... */
6631 : : /* ... */
6632 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6633 : : /* (content generated from line coverage data) */
6634 : : /* ... */
6635 : : /* ... */
6636 : : /* ... */
6637 : : /* ... */
6638 : : /* ... */
6639 : : /* ... */
6640 : : /* ... */
6641 : : /* ... */
6642 : : /* ... */
6643 : : /* ... */
6644 : : /* ... */
6645 : : /* ... */
6646 : : /* ... */
6647 : : /* ... */
6648 : : /* ... */
6649 : : /* ... */
6650 : : /* ... */
6651 : : /* ... */
6652 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6653 : : /* (content generated from line coverage data) */
6654 : : /* ... */
6655 : : /* ... */
6656 : : /* ... */
6657 : : /* ... */
6658 : : /* ... */
6659 : : /* ... */
6660 : : /* ... */
6661 : : /* ... */
6662 : : /* ... */
6663 : : /* ... */
6664 : : /* ... */
6665 : : /* ... */
6666 : : /* ... */
6667 : : /* ... */
6668 : : /* ... */
6669 : : /* ... */
6670 : : /* ... */
6671 : : /* ... */
6672 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6673 : : /* (content generated from line coverage data) */
6674 : : /* ... */
6675 : : /* ... */
6676 : : /* ... */
6677 : : /* ... */
6678 : : /* ... */
6679 : : /* ... */
6680 : : /* ... */
6681 : : /* ... */
6682 : : /* ... */
6683 : : /* ... */
6684 : : /* ... */
6685 : : /* ... */
6686 : : /* ... */
6687 : : /* ... */
6688 : : /* ... */
6689 : : /* ... */
6690 : : /* ... */
6691 : : /* ... */
6692 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6693 : : /* (content generated from line coverage data) */
6694 : : /* ... */
6695 : : /* ... */
6696 : : /* ... */
6697 : : /* ... */
6698 : : /* ... */
6699 : : /* ... */
6700 : : /* ... */
6701 : : /* ... */
6702 : : /* ... */
6703 : : /* ... */
6704 : : /* ... */
6705 : : /* ... */
6706 : : /* ... */
6707 : : /* ... */
6708 : : /* ... */
6709 : : /* ... */
6710 : : /* ... */
6711 : : /* ... */
6712 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6713 : : /* (content generated from line coverage data) */
6714 : : /* ... */
6715 : : /* ... */
6716 : : /* ... */
6717 : : /* ... */
6718 : : /* ... */
6719 : : /* ... */
6720 : : /* ... */
6721 : : /* ... */
6722 : : /* ... */
6723 : : /* ... */
6724 : : /* ... */
6725 : : /* ... */
6726 : : /* ... */
6727 : : /* ... */
6728 : : /* ... */
6729 : : /* ... */
6730 : : /* ... */
6731 : : /* ... */
6732 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6733 : : /* (content generated from line coverage data) */
6734 : : /* ... */
6735 : : /* ... */
6736 : : /* ... */
6737 : : /* ... */
6738 : : /* ... */
6739 : : /* ... */
6740 : : /* ... */
6741 : : /* ... */
6742 : : /* ... */
6743 : : /* ... */
6744 : : /* ... */
6745 : : /* ... */
6746 : : /* ... */
6747 : : /* ... */
6748 : : /* ... */
6749 : : /* ... */
6750 : : /* ... */
6751 : : /* ... */
6752 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6753 : : /* (content generated from line coverage data) */
6754 : : /* ... */
6755 : : /* ... */
6756 : : /* ... */
6757 : : /* ... */
6758 : : /* ... */
6759 : : /* ... */
6760 : : /* ... */
6761 : : /* ... */
6762 : : /* ... */
6763 : : /* ... */
6764 : : /* ... */
6765 : : /* ... */
6766 : : /* ... */
6767 : : /* ... */
6768 : : /* ... */
6769 : : /* ... */
6770 : : /* ... */
6771 : : /* ... */
6772 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6773 : : /* (content generated from line coverage data) */
6774 : : /* ... */
6775 : : /* ... */
6776 : : /* ... */
6777 : : /* ... */
6778 : : /* ... */
6779 : : /* ... */
6780 : : /* ... */
6781 : : /* ... */
6782 : : /* ... */
6783 : : /* ... */
6784 : : /* ... */
6785 : : /* ... */
6786 : : /* ... */
6787 : : /* ... */
6788 : : /* ... */
6789 : : /* ... */
6790 : : /* ... */
6791 : : /* ... */
6792 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6793 : : /* (content generated from line coverage data) */
6794 : : /* ... */
6795 : : /* ... */
6796 : : /* ... */
6797 : : /* ... */
6798 : : /* ... */
6799 : : /* ... */
6800 : : /* ... */
6801 : : /* ... */
6802 : : /* ... */
6803 : : /* ... */
6804 : : /* ... */
6805 : : /* ... */
6806 : : /* ... */
6807 : : /* ... */
6808 : : /* ... */
6809 : : /* ... */
6810 : : /* ... */
6811 : : /* ... */
6812 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6813 : : /* (content generated from line coverage data) */
6814 : : /* ... */
6815 : : /* ... */
6816 : : /* ... */
6817 : : /* ... */
6818 : : /* ... */
6819 : : /* ... */
6820 : : /* ... */
6821 : : /* ... */
6822 : : /* ... */
6823 : : /* ... */
6824 : : /* ... */
6825 : : /* ... */
6826 : : /* ... */
6827 : : /* ... */
6828 : : /* ... */
6829 : : /* ... */
6830 : : /* ... */
6831 : : /* ... */
6832 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6833 : : /* (content generated from line coverage data) */
6834 : : /* ... */
6835 : : /* ... */
6836 : : /* ... */
6837 : : /* ... */
6838 : : /* ... */
6839 : : /* ... */
6840 : : /* ... */
6841 : : /* ... */
6842 : : /* ... */
6843 : : /* ... */
6844 : : /* ... */
6845 : : /* ... */
6846 : : /* ... */
6847 : : /* ... */
6848 : : /* ... */
6849 : : /* ... */
6850 : : /* ... */
6851 : : /* ... */
6852 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6853 : : /* (content generated from line coverage data) */
6854 : : /* ... */
6855 : : /* ... */
6856 : : /* ... */
6857 : : /* ... */
6858 : : /* ... */
6859 : : /* ... */
6860 : : /* ... */
6861 : : /* ... */
6862 : : /* ... */
6863 : : /* ... */
6864 : : /* ... */
6865 : : /* ... */
6866 : : /* ... */
6867 : : /* ... */
6868 : : /* ... */
6869 : : /* ... */
6870 : : /* ... */
6871 : : /* ... */
6872 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6873 : : /* (content generated from line coverage data) */
6874 : : /* ... */
6875 : : /* ... */
6876 : : /* ... */
6877 : : /* ... */
6878 : : /* ... */
6879 : : /* ... */
6880 : : /* ... */
6881 : : /* ... */
6882 : : /* ... */
6883 : : /* ... */
6884 : : /* ... */
6885 : : /* ... */
6886 : : /* ... */
6887 : : /* ... */
6888 : : /* ... */
6889 : : /* ... */
6890 : : /* ... */
6891 : : /* ... */
6892 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6893 : : /* (content generated from line coverage data) */
6894 : : /* ... */
6895 : : /* ... */
6896 : : /* ... */
6897 : : /* ... */
6898 : : /* ... */
6899 : : /* ... */
6900 : : /* ... */
6901 : : /* ... */
6902 : : /* ... */
6903 : : /* ... */
6904 : : /* ... */
6905 : : /* ... */
6906 : : /* ... */
6907 : : /* ... */
6908 : : /* ... */
6909 : : /* ... */
6910 : : /* ... */
6911 : : /* ... */
6912 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6913 : : /* (content generated from line coverage data) */
6914 : : /* ... */
6915 : : /* ... */
6916 : : /* ... */
6917 : : /* ... */
6918 : : /* ... */
6919 : : /* ... */
6920 : : /* ... */
6921 : : /* ... */
6922 : : /* ... */
6923 : : /* ... */
6924 : : /* ... */
6925 : : /* ... */
6926 : : /* ... */
6927 : : /* ... */
6928 : : /* ... */
6929 : : /* ... */
6930 : : /* ... */
6931 : : /* ... */
6932 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6933 : : /* (content generated from line coverage data) */
6934 : : /* ... */
6935 : : /* ... */
6936 : : /* ... */
6937 : : /* ... */
6938 : : /* ... */
6939 : : /* ... */
6940 : : /* ... */
6941 : : /* ... */
6942 : : /* ... */
6943 : : /* ... */
6944 : : /* ... */
6945 : : /* ... */
6946 : : /* ... */
6947 : : /* ... */
6948 : : /* ... */
6949 : : /* ... */
6950 : : /* ... */
6951 : : /* ... */
6952 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6953 : : /* (content generated from line coverage data) */
6954 : : /* ... */
6955 : : /* ... */
6956 : : /* ... */
6957 : : /* ... */
6958 : : /* ... */
6959 : : /* ... */
6960 : : /* ... */
6961 : : /* ... */
6962 : : /* ... */
6963 : : /* ... */
6964 : : /* ... */
6965 : : /* ... */
6966 : : /* ... */
6967 : : /* ... */
6968 : : /* ... */
6969 : : /* ... */
6970 : : /* ... */
6971 : : /* ... */
6972 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6973 : : /* (content generated from line coverage data) */
6974 : : /* ... */
6975 : : /* ... */
6976 : : /* ... */
6977 : : /* ... */
6978 : : /* ... */
6979 : : /* ... */
6980 : : /* ... */
6981 : : /* ... */
6982 : : /* ... */
6983 : : /* ... */
6984 : : /* ... */
6985 : : /* ... */
6986 : : /* ... */
6987 : : /* ... */
6988 : : /* ... */
6989 : : /* ... */
6990 : : /* ... */
6991 : : /* ... */
6992 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
6993 : : /* (content generated from line coverage data) */
6994 : : /* ... */
6995 : : /* ... */
6996 : : /* ... */
6997 : : /* ... */
6998 : : /* ... */
6999 : : /* ... */
7000 : : /* ... */
7001 : : /* ... */
7002 : : /* ... */
7003 : : /* ... */
7004 : : /* ... */
7005 : : /* ... */
7006 : : /* ... */
7007 : : /* ... */
7008 : : /* ... */
7009 : : /* ... */
7010 : : /* ... */
7011 : : /* ... */
7012 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7013 : : /* (content generated from line coverage data) */
7014 : : /* ... */
7015 : : /* ... */
7016 : : /* ... */
7017 : : /* ... */
7018 : : /* ... */
7019 : : /* ... */
7020 : : /* ... */
7021 : : /* ... */
7022 : : /* ... */
7023 : : /* ... */
7024 : : /* ... */
7025 : : /* ... */
7026 : : /* ... */
7027 : : /* ... */
7028 : : /* ... */
7029 : : /* ... */
7030 : : /* ... */
7031 : : /* ... */
7032 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7033 : : /* (content generated from line coverage data) */
7034 : : /* ... */
7035 : : /* ... */
7036 : : /* ... */
7037 : : /* ... */
7038 : : /* ... */
7039 : : /* ... */
7040 : : /* ... */
7041 : : /* ... */
7042 : : /* ... */
7043 : : /* ... */
7044 : : /* ... */
7045 : : /* ... */
7046 : : /* ... */
7047 : : /* ... */
7048 : : /* ... */
7049 : : /* ... */
7050 : : /* ... */
7051 : : /* ... */
7052 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7053 : : /* (content generated from line coverage data) */
7054 : : /* ... */
7055 : : /* ... */
7056 : : /* ... */
7057 : : /* ... */
7058 : : /* ... */
7059 : : /* ... */
7060 : : /* ... */
7061 : : /* ... */
7062 : : /* ... */
7063 : : /* ... */
7064 : : /* ... */
7065 : : /* ... */
7066 : : /* ... */
7067 : : /* ... */
7068 : : /* ... */
7069 : : /* ... */
7070 : : /* ... */
7071 : : /* ... */
7072 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7073 : : /* (content generated from line coverage data) */
7074 : : /* ... */
7075 : : /* ... */
7076 : : /* ... */
7077 : : /* ... */
7078 : : /* ... */
7079 : : /* ... */
7080 : : /* ... */
7081 : : /* ... */
7082 : : /* ... */
7083 : : /* ... */
7084 : : /* ... */
7085 : : /* ... */
7086 : : /* ... */
7087 : : /* ... */
7088 : : /* ... */
7089 : : /* ... */
7090 : : /* ... */
7091 : : /* ... */
7092 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7093 : : /* (content generated from line coverage data) */
7094 : : /* ... */
7095 : : /* ... */
7096 : : /* ... */
7097 : : /* ... */
7098 : : /* ... */
7099 : : /* ... */
7100 : : /* ... */
7101 : : /* ... */
7102 : : /* ... */
7103 : : /* ... */
7104 : : /* ... */
7105 : : /* ... */
7106 : : /* ... */
7107 : : /* ... */
7108 : : /* ... */
7109 : : /* ... */
7110 : : /* ... */
7111 : : /* ... */
7112 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7113 : : /* (content generated from line coverage data) */
7114 : : /* ... */
7115 : : /* ... */
7116 : : /* ... */
7117 : : /* ... */
7118 : : /* ... */
7119 : : /* ... */
7120 : : /* ... */
7121 : : /* ... */
7122 : : /* ... */
7123 : : /* ... */
7124 : : /* ... */
7125 : : /* ... */
7126 : : /* ... */
7127 : : /* ... */
7128 : : /* ... */
7129 : : /* ... */
7130 : : /* ... */
7131 : : /* ... */
7132 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7133 : : /* (content generated from line coverage data) */
7134 : : /* ... */
7135 : : /* ... */
7136 : : /* ... */
7137 : : /* ... */
7138 : : /* ... */
7139 : : /* ... */
7140 : : /* ... */
7141 : : /* ... */
7142 : : /* ... */
7143 : : /* ... */
7144 : : /* ... */
7145 : : /* ... */
7146 : : /* ... */
7147 : : /* ... */
7148 : : /* ... */
7149 : : /* ... */
7150 : : /* ... */
7151 : : /* ... */
7152 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7153 : : /* (content generated from line coverage data) */
7154 : : /* ... */
7155 : : /* ... */
7156 : : /* ... */
7157 : : /* ... */
7158 : : /* ... */
7159 : : /* ... */
7160 : : /* ... */
7161 : : /* ... */
7162 : : /* ... */
7163 : : /* ... */
7164 : : /* ... */
7165 : : /* ... */
7166 : : /* ... */
7167 : : /* ... */
7168 : : /* ... */
7169 : : /* ... */
7170 : : /* ... */
7171 : : /* ... */
7172 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7173 : : /* (content generated from line coverage data) */
7174 : : /* ... */
7175 : : /* ... */
7176 : : /* ... */
7177 : : /* ... */
7178 : : /* ... */
7179 : : /* ... */
7180 : : /* ... */
7181 : : /* ... */
7182 : : /* ... */
7183 : : /* ... */
7184 : : /* ... */
7185 : : /* ... */
7186 : : /* ... */
7187 : : /* ... */
7188 : : /* ... */
7189 : : /* ... */
7190 : : /* ... */
7191 : : /* ... */
7192 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7193 : : /* (content generated from line coverage data) */
7194 : : /* ... */
7195 : : /* ... */
7196 : : /* ... */
7197 : : /* ... */
7198 : : /* ... */
7199 : : /* ... */
7200 : : /* ... */
7201 : : /* ... */
7202 : : /* ... */
7203 : : /* ... */
7204 : : /* ... */
7205 : : /* ... */
7206 : : /* ... */
7207 : : /* ... */
7208 : : /* ... */
7209 : : /* ... */
7210 : : /* ... */
7211 : : /* ... */
7212 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7213 : : /* (content generated from line coverage data) */
7214 : : /* ... */
7215 : : /* ... */
7216 : : /* ... */
7217 : : /* ... */
7218 : : /* ... */
7219 : : /* ... */
7220 : : /* ... */
7221 : : /* ... */
7222 : : /* ... */
7223 : : /* ... */
7224 : : /* ... */
7225 : : /* ... */
7226 : : /* ... */
7227 : : /* ... */
7228 : : /* ... */
7229 : : /* ... */
7230 : : /* ... */
7231 : : /* ... */
7232 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7233 : : /* (content generated from line coverage data) */
7234 : : /* ... */
7235 : : /* ... */
7236 : : /* ... */
7237 : : /* ... */
7238 : : /* ... */
7239 : : /* ... */
7240 : : /* ... */
7241 : : /* ... */
7242 : : /* ... */
7243 : : /* ... */
7244 : : /* ... */
7245 : : /* ... */
7246 : : /* ... */
7247 : : /* ... */
7248 : : /* ... */
7249 : : /* ... */
7250 : : /* ... */
7251 : : /* ... */
7252 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7253 : : /* (content generated from line coverage data) */
7254 : : /* ... */
7255 : : /* ... */
7256 : : /* ... */
7257 : : /* ... */
7258 : : /* ... */
7259 : : /* ... */
7260 : : /* ... */
7261 : : /* ... */
7262 : : /* ... */
7263 : : /* ... */
7264 : : /* ... */
7265 : : /* ... */
7266 : : /* ... */
7267 : : /* ... */
7268 : : /* ... */
7269 : : /* ... */
7270 : : /* ... */
7271 : : /* ... */
7272 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7273 : : /* (content generated from line coverage data) */
7274 : : /* ... */
7275 : : /* ... */
7276 : : /* ... */
7277 : : /* ... */
7278 : : /* ... */
7279 : : /* ... */
7280 : : /* ... */
7281 : : /* ... */
7282 : : /* ... */
7283 : : /* ... */
7284 : : /* ... */
7285 : : /* ... */
7286 : : /* ... */
7287 : : /* ... */
7288 : : /* ... */
7289 : : /* ... */
7290 : : /* ... */
7291 : : /* ... */
7292 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7293 : : /* (content generated from line coverage data) */
7294 : : /* ... */
7295 : : /* ... */
7296 : : /* ... */
7297 : : /* ... */
7298 : : /* ... */
7299 : : /* ... */
7300 : : /* ... */
7301 : : /* ... */
7302 : : /* ... */
7303 : : /* ... */
7304 : : /* ... */
7305 : : /* ... */
7306 : : /* ... */
7307 : : /* ... */
7308 : : /* ... */
7309 : : /* ... */
7310 : : /* ... */
7311 : : /* ... */
7312 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7313 : : /* (content generated from line coverage data) */
7314 : : /* ... */
7315 : : /* ... */
7316 : : /* ... */
7317 : : /* ... */
7318 : : /* ... */
7319 : : /* ... */
7320 : : /* ... */
7321 : : /* ... */
7322 : : /* ... */
7323 : : /* ... */
7324 : : /* ... */
7325 : : /* ... */
7326 : : /* ... */
7327 : : /* ... */
7328 : : /* ... */
7329 : : /* ... */
7330 : : /* ... */
7331 : : /* ... */
7332 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7333 : : /* (content generated from line coverage data) */
7334 : : /* ... */
7335 : : /* ... */
7336 : : /* ... */
7337 : : /* ... */
7338 : : /* ... */
7339 : : /* ... */
7340 : : /* ... */
7341 : : /* ... */
7342 : : /* ... */
7343 : : /* ... */
7344 : : /* ... */
7345 : : /* ... */
7346 : : /* ... */
7347 : : /* ... */
7348 : : /* ... */
7349 : : /* ... */
7350 : : /* ... */
7351 : : /* ... */
7352 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7353 : : /* (content generated from line coverage data) */
7354 : : /* ... */
7355 : : /* ... */
7356 : : /* ... */
7357 : : /* ... */
7358 : : /* ... */
7359 : 0 : /* ... */
7360 : 0 : /* ... */
7361 : 0 : /* ... */
7362 : 0 : /* ... */
7363 : : /* ... */
7364 : 0 : /* ... */
7365 : : /* ... */
7366 : : /* ... */
7367 : : /* ... */
7368 : : /* ... */
7369 : : /* ... */
7370 : : /* ... */
7371 : : /* ... */
7372 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7373 : : /* (content generated from line coverage data) */
7374 : : /* ... */
7375 : : /* ... */
7376 : : /* ... */
7377 : : /* ... */
7378 : : /* ... */
7379 : : /* ... */
7380 : 379639002 : /* ... */
7381 : : /* ... */
7382 : 379639002 : /* ... */
7383 : : /* ... */
7384 : 379639002 : /* ... */
7385 : : /* ... */
7386 : 1120846 : /* ... */
7387 : 1120846 : /* ... */
7388 : 1120846 : /* ... */
7389 : 1120846 : /* ... */
7390 : 1120846 : /* ... */
7391 : : /* ... */
7392 : : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/mmx.md not long enough */
7393 : : /* (content generated from line coverage data) */
7394 : : /* ... */
7395 : : /* ... */
7396 : 1120657 : /* ... */
|
