← Back to branch summary

~ubuntu-branches/debian/sid/gcc-4.8/sid

« back to all changes in this revision

Viewing changes to .svn/pristine/aa/aa76da26fc2b688b4bb2ee3dcb0946f8fb0aff53.svn-base

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-12-19 19:48:34 UTC
  • Revision ID: package-import@ubuntu.com-20141219194834-4dz1q7rrn5pad823
Tags: 4.8.4-1
* GCC 4.8.4 release.
  - Fix PR target/61407 (darwin), PR middle-end/58624 (ice),
    PR sanitizer/64265 (wrong code).
* Require recent binutils to pass go test failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.svn/pristine/aa/aa76da26fc2b688b4bb2ee3dcb0946f8fb0aff53.svn-base
 
1
# DP: Revert AArch64 backport also found on the Linaro branch.
 
2
 
 
3
Index: gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c
 
4
===================================================================
 
5
--- a/src/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c  (revision 206133)
 
6
+++ a/src/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c  (revision 206132)
 
7
@@ -1,14 +1,8 @@
 
8
 /* { dg-do compile } */
 
9
 /* { dg-options "-O2" } */
 
10
 
 
11
-#include <arm_neon.h>
 
12
+#include "../../../config/aarch64/arm_neon.h"
 
13
 
 
14
-/* Used to force a variable to a SIMD register.  */
 
15
-#define force_simd(V1)   asm volatile ("mov %d0, %1.d[0]"      \
 
16
-          : "=w"(V1)                                           \
 
17
-          : "w"(V1)                                            \
 
18
-          : /* No clobbers */);
 
19
-
 
20
 /* { dg-final { scan-assembler-times "\\tadd\\tx\[0-9\]+" 2 } } */
 
21
 
 
22
 uint64x1_t
 
23
@@ -37,12 +31,7 @@
 
24
 uint64x1_t
 
25
 test_vceqd_s64 (int64x1_t a, int64x1_t b)
 
26
 {
 
27
-  uint64x1_t res;
 
28
-  force_simd (a);
 
29
-  force_simd (b);
 
30
-  res = vceqd_s64 (a, b);
 
31
-  force_simd (res);
 
32
-  return res;
 
33
+  return vceqd_s64 (a, b);
 
34
 }
 
35
 
 
36
 /* { dg-final { scan-assembler-times "\\tcmeq\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */
 
37
@@ -50,11 +39,7 @@
 
38
 uint64x1_t
 
39
 test_vceqzd_s64 (int64x1_t a)
 
40
 {
 
41
-  uint64x1_t res;
 
42
-  force_simd (a);
 
43
-  res = vceqzd_s64 (a);
 
44
-  force_simd (res);
 
45
-  return res;
 
46
+  return vceqzd_s64 (a);
 
47
 }
 
48
 
 
49
 /* { dg-final { scan-assembler-times "\\tcmge\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 2 } } */
 
50
@@ -62,36 +47,21 @@
 
51
 uint64x1_t
 
52
 test_vcged_s64 (int64x1_t a, int64x1_t b)
 
53
 {
 
54
-  uint64x1_t res;
 
55
-  force_simd (a);
 
56
-  force_simd (b);
 
57
-  res = vcged_s64 (a, b);
 
58
-  force_simd (res);
 
59
-  return res;
 
60
+  return vcged_s64 (a, b);
 
61
 }
 
62
 
 
63
 uint64x1_t
 
64
 test_vcled_s64 (int64x1_t a, int64x1_t b)
 
65
 {
 
66
-  uint64x1_t res;
 
67
-  force_simd (a);
 
68
-  force_simd (b);
 
69
-  res = vcled_s64 (a, b);
 
70
-  force_simd (res);
 
71
-  return res;
 
72
+  return vcled_s64 (a, b);
 
73
 }
 
74
 
 
75
-/* Idiom recognition will cause this testcase not to generate
 
76
-   the expected cmge instruction, so do not check for it.  */
 
77
+/* { dg-final { scan-assembler-times "\\tcmge\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */
 
78
 
 
79
 uint64x1_t
 
80
 test_vcgezd_s64 (int64x1_t a)
 
81
 {
 
82
-  uint64x1_t res;
 
83
-  force_simd (a);
 
84
-  res = vcgezd_s64 (a);
 
85
-  force_simd (res);
 
86
-  return res;
 
87
+  return vcgezd_s64 (a);
 
88
 }
 
89
 
 
90
 /* { dg-final { scan-assembler-times "\\tcmhs\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 1 } } */
 
91
@@ -99,12 +69,7 @@
 
92
 uint64x1_t
 
93
 test_vcged_u64 (uint64x1_t a, uint64x1_t b)
 
94
 {
 
95
-  uint64x1_t res;
 
96
-  force_simd (a);
 
97
-  force_simd (b);
 
98
-  res = vcged_u64 (a, b);
 
99
-  force_simd (res);
 
100
-  return res;
 
101
+  return vcged_u64 (a, b);
 
102
 }
 
103
 
 
104
 /* { dg-final { scan-assembler-times "\\tcmgt\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 2 } } */
 
105
@@ -112,23 +77,13 @@
 
106
 uint64x1_t
 
107
 test_vcgtd_s64 (int64x1_t a, int64x1_t b)
 
108
 {
 
109
-  uint64x1_t res;
 
110
-  force_simd (a);
 
111
-  force_simd (b);
 
112
-  res = vcgtd_s64 (a, b);
 
113
-  force_simd (res);
 
114
-  return res;
 
115
+  return vcgtd_s64 (a, b);
 
116
 }
 
117
 
 
118
 uint64x1_t
 
119
 test_vcltd_s64 (int64x1_t a, int64x1_t b)
 
120
 {
 
121
-  uint64x1_t res;
 
122
-  force_simd (a);
 
123
-  force_simd (b);
 
124
-  res = vcltd_s64 (a, b);
 
125
-  force_simd (res);
 
126
-  return res;
 
127
+  return vcltd_s64 (a, b);
 
128
 }
 
129
 
 
130
 /* { dg-final { scan-assembler-times "\\tcmgt\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */
 
131
@@ -136,11 +91,7 @@
 
132
 uint64x1_t
 
133
 test_vcgtzd_s64 (int64x1_t a)
 
