VAX: Correct `sync_lock_test_and_set' and `sync_lock_release' builtins

Remove an ICE like:

during RTL pass: expand
.../libatomic/tas_n.c: In function 'libat_test_and_set_1':
.../libatomic/tas_n.c:39:1: internal compiler error: in patch_jump_insn, at cfgrtl.c:1298
   39 | }
      | ^
0x108a09ff patch_jump_insn
	.../gcc/cfgrtl.c:1298
0x108a0b07 redirect_branch_edge
	.../gcc/cfgrtl.c:1325
0x108a124b rtl_redirect_edge_and_branch
	.../gcc/cfgrtl.c:1458
0x1087f6d3 redirect_edge_and_branch(edge_def*, basic_block_def*)
	.../gcc/cfghooks.c:373
0x11d6264b try_forward_edges
	.../gcc/cfgcleanup.c:562
0x11d6b0eb try_optimize_cfg
	.../gcc/cfgcleanup.c:2960
0x11d6ba4f cleanup_cfg(int)
	.../gcc/cfgcleanup.c:3174
0x10870b3f execute
	.../gcc/cfgexpand.c:6763

triggered with an RTL pattern like:

(jump_insn 8 7 20 2 (parallel [
            (set (pc)
                (if_then_else (ne (zero_extract:SI (mem/v:QI (mem/f/c:SI (reg/f:SI 16 virtual-incoming-args) [1 mptr+0 S4 A32]) [-1  S1 A8])
                            (const_int 1 [0x1])
                            (const_int 0 [0]))
                        (const_int 0 [0]))
                    (label_ref 10)
                    (pc)))
            (set (zero_extract:SI (mem/v:QI (mem/f/c:SI (reg/f:SI 16 virtual-incoming-args) [1 mptr+0 S4 A32]) [-1  S1 A8])
                    (const_int 1 [0x1])
                    (const_int 0 [0]))
                (const_int 1 [0x1]))
        ]) ".../libatomic/tas_n.c":38:12 -1
     (nil)
 -> 10)

caused by a volatile memory reference used that is not accepted by the
`memory_operand' predicate of the `jbbssiqi' insn explicitly referred
from the `sync_lock_test_and_setqi' expander.  Also seen with:

FAIL: gcc.dg/pr61756.c (internal compiler error)

Define a new `any_memory_operand' predicate accepting both ordinary and
volatile memory references and use it with the `jbb<ccss>i<mode>' insn,
so as to address the ICE.

Also remove useless operations from the `sync_lock_test_and_set<mode>'
and `sync_lock_release<mode>' expanders as those always either complete
or fail and therefore never fall through to using their template other
than to match operands.  Wrap `jbb<ccss>i<mode>' into `unspec_volatile'
instead so that the jump does not get removed or reordered.  Share one
index to avoid a complication around the iterators since the index is
nowhere referred to anyway and the pattern required pulled by its name.

Test cases will be added separately.

	gcc/
	* config/vax/predicates.md (volatile_mem_operand)
	(any_memory_operand): New predicates.
	* config/vax/builtins.md (VUNSPEC_UNLOCK): Remove constant.
	(sync_lock_test_and_set<mode>): Remove `set' and `unspec'
	operations, match operands only.  Reformat.
	(sync_lock_release<mode>): Likewise.  Remove cruft.
	(jbb<ccss>i<mode>): Wrap into `unspec_volatile', use
	`any_memory_operand' predicate.

diff --git a/gcc/config/vax/builtins.md b/gcc/config/vax/builtins.md
index 8bbcd603d13c4f2ac3d6048b4c007f3fc3be2dff..7e27854a8b088b454d7e150faa6f4a3802cc87c5 100644 (file)
--- a/gcc/config/vax/builtins.md
+++ b/gcc/config/vax/builtins.md
@@ -19,8 +19,7 @@
 
 (define_constants
   [
-    (VUNSPEC_LOCK 100)         ; sync lock and test
-    (VUNSPEC_UNLOCK 101)       ; sync lock release
+    (VUNSPEC_LOCK 100)         ; sync lock operations
   ]
 )
 