134
 {
 
135
-  uint64x1_t res;
 
136
-  force_simd (a);
 
137
-  res = vcgtzd_s64 (a);
 
138
-  force_simd (res);
 
139
-  return res;
 
140
+  return vcgtzd_s64 (a);
 
141
 }
 
142
 
 
143
 /* { dg-final { scan-assembler-times "\\tcmhi\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 1 } } */
 
144
@@ -148,12 +99,7 @@
 
145
 uint64x1_t
 
146
 test_vcgtd_u64 (uint64x1_t a, uint64x1_t b)
 
147
 {
 
148
-  uint64x1_t res;
 
149
-  force_simd (a);
 
150
-  force_simd (b);
 
151
-  res = vcgtd_u64 (a, b);
 
152
-  force_simd (res);
 
153
-  return res;
 
154
+  return vcgtd_u64 (a, b);
 
155
 }
 
156
 
 
157
 /* { dg-final { scan-assembler-times "\\tcmle\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */
 
158
@@ -161,24 +107,15 @@
 
159
 uint64x1_t
 
160
 test_vclezd_s64 (int64x1_t a)
 
161
 {
 
162
-  uint64x1_t res;
 
163
-  force_simd (a);
 
164
-  res = vclezd_s64 (a);
 
165
-  force_simd (res);
 
166
-  return res;
 
167
+  return vclezd_s64 (a);
 
168
 }
 
169
 
 
170
-/* Idiom recognition will cause this testcase not to generate
 
171
-   the expected cmlt instruction, so do not check for it.  */
 
172
+/* { dg-final { scan-assembler-times "\\tcmlt\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */
 
173
 
 
174
 uint64x1_t
 
175
 test_vcltzd_s64 (int64x1_t a)
 
176
 {
 
177
-  uint64x1_t res;
 
178
-  force_simd (a);
 
179
-  res = vcltzd_s64 (a);
 
180
-  force_simd (res);
 
181
-  return res;
 
182
+  return vcltzd_s64 (a);
 
183
 }
 
184
 
 
185
 /* { dg-final { scan-assembler-times "\\tdup\\tb\[0-9\]+, v\[0-9\]+\.b" 2 } } */
 
186
@@ -242,23 +179,13 @@
 
187
 int64x1_t
 
188
 test_vtst_s64 (int64x1_t a, int64x1_t b)
 
189
 {
 
190
-  uint64x1_t res;
 
191
-  force_simd (a);
 
192
-  force_simd (b);
 
193
-  res = vtstd_s64 (a, b);
 
194
-  force_simd (res);
 
195
-  return res;
 
196
+  return vtstd_s64 (a, b);
 
197
 }
 
198
 
 
199
 uint64x1_t
 
200
 test_vtst_u64 (uint64x1_t a, uint64x1_t b)
 
201
 {
 
202
-  uint64x1_t res;
 
203
-  force_simd (a);
 
204
-  force_simd (b);
 
205
-  res = vtstd_s64 (a, b);
 
206
-  force_simd (res);
 
207
-  return res;
 
208
+  return vtstd_u64 (a, b);
 
209
 }
 
210
 
 
211
 /* { dg-final { scan-assembler-times "\\taddp\\td\[0-9\]+, v\[0-9\]+\.2d" 1 } } */
 
212
@@ -795,11 +722,8 @@
 
213
   return vrshld_u64 (a, b);
 
214
 }
 
215
 
 
216
-/* Other intrinsics can generate an asr instruction (vcltzd, vcgezd),
 
217
-   so we cannot check scan-assembler-times.  */
 
218
+/* { dg-final { scan-assembler-times "\\tasr\\tx\[0-9\]+" 1 } } */
 
219
 
 
220
-/* { dg-final { scan-assembler "\\tasr\\tx\[0-9\]+" } } */
 
221
-
 
222
 int64x1_t
 
223
 test_vshrd_n_s64 (int64x1_t a)
 
224
 {
 
225
Index: gcc/config/aarch64/aarch64-simd.md
 
226
===================================================================
 
227
--- a/src/gcc/config/aarch64/aarch64-simd.md    (revision 206133)
 
228
+++ a/src/gcc/config/aarch64/aarch64-simd.md    (revision 206132)
 
229
@@ -21,7 +21,7 @@
 
230
 
 
231
 ; Main data types used by the insntructions
 
232
 
 
233
-(define_attr "simd_mode" "unknown,none,V8QI,V16QI,V4HI,V8HI,V2SI,V4SI,V2DI,V2SF,V4SF,V2DF,OI,CI,XI,DI,DF,SI,SF,HI,QI"
 
234
+(define_attr "simd_mode" "unknown,none,V8QI,V16QI,V4HI,V8HI,V2SI,V4SI,V2DI,V2SF,V4SF,V2DF,OI,CI,XI,DI,DF,SI,HI,QI"
 
235
   (const_string "unknown"))
 
236
 
 
237
 
 
238
@@ -1548,12 +1548,12 @@
 
239
 
 
240
     case LTU:
 
241
     case GEU:
 
242
-      emit_insn (gen_aarch64_cmgeu<mode> (mask, operands[4], operands[5]));
 
243
+      emit_insn (gen_aarch64_cmhs<mode> (mask, operands[4], operands[5]));
 
244
       break;
 
245
 
 
246
     case LEU:
 
247
     case GTU:
 
248
-      emit_insn (gen_aarch64_cmgtu<mode> (mask, operands[4], operands[5]));
 
249
+      emit_insn (gen_aarch64_cmhi<mode> (mask, operands[4], operands[5]));
 
250
       break;
 
251
 
 
252
     case NE:
 
253
@@ -3034,181 +3034,48 @@
 
254
 )
 
255
 
 
256
 
 
257
-;; cm(eq|ge|gt|lt|le)
 
258
-;; Note, we have constraints for Dz and Z as different expanders
 
259
-;; have different ideas of what should be passed to this pattern.
 
260
+;; cm(eq|ge|le|lt|gt)
 
261
 
 
262
-(define_insn "aarch64_cm<optab><mode>"
 
263
+(define_insn "aarch64_cm<cmp><mode>"
 
264
   [(set (match_operand:<V_cmp_result> 0 "register_operand" "=w,w")
 
265
-       (neg:<V_cmp_result>
 
266
-         (COMPARISONS:<V_cmp_result>
 
267
-           (match_operand:VDQ 1 "register_operand" "w,w")
 
268
-           (match_operand:VDQ 2 "aarch64_simd_reg_or_zero" "w,ZDz")
 
269
-         )))]
 
270
+        (unspec:<V_cmp_result>
 
271
+         [(match_operand:VSDQ_I_DI 1 "register_operand" "w,w")
 
272
+          (match_operand:VSDQ_I_DI 2 "aarch64_simd_reg_or_zero" "w,Z")]
 
273
+          VCMP_S))]
 
274
   "TARGET_SIMD"
 
275
   "@
 
276
-  cm<n_optab>\t%<v>0<Vmtype>, %<v><cmp_1><Vmtype>, %<v><cmp_2><Vmtype>
 
277
-  cm<optab>\t%<v>0<Vmtype>, %<v>1<Vmtype>, #0"
 
278
+  cm<cmp>\t%<v>0<Vmtype>, %<v>1<Vmtype>, %<v>2<Vmtype>
 
279
+  cm<cmp>\t%<v>0<Vmtype>, %<v>1<Vmtype>, #0"
 
280
   [(set_attr "simd_type" "simd_cmp")
 
281
    (set_attr "simd_mode" "<MODE>")]
 
282
 )
 