@@ -58,10 +57,9 @@
   "ffs $0,$32,%1,%0")
 
 (define_expand "sync_lock_test_and_set<mode>"
-  [(set (match_operand:VAXint 0 "nonimmediate_operand" "=&g")
-       (unspec:VAXint [(match_operand:VAXint 1 "memory_operand" "+m")
-                   (match_operand:VAXint 2 "const_int_operand" "n")
-                  ] VUNSPEC_LOCK))]
+  [(match_operand:VAXint 0 "nonimmediate_operand" "=&g")
+   (match_operand:VAXint 1 "memory_operand" "+m")
+   (match_operand:VAXint 2 "const_int_operand" "n")]
   ""
   "
 {
@@ -72,46 +70,46 @@
 
   label = gen_label_rtx ();
   emit_move_insn (operands[0], const1_rtx);
-  emit_jump_insn (gen_jbbssi<mode> (operands[1], const0_rtx, label, operands[1]));
+  emit_jump_insn (gen_jbbssi<mode> (operands[1], const0_rtx, label,
+                                   operands[1]));
   emit_move_insn (operands[0], const0_rtx);
   emit_label (label);
   DONE;
 }")
 
 (define_expand "sync_lock_release<mode>"
-  [(set (match_operand:VAXint 0 "memory_operand" "+m")
-       (unspec:VAXint [(match_operand:VAXint 1 "const_int_operand" "n")
-                  ] VUNSPEC_UNLOCK))]
+  [(match_operand:VAXint 0 "memory_operand" "+m")
+   (match_operand:VAXint 1 "const_int_operand" "n")]
   ""
   "
 {
   rtx label;
+
   if (operands[1] != const0_rtx)
     FAIL;
-#if 1
+
   label = gen_label_rtx ();
-  emit_jump_insn (gen_jbbcci<mode> (operands[0], const0_rtx, label, operands[0]));
+  emit_jump_insn (gen_jbbcci<mode> (operands[0], const0_rtx, label,
+                                   operands[0]));
   emit_label (label);
-#else
-  emit_move_insn (operands[0], const0_rtx);
-#endif
   DONE;
 }")
 
 (define_insn "jbb<ccss>i<mode>"
-  [(parallel
+  [(unspec_volatile
     [(set (pc)
          (if_then_else
            (eq (zero_extract:SI
-                 (match_operand:VAXint 0 "memory_operand" "<bb_mem>")
+                 (match_operand:VAXint 0 "any_memory_operand" "<bb_mem>")
                  (const_int 1)
                  (match_operand:SI 1 "general_operand" "nrmT"))
                (const_int bit))
            (label_ref (match_operand 2 "" ""))
            (pc)))
-     (set (zero_extract:SI (match_operand:VAXint 3 "memory_operand" "+0")
+     (set (zero_extract:SI (match_operand:VAXint 3 "any_memory_operand" "+0")
                           (const_int 1)
                           (match_dup 1))
-         (const_int bit))])]
+         (const_int bit))]
+    VUNSPEC_LOCK)]
   ""
   "jb<ccss>i %1,%0,%l2")

diff --git a/gcc/config/vax/predicates.md b/gcc/config/vax/predicates.md
index 93e91e499a6755c82b07646073642090c0bff821..7c97b36660471d3c51c709a3989650393290a327 100644 (file)
--- a/gcc/config/vax/predicates.md
+++ b/gcc/config/vax/predicates.md
@@ -93,3 +93,19 @@
    (and (match_code "const_int,const_double,subreg,reg,mem")
        (and (match_operand:DI 0 "general_operand" "")
             (not (match_operand:DI 0 "illegal_addsub_di_memory_operand")))))
+
+;; Return 1 if the operand is in volatile memory.  Note that during the
+;; RTL generation phase, `memory_operand' does not return TRUE for
+;; volatile memory references.  So this function allows us to recognize
+;; volatile references where it's safe.
+(define_predicate "volatile_mem_operand"
+  (and (match_code "mem")
+       (match_test "MEM_VOLATILE_P (op)")
+       (if_then_else (match_test "reload_completed")
+        (match_operand 0 "memory_operand")
+        (match_test "memory_address_p (mode, XEXP (op, 0))"))))
+
+;; Return 1 if the operand is a volatile or non-volatile memory operand.
+(define_predicate "any_memory_operand"
+  (ior (match_operand 0 "memory_operand")
+       (match_operand 0 "volatile_mem_operand")))