283
 
 
284
-(define_insn_and_split "aarch64_cm<optab>di"
 
285
-  [(set (match_operand:DI 0 "register_operand" "=w,w,r")
 
286
-       (neg:DI
 
287
-         (COMPARISONS:DI
 
288
-           (match_operand:DI 1 "register_operand" "w,w,r")
 
289
-           (match_operand:DI 2 "aarch64_simd_reg_or_zero" "w,ZDz,r")
 
290
-         )))]
 
291
-  "TARGET_SIMD"
 
292
-  "@
 
293
-  cm<n_optab>\t%d0, %d<cmp_1>, %d<cmp_2>
 
294
-  cm<optab>\t%d0, %d1, #0
 
295
-  #"
 
296
-  "reload_completed
 
297
-   /* We need to prevent the split from
 
298
-      happening in the 'w' constraint cases.  */
 
299
-   && GP_REGNUM_P (REGNO (operands[0]))
 
300
-   && GP_REGNUM_P (REGNO (operands[1]))"
 
301
-  [(set (reg:CC CC_REGNUM)
 
302
-    (compare:CC
 
303
-      (match_dup 1)
 
304
-      (match_dup 2)))
 
305
-  (set (match_dup 0)
 
306
-    (neg:DI
 
307
-      (COMPARISONS:DI
 
308
-       (match_operand 3 "cc_register" "")
 
309
-       (const_int 0))))]
 
310
-  {
 
311
-    enum machine_mode mode = SELECT_CC_MODE (<CMP>, operands[1], operands[2]);
 
312
-    rtx cc_reg = aarch64_gen_compare_reg (<CMP>, operands[1], operands[2]);
 
313
-    rtx comparison = gen_rtx_<CMP> (mode, operands[1], operands[2]);
 
314
-    emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
 
315
-    DONE;
 
316
-  }
 
317
-  [(set_attr "simd_type" "simd_cmp")
 
318
-   (set_attr "simd_mode" "DI")]
 
319
-)
 
320
+;; cm(hs|hi|tst)
 
321
 
 
322
-;; cm(hs|hi)
 
323
-
 
324
-(define_insn "aarch64_cm<optab><mode>"
 
325
+(define_insn "aarch64_cm<cmp><mode>"
 
326
   [(set (match_operand:<V_cmp_result> 0 "register_operand" "=w")
 
327
-       (neg:<V_cmp_result>
 
328
-         (UCOMPARISONS:<V_cmp_result>
 
329
-           (match_operand:VDQ 1 "register_operand" "w")
 
330
-           (match_operand:VDQ 2 "register_operand" "w")
 
331
-         )))]
 
332
+        (unspec:<V_cmp_result>
 
333
+         [(match_operand:VSDQ_I_DI 1 "register_operand" "w")
 
334
+          (match_operand:VSDQ_I_DI 2 "register_operand" "w")]
 
335
+          VCMP_U))]
 
336
   "TARGET_SIMD"
 
337
-  "cm<n_optab>\t%<v>0<Vmtype>, %<v><cmp_1><Vmtype>, %<v><cmp_2><Vmtype>"
 
338
+  "cm<cmp>\t%<v>0<Vmtype>, %<v>1<Vmtype>, %<v>2<Vmtype>"
 
339
   [(set_attr "simd_type" "simd_cmp")
 
340
    (set_attr "simd_mode" "<MODE>")]
 
341
 )
 
342
 
 
343
-(define_insn_and_split "aarch64_cm<optab>di"
 
344
-  [(set (match_operand:DI 0 "register_operand" "=w,r")
 
345
-       (neg:DI
 
346
-         (UCOMPARISONS:DI
 
347
-           (match_operand:DI 1 "register_operand" "w,r")
 
348
-           (match_operand:DI 2 "aarch64_simd_reg_or_zero" "w,r")
 
349
-         )))]
 
350
-  "TARGET_SIMD"
 
351
-  "@
 
352
-  cm<n_optab>\t%d0, %d<cmp_1>, %d<cmp_2>
 
353
-  #"
 
354
-  "reload_completed
 
355
-   /* We need to prevent the split from
 
356
-      happening in the 'w' constraint cases.  */
 
357
-   && GP_REGNUM_P (REGNO (operands[0]))
 
358
-   && GP_REGNUM_P (REGNO (operands[1]))"
 
359
-  [(set (reg:CC CC_REGNUM)
 
360
-    (compare:CC
 
361
-      (match_dup 1)
 
362
-      (match_dup 2)))
 
363
-  (set (match_dup 0)
 
364
-    (neg:DI
 
365
-      (UCOMPARISONS:DI
 
366
-       (match_operand 3 "cc_register" "")
 
367
-       (const_int 0))))]
 
368
-  {
 
369
-    enum machine_mode mode = SELECT_CC_MODE (<CMP>, operands[1], operands[2]);
 
370
-    rtx cc_reg = aarch64_gen_compare_reg (<CMP>, operands[1], operands[2]);
 
371
-    rtx comparison = gen_rtx_<CMP> (mode, operands[1], operands[2]);
 
372
-    emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
 
373
-    DONE;
 
374
-  }
 
375
-  [(set_attr "simd_type" "simd_cmp")
 
376
-   (set_attr "simd_mode" "DI")]
 
377
-)
 
378
+;; fcm(eq|ge|le|lt|gt)
 
379
 
 
380
-;; cmtst
 
381
-
 
382
-(define_insn "aarch64_cmtst<mode>"
 
383
-  [(set (match_operand:<V_cmp_result> 0 "register_operand" "=w")
 
384
-       (neg:<V_cmp_result>
 
385
-         (ne:<V_cmp_result>
 
386
-           (and:VDQ
 
387
-             (match_operand:VDQ 1 "register_operand" "w")
 
388
-             (match_operand:VDQ 2 "register_operand" "w"))
 
389
-           (vec_duplicate:<V_cmp_result> (const_int 0)))))]
 
390
-  "TARGET_SIMD"
 
391
-  "cmtst\t%<v>0<Vmtype>, %<v>1<Vmtype>, %<v>2<Vmtype>"
 
392
-  [(set_attr "simd_type" "simd_cmp")
 
393
-   (set_attr "simd_mode" "<MODE>")]
 
394
-)
 
395
-
 
396
-(define_insn_and_split "aarch64_cmtstdi"
 
397
-  [(set (match_operand:DI 0 "register_operand" "=w,r")
 
398
-       (neg:DI
 
399
-         (ne:DI
 
400
-           (and:DI
 
401
-             (match_operand:DI 1 "register_operand" "w,r")
 
402
-             (match_operand:DI 2 "register_operand" "w,r"))
 
403
-           (const_int 0))))]
 
404
-  "TARGET_SIMD"
 
405
-  "@
 
406
-  cmtst\t%d0, %d1, %d2
 
407
-  #"
 
408
-  "reload_completed
 
409
-   /* We need to prevent the split from
 
410
-      happening in the 'w' constraint cases.  */
 
411
-   && GP_REGNUM_P (REGNO (operands[0]))
 
412
-   && GP_REGNUM_P (REGNO (operands[1]))"
 
413
-   [(set (reg:CC_NZ CC_REGNUM)
 
414
-       (compare:CC_NZ
 
415
-        (and:DI (match_dup 1)
 
416
-                 (match_dup 2))
 
417
-        (const_int 0)))
 
418
-  (set (match_dup 0)
 
419
-    (neg:DI
 
420
-      (ne:DI
 
421
-       (match_operand 3 "cc_register" "")
 
422
-       (const_int 0))))]
 
423
-  {
 
424
-    rtx and_tree = gen_rtx_AND (DImode, operands[1], operands[2]);
 
425
-    enum machine_mode mode = SELECT_CC_MODE (NE, and_tree, const0_rtx);
 
426
-    rtx cc_reg = aarch64_gen_compare_reg (NE, and_tree, const0_rtx);
 
427
-    rtx comparison = gen_rtx_NE (mode, and_tree, const0_rtx);
 
428
-    emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
 
429
-    DONE;
 
430
-  }
 
431
-  [(set_attr "simd_type" "simd_cmp")
 
432
-   (set_attr "simd_mode" "DI")]
 
433
-)
 
434
-
 
435
-;; fcm(eq|ge|gt|le|lt)
 
436
-
 
437
-(define_insn "aarch64_cm<optab><mode>"
 
438
+(define_insn "aarch64_cm<cmp><mode>"
 
439
   [(set (match_operand:<V_cmp_result> 0 "register_operand" "=w,w")
 
440
-       (neg:<V_cmp_result>
 
441
-         (COMPARISONS:<V_cmp_result>
 
442
-           (match_operand:VALLF 1 "register_operand" "w,w")
 
443
-           (match_operand:VALLF 2 "aarch64_simd_reg_or_zero" "w,YDz")
 
444
-         )))]
 
445
+       (unspec:<V_cmp_result>
 
446
+         [(match_operand:VDQF 1 "register_operand" "w,w")
 
447
+          (match_operand:VDQF 2 "aarch64_simd_reg_or_zero" "w,Dz")]
 
448
+          VCMP_S))]
 
449
   "TARGET_SIMD"
 
450
   "@
 
451
-  fcm<n_optab>\t%<v>0<Vmtype>, %<v><cmp_1><Vmtype>, %<v><cmp_2><Vmtype>
 
452
-  fcm<optab>\t%<v>0<Vmtype>, %<v>1<Vmtype>, 0"
 
453
+  fcm<cmp>\t%<v>0<Vmtype>, %<v>1<Vmtype>, %<v>2<Vmtype>
 
454
+  fcm<cmp>\t%<v>0<Vmtype>, %<v>1<Vmtype>, 0"
 
455
   [(set_attr "simd_type" "simd_fcmp")
 
456
    (set_attr "simd_mode" "<MODE>")]
 
457
 )
 
458
Index: gcc/config/aarch64/predicates.md
 
459
===================================================================
 
460
--- a/src/gcc/config/aarch64/predicates.md      (revision 206133)
 
461
+++ a/src/gcc/config/aarch64/predicates.md      (revision 206132)
 
462
@@ -31,11 +31,6 @@
 
463
        (ior (match_operand 0 "register_operand")
 
464
            (match_test "op == const0_rtx"))))
 
465
 
 
466
-(define_predicate "aarch64_reg_or_fp_zero"
 
467
-  (and (match_code "reg,subreg,const_double")
 
468
-       (ior (match_operand 0 "register_operand")
 
469
-           (match_test "aarch64_float_const_zero_rtx_p (op)"))))
 
470
-
 
471
 (define_predicate "aarch64_reg_zero_or_m1_or_1"
 
472
   (and (match_code "reg,subreg,const_int")
 
473
        (ior (match_operand 0 "register_operand")
 
474
Index: gcc/config/aarch64/arm_neon.h
 
475
===================================================================
 
476
--- a/src/gcc/config/aarch64/arm_neon.h (revision 206133)
 
477
+++ a/src/gcc/config/aarch64/arm_neon.h (revision 206132)
 
478
@@ -19551,28 +19551,28 @@
 
479
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 
480
 vcge_u8 (uint8x8_t __a, uint8x8_t __b)
 
481
 {
 
482
-  return (uint8x8_t) __builtin_aarch64_cmgeuv8qi ((int8x8_t) __a,
 
483
+  return (uint8x8_t) __builtin_aarch64_cmhsv8qi ((int8x8_t) __a,
 
484
                                                 (int8x8_t) __b);
 
485
 }
 
486
 
 
487
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 
488
 vcge_u16 (uint16x4_t __a, uint16x4_t __b)
 
489
 {
 
490
-  return (uint16x4_t) __builtin_aarch64_cmgeuv4hi ((int16x4_t) __a,
 
491
+  return (uint16x4_t) __builtin_aarch64_cmhsv4hi ((int16x4_t) __a,
 
492
                                                  (int16x4_t) __b);
 
493
 }
 
494
 
 
495
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 
496
 vcge_u32 (uint32x2_t __a, uint32x2_t __b)
 
497
 {
 
498
-  return (uint32x2_t) __builtin_aarch64_cmgeuv2si ((int32x2_t) __a,
 
499
+  return (uint32x2_t) __builtin_aarch64_cmhsv2si ((int32x2_t) __a,
 
500
                                                  (int32x2_t) __b);
 
501
 }
 
502
 
 
503
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
504
 vcge_u64 (uint64x1_t __a, uint64x1_t __b)
 
505
 {
 
506
-  return (uint64x1_t) __builtin_aarch64_cmgeudi ((int64x1_t) __a,
 
507
+  return (uint64x1_t) __builtin_aarch64_cmhsdi ((int64x1_t) __a,
 
508
                                                (int64x1_t) __b);
 
509
 }
 
510
 
 
511
@@ -19603,28 +19603,28 @@
 
512
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 
513
 vcgeq_u8 (uint8x16_t __a, uint8x16_t __b)
 
514
 {
 
515
-  return (uint8x16_t) __builtin_aarch64_cmgeuv16qi ((int8x16_t) __a,
 
516
+  return (uint8x16_t) __builtin_aarch64_cmhsv16qi ((int8x16_t) __a,
 
517
                                                   (int8x16_t) __b);
 
518
 }
 
519
 
 
520
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 
521
 vcgeq_u16 (uint16x8_t __a, uint16x8_t __b)
 
522
 {
 
523
-  return (uint16x8_t) __builtin_aarch64_cmgeuv8hi ((int16x8_t) __a,
 
524
+  return (uint16x8_t) __builtin_aarch64_cmhsv8hi ((int16x8_t) __a,
 
525
                                                  (int16x8_t) __b);
 
526
 }
 
527
 
 
528
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 
529
 vcgeq_u32 (uint32x4_t __a, uint32x4_t __b)
 
530
 {
 
531
-  return (uint32x4_t) __builtin_aarch64_cmgeuv4si ((int32x4_t) __a,
 
532
+  return (uint32x4_t) __builtin_aarch64_cmhsv4si ((int32x4_t) __a,
 
533
                                                  (int32x4_t) __b);
 
534
 }
 
535
 
 
536
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 
537
 vcgeq_u64 (uint64x2_t __a, uint64x2_t __b)
 
538
 {
 
539
-  return (uint64x2_t) __builtin_aarch64_cmgeuv2di ((int64x2_t) __a,
 
540
+  return (uint64x2_t) __builtin_aarch64_cmhsv2di ((int64x2_t) __a,
 
541
                                                  (int64x2_t) __b);
 
542
 }
 
543
 
 
544
@@ -19637,7 +19637,7 @@
 
545
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
546
 vcged_u64 (uint64x1_t __a, uint64x1_t __b)
 
547
 {
 
548
-  return (uint64x1_t) __builtin_aarch64_cmgeudi ((int64x1_t) __a,
 
549
+  return (uint64x1_t) __builtin_aarch64_cmhsdi ((int64x1_t) __a,
 
550
                                                (int64x1_t) __b);
 
551
 }
 
552
 
 
553
@@ -19676,28 +19676,28 @@
 
554
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 
555
 vcgt_u8 (uint8x8_t __a, uint8x8_t __b)
 
556
 {
 
557
-  return (uint8x8_t) __builtin_aarch64_cmgtuv8qi ((int8x8_t) __a,
 
558
+  return (uint8x8_t) __builtin_aarch64_cmhiv8qi ((int8x8_t) __a,
 
559
                                                 (int8x8_t) __b);
 
560
 }
 
561
 
 
562
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 
563
 vcgt_u16 (uint16x4_t __a, uint16x4_t __b)
 
564
 {
 
565
-  return (uint16x4_t) __builtin_aarch64_cmgtuv4hi ((int16x4_t) __a,
 
566
+  return (uint16x4_t) __builtin_aarch64_cmhiv4hi ((int16x4_t) __a,
 
567
                                                  (int16x4_t) __b);
 
568
 }
 
569
 
 
570
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 
571
 vcgt_u32 (uint32x2_t __a, uint32x2_t __b)
 
572
 {
 
573
-  return (uint32x2_t) __builtin_aarch64_cmgtuv2si ((int32x2_t) __a,
 
574
+  return (uint32x2_t) __builtin_aarch64_cmhiv2si ((int32x2_t) __a,
 
575
                                                  (int32x2_t) __b);
 
576
 }
 
577
 
 
578
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
579
 vcgt_u64 (uint64x1_t __a, uint64x1_t __b)
 
580
 {
 
581
-  return (uint64x1_t) __builtin_aarch64_cmgtudi ((int64x1_t) __a,
 
582
+  return (uint64x1_t) __builtin_aarch64_cmhidi ((int64x1_t) __a,
 
583
                                                (int64x1_t) __b);
 
584
 }
 
585
 
 
586
@@ -19728,28 +19728,28 @@
 
587
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 
588
 vcgtq_u8 (uint8x16_t __a, uint8x16_t __b)
 
589
 {
 
590
-  return (uint8x16_t) __builtin_aarch64_cmgtuv16qi ((int8x16_t) __a,
 
591
+  return (uint8x16_t) __builtin_aarch64_cmhiv16qi ((int8x16_t) __a,
 
592
                                                   (int8x16_t) __b);
 
593
 }
 
594
 
 
595
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 
596
 vcgtq_u16 (uint16x8_t __a, uint16x8_t __b)
 
597
 {
 
598
-  return (uint16x8_t) __builtin_aarch64_cmgtuv8hi ((int16x8_t) __a,
 
599
+  return (uint16x8_t) __builtin_aarch64_cmhiv8hi ((int16x8_t) __a,
 
600
                                                  (int16x8_t) __b);
 
601
 }
 
602
 
 
603
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 
604
 vcgtq_u32 (uint32x4_t __a, uint32x4_t __b)
 
605
 {
 
606
-  return (uint32x4_t) __builtin_aarch64_cmgtuv4si ((int32x4_t) __a,
 
607
+  return (uint32x4_t) __builtin_aarch64_cmhiv4si ((int32x4_t) __a,
 
608
                                                  (int32x4_t) __b);
 
609
 }
 
610
 
 
611
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 
612
 vcgtq_u64 (uint64x2_t __a, uint64x2_t __b)
 
613
 {
 
614
-  return (uint64x2_t) __builtin_aarch64_cmgtuv2di ((int64x2_t) __a,
 
615
+  return (uint64x2_t) __builtin_aarch64_cmhiv2di ((int64x2_t) __a,
 
616
                                                  (int64x2_t) __b);
 
617
 }
 
618
 
 
619
@@ -19762,7 +19762,7 @@
 
620
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
621
 vcgtd_u64 (uint64x1_t __a, uint64x1_t __b)
 
622
 {
 
623
-  return (uint64x1_t) __builtin_aarch64_cmgtudi ((int64x1_t) __a,
 
624
+  return (uint64x1_t) __builtin_aarch64_cmhidi ((int64x1_t) __a,
 
625
                                                (int64x1_t) __b);
 
626
 }
 
627
 
 
628
@@ -19801,28 +19801,28 @@
 
629
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 
630
 vcle_u8 (uint8x8_t __a, uint8x8_t __b)
 
631
 {
 
632
-  return (uint8x8_t) __builtin_aarch64_cmgeuv8qi ((int8x8_t) __b,
 
633
+  return (uint8x8_t) __builtin_aarch64_cmhsv8qi ((int8x8_t) __b,
 
634
                                                 (int8x8_t) __a);
 
635
 }
 
636
 
 
637
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 
638
 vcle_u16 (uint16x4_t __a, uint16x4_t __b)
 
639
 {
 
640
-  return (uint16x4_t) __builtin_aarch64_cmgeuv4hi ((int16x4_t) __b,
 
641
+  return (uint16x4_t) __builtin_aarch64_cmhsv4hi ((int16x4_t) __b,
 
642
                                                  (int16x4_t) __a);
 
643
 }
 
644
 
 
645
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 
646
 vcle_u32 (uint32x2_t __a, uint32x2_t __b)
 
647
 {
 
648
-  return (uint32x2_t) __builtin_aarch64_cmgeuv2si ((int32x2_t) __b,
 
649
+  return (uint32x2_t) __builtin_aarch64_cmhsv2si ((int32x2_t) __b,
 
650
                                                  (int32x2_t) __a);
 
651
 }
 
652
 
 
653
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
654
 vcle_u64 (uint64x1_t __a, uint64x1_t __b)
 
655
 {
 
656
-  return (uint64x1_t) __builtin_aarch64_cmgeudi ((int64x1_t) __b,
 
657
+  return (uint64x1_t) __builtin_aarch64_cmhsdi ((int64x1_t) __b,
 
658
                                                (int64x1_t) __a);
 
659
 }
 
660
 
 
661
@@ -19853,28 +19853,28 @@
 
662
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 
663
 vcleq_u8 (uint8x16_t __a, uint8x16_t __b)
 
664
 {
 
665
-  return (uint8x16_t) __builtin_aarch64_cmgeuv16qi ((int8x16_t) __b,
 
666
+  return (uint8x16_t) __builtin_aarch64_cmhsv16qi ((int8x16_t) __b,
 
667
                                                   (int8x16_t) __a);
 
668
 }
 
669
 
 
670
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 
671
 vcleq_u16 (uint16x8_t __a, uint16x8_t __b)
 
672
 {
 
673
-  return (uint16x8_t) __builtin_aarch64_cmgeuv8hi ((int16x8_t) __b,
 
674
+  return (uint16x8_t) __builtin_aarch64_cmhsv8hi ((int16x8_t) __b,
 
675
                                                  (int16x8_t) __a);
 
676
 }
 
677
 
 
678
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 
679
 vcleq_u32 (uint32x4_t __a, uint32x4_t __b)
 
680
 {
 
681
-  return (uint32x4_t) __builtin_aarch64_cmgeuv4si ((int32x4_t) __b,
 
682
+  return (uint32x4_t) __builtin_aarch64_cmhsv4si ((int32x4_t) __b,
 
683
                                                  (int32x4_t) __a);
 
684
 }
 
685
 
 
686
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 
687
 vcleq_u64 (uint64x2_t __a, uint64x2_t __b)
 
688
 {
 
689
-  return (uint64x2_t) __builtin_aarch64_cmgeuv2di ((int64x2_t) __b,
 
690
+  return (uint64x2_t) __builtin_aarch64_cmhsv2di ((int64x2_t) __b,
 
691
                                                  (int64x2_t) __a);
 
692
 }
 
693
 
 
694
@@ -19919,28 +19919,28 @@
 
695
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 
696
 vclt_u8 (uint8x8_t __a, uint8x8_t __b)
 
697
 {
 
698
-  return (uint8x8_t) __builtin_aarch64_cmgtuv8qi ((int8x8_t) __b,
 
699
+  return (uint8x8_t) __builtin_aarch64_cmhiv8qi ((int8x8_t) __b,
 
700
                                                 (int8x8_t) __a);
 
701
 }
 
702
 
 
703
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 
704
 vclt_u16 (uint16x4_t __a, uint16x4_t __b)
 
705
 {
 
706
-  return (uint16x4_t) __builtin_aarch64_cmgtuv4hi ((int16x4_t) __b,
 
707
+  return (uint16x4_t) __builtin_aarch64_cmhiv4hi ((int16x4_t) __b,
 
708
                                                  (int16x4_t) __a);
 
709
 }
 
710
 
 
711
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 
712
 vclt_u32 (uint32x2_t __a, uint32x2_t __b)
 
713
 {
 
714
-  return (uint32x2_t) __builtin_aarch64_cmgtuv2si ((int32x2_t) __b,
 
715
+  return (uint32x2_t) __builtin_aarch64_cmhiv2si ((int32x2_t) __b,
 
716
                                                  (int32x2_t) __a);
 
717
 }
 
718
 
 
719
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 
720
 vclt_u64 (uint64x1_t __a, uint64x1_t __b)
 
721
 {
 
722
-  return (uint64x1_t) __builtin_aarch64_cmgtudi ((int64x1_t) __b,
 
723
+  return (uint64x1_t) __builtin_aarch64_cmhidi ((int64x1_t) __b,
 
724
                                                (int64x1_t) __a);
 
725
 }
 
726
 
 
727
@@ -19971,28 +19971,28 @@
 
728
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 
729
 vcltq_u8 (uint8x16_t __a, uint8x16_t __b)
 
730
 {
 
731
-  return (uint8x16_t) __builtin_aarch64_cmgtuv16qi ((int8x16_t) __b,
 
732
+  return (uint8x16_t) __builtin_aarch64_cmhiv16qi ((int8x16_t) __b,
 
733
                                                   (int8x16_t) __a);
 
734
 }
 
735
 
 
736
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 
737
 vcltq_u16 (uint16x8_t __a, uint16x8_t __b)
 
738
 {
 
739
-  return (uint16x8_t) __builtin_aarch64_cmgtuv8hi ((int16x8_t) __b,
 
740
+  return (uint16x8_t) __builtin_aarch64_cmhiv8hi ((int16x8_t) __b,
 
741
                                                  (int16x8_t) __a);
 
742
 }
 
743
 
 
744
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 
745
 vcltq_u32 (uint32x4_t __a, uint32x4_t __b)
 
746
 {
 
747
-  return (uint32x4_t) __builtin_aarch64_cmgtuv4si ((int32x4_t) __b,
 
748
+  return (uint32x4_t) __builtin_aarch64_cmhiv4si ((int32x4_t) __b,
 
749
                                                  (int32x4_t) __a);
 
750
 }
 
751
 
 
752
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 
753
 vcltq_u64 (uint64x2_t __a, uint64x2_t __b)
 
754
 {
 
755
-  return (uint64x2_t) __builtin_aarch64_cmgtuv2di ((int64x2_t) __b,
 
756
+  return (uint64x2_t) __builtin_aarch64_cmhiv2di ((int64x2_t) __b,
 
757
                                                  (int64x2_t) __a);
 
758
 }
 
759
 
 
760
Index: gcc/config/aarch64/aarch64.md
 
761
===================================================================
 
762
--- a/src/gcc/config/aarch64/aarch64.md (revision 206133)
 
763
+++ a/src/gcc/config/aarch64/aarch64.md (revision 206132)
 
764
@@ -2211,7 +2211,7 @@
 
765
    (set_attr "mode" "SI")]
 
766
 )
 
767
 
 
768
-(define_insn "cstore<mode>_neg"
 
769
+(define_insn "*cstore<mode>_neg"
 
770
   [(set (match_operand:ALLI 0 "register_operand" "=r")
 
771
        (neg:ALLI (match_operator:ALLI 1 "aarch64_comparison_operator"
 
772
                  [(match_operand 2 "cc_register" "") (const_int 0)])))]
 
773
Index: gcc/config/aarch64/aarch64-simd-builtins.def
 
774
===================================================================
 
775
--- a/src/gcc/config/aarch64/aarch64-simd-builtins.def  (revision 206133)
 
776
+++ a/src/gcc/config/aarch64/aarch64-simd-builtins.def  (revision 206132)
 
777
@@ -217,8 +217,8 @@
 
778
   BUILTIN_VSDQ_I_DI (BINOP, cmle)
 
779
   BUILTIN_VSDQ_I_DI (BINOP, cmlt)
 
780
   /* Implemented by aarch64_cm<cmp><mode>.  */
 
781
-  BUILTIN_VSDQ_I_DI (BINOP, cmgeu)
 
782
-  BUILTIN_VSDQ_I_DI (BINOP, cmgtu)
 
783
+  BUILTIN_VSDQ_I_DI (BINOP, cmhs)
 
784
+  BUILTIN_VSDQ_I_DI (BINOP, cmhi)
 
785
   BUILTIN_VSDQ_I_DI (BINOP, cmtst)
 
786
 
 
787
   /* Implemented by aarch64_<fmaxmin><mode>.  */
 
788
Index: gcc/config/aarch64/iterators.md
 
789
===================================================================
 
790
--- a/src/gcc/config/aarch64/iterators.md       (revision 206133)
 
791
+++ a/src/gcc/config/aarch64/iterators.md       (revision 206132)
 
792
@@ -83,9 +83,6 @@
 
793
 ;; Vector Float modes.
 
794
 (define_mode_iterator VDQF [V2SF V4SF V2DF])
 
795
 
 
796
-;; All Float modes.
 
797
-(define_mode_iterator VALLF [V2SF V4SF V2DF SF DF])
 
798
-
 
799
 ;; Vector Float modes with 2 elements.
 
800
 (define_mode_iterator V2F [V2SF V2DF])
 
801
 
 
802
@@ -216,6 +213,13 @@
 
803
     UNSPEC_URSHL       ; Used in aarch64-simd.md.
 
804
     UNSPEC_SQRSHL      ; Used in aarch64-simd.md.
 
805
     UNSPEC_UQRSHL      ; Used in aarch64-simd.md.
 
806
+    UNSPEC_CMEQ                ; Used in aarch64-simd.md.
 
807
+    UNSPEC_CMLE                ; Used in aarch64-simd.md.
 
808
+    UNSPEC_CMLT                ; Used in aarch64-simd.md.
 
809
+    UNSPEC_CMGE                ; Used in aarch64-simd.md.
 
810
+    UNSPEC_CMGT                ; Used in aarch64-simd.md.
 
811
+    UNSPEC_CMHS                ; Used in aarch64-simd.md.
 
812
+    UNSPEC_CMHI                ; Used in aarch64-simd.md.
 
813
     UNSPEC_SSLI                ; Used in aarch64-simd.md.
 
814
     UNSPEC_USLI                ; Used in aarch64-simd.md.
 
815
     UNSPEC_SSRI                ; Used in aarch64-simd.md.
 
816
@@ -223,6 +227,7 @@
 
817
     UNSPEC_SSHLL       ; Used in aarch64-simd.md.
 
818
     UNSPEC_USHLL       ; Used in aarch64-simd.md.
 
819
     UNSPEC_ADDP                ; Used in aarch64-simd.md.
 
820
+    UNSPEC_CMTST       ; Used in aarch64-simd.md.
 
821
     UNSPEC_FMAX                ; Used in aarch64-simd.md.
 
822
     UNSPEC_FMIN                ; Used in aarch64-simd.md.
 
823
     UNSPEC_BSL         ; Used in aarch64-simd.md.
 
824
@@ -246,7 +251,6 @@
 
825
 
 
826
 ;; For scalar usage of vector/FP registers
 
827
 (define_mode_attr v [(QI "b") (HI "h") (SI "s") (DI "d")
 
828
-                   (SF "s") (DF "d")
 
829
                    (V8QI "") (V16QI "")
 
830
                    (V4HI "") (V8HI "")
 
831
                    (V2SI "") (V4SI  "")
 
832
@@ -301,8 +305,7 @@
 
833
                         (V4SF ".4s") (V2DF ".2d")
 
834
                         (DI   "")    (SI   "")
 
835
                         (HI   "")    (QI   "")
 
836
-                        (TI   "")    (SF   "")
 
837
-                        (DF   "")])
 
838
+                        (TI   "")])
 
839
 
 
840
 ;; Register suffix narrowed modes for VQN.
 
841
 (define_mode_attr Vmntype [(V8HI ".8b") (V4SI ".4h")
 
842
@@ -441,8 +444,7 @@
 
843
                                (V2SI "V2SI") (V4SI  "V4SI")
 
844
                                (DI   "DI")   (V2DI  "V2DI")
 
845
                                (V2SF "V2SI") (V4SF  "V4SI")
 
846
-                               (V2DF "V2DI") (DF    "DI")
 
847
-                               (SF   "SI")])
 
848
+                               (V2DF "V2DI")])
 
849
 
 
850
 ;; Lower case mode of results of comparison operations.
 
851
 (define_mode_attr v_cmp_result [(V8QI "v8qi") (V16QI "v16qi")
 
852
@@ -450,8 +452,7 @@
 
853
                                (V2SI "v2si") (V4SI  "v4si")
 
854
                                (DI   "di")   (V2DI  "v2di")
 
855
                                (V2SF "v2si") (V4SF  "v4si")
 
856
-                               (V2DF "v2di") (DF    "di")
 
857
-                               (SF   "si")])
 
858
+                               (V2DF "v2di")])
 
859
 
 
860
 ;; Vm for lane instructions is restricted to FP_LO_REGS.
 
861
 (define_mode_attr vwx [(V4HI "x") (V8HI "x") (HI "x")
 
862
@@ -542,12 +543,6 @@
 
863
 ;; Code iterator for signed variants of vector saturating binary ops.
 
864
 (define_code_iterator SBINQOPS [ss_plus ss_minus])
 
865
 
 
866
-;; Comparison operators for <F>CM.
 
867
-(define_code_iterator COMPARISONS [lt le eq ge gt])
 
868
-
 
869
-;; Unsigned comparison operators.
 
870
-(define_code_iterator UCOMPARISONS [ltu leu geu gtu])
 
871
-
 
872
 ;; -------------------------------------------------------------------
 
873
 ;; Code Attributes
 
874
 ;; -------------------------------------------------------------------
 
875
@@ -576,29 +571,8 @@
 
876
                         (eq "eq")
 
877
                         (ne "ne")
 
878
                         (lt "lt")
 
879
-                        (ge "ge")
 
880
-                        (le "le")
 
881
-                        (gt "gt")
 
882
-                        (ltu "ltu")
 
883
-                        (leu "leu")
 
884
-                        (geu "geu")
 
885
-                        (gtu "gtu")])
 
886
+                        (ge "ge")])
 
887
 
 
888
-;; For comparison operators we use the FCM* and CM* instructions.
 
889
-;; As there are no CMLE or CMLT instructions which act on 3 vector
 
890
-;; operands, we must use CMGE or CMGT and swap the order of the
 
891
-;; source operands.
 
892
-
 
893
-(define_code_attr n_optab [(lt "gt") (le "ge") (eq "eq") (ge "ge") (gt "gt")
 
894
-                          (ltu "hi") (leu "hs") (geu "hs") (gtu "hi")])
 
895
-(define_code_attr cmp_1   [(lt "2") (le "2") (eq "1") (ge "1") (gt "1")
 
896
-                          (ltu "2") (leu "2") (geu "1") (gtu "1")])
 
897
-(define_code_attr cmp_2   [(lt "1") (le "1") (eq "2") (ge "2") (gt "2")
 
898
-                          (ltu "1") (leu "1") (geu "2") (gtu "2")])
 
899
-
 
900
-(define_code_attr CMP [(lt "LT") (le "LE") (eq "EQ") (ge "GE") (gt "GT")
 
901
-                          (ltu "LTU") (leu "LEU") (geu "GEU") (gtu "GTU")])
 
902
-
 
903
 ;; Optab prefix for sign/zero-extending operations
 
904
 (define_code_attr su_optab [(sign_extend "") (zero_extend "u")
 
905
                            (div "") (udiv "u")
 
906
@@ -706,6 +680,11 @@
 
907
                                UNSPEC_SQSHRN UNSPEC_UQSHRN
 
908
                                UNSPEC_SQRSHRN UNSPEC_UQRSHRN])
 
909
 
 
910
+(define_int_iterator VCMP_S [UNSPEC_CMEQ UNSPEC_CMGE UNSPEC_CMGT
 
911
+                            UNSPEC_CMLE UNSPEC_CMLT])
 
912
+
 
913
+(define_int_iterator VCMP_U [UNSPEC_CMHS UNSPEC_CMHI UNSPEC_CMTST])
 
914
+
 
915
 (define_int_iterator PERMUTE [UNSPEC_ZIP1 UNSPEC_ZIP2
 
916
                              UNSPEC_TRN1 UNSPEC_TRN2
 
917
                              UNSPEC_UZP1 UNSPEC_UZP2])
 
918
@@ -789,6 +768,12 @@
 
919
                         (UNSPEC_RADDHN2 "add")
 
920
                         (UNSPEC_RSUBHN2 "sub")])
 
921
 
 
922
+(define_int_attr cmp [(UNSPEC_CMGE "ge") (UNSPEC_CMGT "gt")
 
923
+                     (UNSPEC_CMLE "le") (UNSPEC_CMLT "lt")
 
924
+                      (UNSPEC_CMEQ "eq")
 
925
+                     (UNSPEC_CMHS "hs") (UNSPEC_CMHI "hi")
 
926
+                     (UNSPEC_CMTST "tst")])
 
927
+
 
928
 (define_int_attr offsetlr [(UNSPEC_SSLI        "1") (UNSPEC_USLI "1")
 
929
                           (UNSPEC_SSRI "0") (UNSPEC_USRI "0")])
 
930