[hardbool] implement OP=, ++ and --, volatile and atomics

hardbools didn't behave quite like bools when incremented,
decremented, or otherwise modified using their previous value, as in
+= et al.  Fix that.

Also fix some checking errors that come up when using qualified base
types.

for  gcc/c-family/ChangeLog

	* c-attribs.cc (handle_hardbool_attribute): Create distinct
	enumeration types, with structural equality.  Handle
	base type qualifiers.

for  gcc/c/ChangeLog

	* c-tree.h (C_BOOLEAN_TYPE_P): Cover hardbools as well.
	* c-typeck.cc (convert_lvalue_to_rvalue): New overload and
	wrapper.
	(build_atomic_assign, build_modify_expr): Use it.
	(build_asm_expr, handle_omp-array_sections_1): Simplify with
	it.
	(build_unary_op): Handle hardbools.

for  gcc/testsuite/ChangeLog

	* gcc.dg/torture/hardbool-ai.c: New.
	* gcc.dg/torture/hardbool-vi.c: New.
	* gcc.dg/torture/hardbool.c: Handle NO_BITFIELDS.
	(add1, preinc, postinc, sub1, predec, postdec): New.
	(main): Exercise them.

diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc
index a0d832b5e056759c91c9cb3991aab04efdf80947..041a00479bd9dcb8f51252e6578de3a243bda0c0 100644 (file)
--- a/gcc/c-family/c-attribs.cc
+++ b/gcc/c-family/c-attribs.cc
@@ -1128,11 +1128,16 @@ handle_hardbool_attribute (tree *node, tree name, tree args,
     }
 
   tree orig = *node;
-  *node = build_duplicate_type (orig);
+  /* Drop qualifiers from the base type.  Keep attributes, so that, in the odd
+     chance attributes are applicable and relevant to the base type, if they
+     are specified first, or through a typedef, they wouldn't be dropped on the
+     floor here.  */
+  tree unqual = build_qualified_type (orig, TYPE_UNQUALIFIED);
+  *node = build_distinct_type_copy (unqual);
 
   TREE_SET_CODE (*node, ENUMERAL_TYPE);
-  ENUM_UNDERLYING_TYPE (*node) = orig;
-  TYPE_CANONICAL (*node) = TYPE_CANONICAL (orig);
+  ENUM_UNDERLYING_TYPE (*node) = unqual;
+  SET_TYPE_STRUCTURAL_EQUALITY (*node);
 
   tree false_value;
   if (args)
@@ -1191,7 +1196,13 @@ handle_hardbool_attribute (tree *node, tree name, tree args,
 
   gcc_checking_assert (!TYPE_CACHED_VALUES_P (*node));
   TYPE_VALUES (*node) = values;
-  TYPE_NAME (*node) = orig;
+  TYPE_NAME (*node) = unqual;
+
+  if (TYPE_QUALS (orig) != TYPE_QUALS (*node))
+    {
+      *node = build_qualified_type (*node, TYPE_QUALS (orig));
+      TYPE_NAME (*node) = orig;
+    }
 
   return NULL_TREE;
 }

diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index bb0b113754e5e7377495d9a480a34afcb6dc6bec..dba94abd1a9843d0b13dad50d9480a25340a0435 100644 (file)
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -163,7 +163,8 @@ along with GCC; see the file COPYING3.  If not see
   (TREE_CODE (TYPE) == BOOLEAN_TYPE                                    \
    || (TREE_CODE (TYPE) == ENUMERAL_TYPE                               \
        && ENUM_UNDERLYING_TYPE (TYPE) != NULL_TREE                     \
-       && TREE_CODE (ENUM_UNDERLYING_TYPE (TYPE)) == BOOLEAN_TYPE))
+       && (TREE_CODE (ENUM_UNDERLYING_TYPE (TYPE)) == BOOLEAN_TYPE     \
+          || c_hardbool_type_attr (TYPE))))
 
 /* Record parser information about an expression that is irrelevant
    for code generation alongside a tree representing its value.  */

diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index d1d217e199850dda1fed116f1eaa13c3a2d7957a..7a95f72c5f2dc4ff1026e7d69c046ccf0024a806 100644 (file)
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -2680,6 +2680,20 @@ convert_lvalue_to_rvalue (location_t loc, struct c_expr exp,
   return exp;
 }
 
+/* Wrapper for the overload above, same arguments but for tree rather than
+   c_expr.  This is important for hardbools to decay to bools.  */
+
+static inline tree
+convert_lvalue_to_rvalue (location_t loc, tree val,
+                         bool convert_p, bool read_p, bool for_init = false)
+{
+  struct c_expr expr;
+  memset (&expr, 0, sizeof (expr));
+  expr.value = val;
+  expr = convert_lvalue_to_rvalue (loc, expr, convert_p, read_p, for_init);
+  return expr.value;
+}
+
 /* EXP is an expression of integer type.  Apply the integer promotions
    to it and return the promoted value.  */
 
@@ -5303,7 +5317,9 @@ cas_loop:
   /* newval = old + val;  */
   if (rhs_type != rhs_semantic_type)
     val = build1 (EXCESS_PRECISION_EXPR, nonatomic_rhs_semantic_type, val);
-  rhs = build_binary_op (loc, modifycode, old, val, true);
+  rhs = build_binary_op (loc, modifycode,
+                        convert_lvalue_to_rvalue (loc, old, true, true),
+                        val, true);
   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
     {
       tree eptype = TREE_TYPE (rhs);
@@ -5759,7 +5775,48 @@ build_unary_op (location_t location, enum tree_code code, tree xarg,
            goto return_build_unary_op;
          }
 
-       if (C_BOOLEAN_TYPE_P (TREE_TYPE (arg)))
+       tree true_res;
+       if (c_hardbool_type_attr (TREE_TYPE (arg), NULL, &true_res))
+         {
+           tree larg = stabilize_reference (arg);
+           tree sarg = save_expr (larg);
+           switch (code)
+             {
+             case PREINCREMENT_EXPR:
+               val = build2 (MODIFY_EXPR, TREE_TYPE (larg), larg, true_res);
+               val = build2 (COMPOUND_EXPR, TREE_TYPE (larg), sarg, val);
+               break;
+             case POSTINCREMENT_EXPR:
+               val = build2 (MODIFY_EXPR, TREE_TYPE (larg), larg, true_res);
+               val = build2 (COMPOUND_EXPR, TREE_TYPE (larg), val, sarg);
+               val = build2 (COMPOUND_EXPR, TREE_TYPE (larg), sarg, val);
+               break;
+             case PREDECREMENT_EXPR:
+               {
+                 tree rarg = convert_lvalue_to_rvalue (location, sarg,
+                                                       true, true);
+                 rarg = invert_truthvalue_loc (location, rarg);
+                 rarg = convert (TREE_TYPE (sarg), rarg);
+                 val = build2 (MODIFY_EXPR, TREE_TYPE (larg), larg, rarg);
+               }
+               break;
+             case POSTDECREMENT_EXPR:
+               {
+                 tree rarg = convert_lvalue_to_rvalue (location, sarg,
+                                                       true, true);
+                 rarg = invert_truthvalue_loc (location, rarg);
+                 tree iarg = convert (TREE_TYPE (larg), rarg);
+                 val = build2 (MODIFY_EXPR, TREE_TYPE (larg), larg, iarg);
+                 val = build2 (COMPOUND_EXPR, TREE_TYPE (larg), val, sarg);
+                 val = build2 (COMPOUND_EXPR, TREE_TYPE (larg), sarg, val);
+               }
+               break;
+             default:
+               gcc_unreachable ();
+             }
+           TREE_SIDE_EFFECTS (val) = 1;
+         }
+       else if (C_BOOLEAN_TYPE_P (TREE_TYPE (arg)))
          val = boolean_increment (code, arg);
        else
          val = build2 (code, TREE_TYPE (arg), arg, inc);
@@ -7372,8 +7429,10 @@ build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
                clear_decl_read = true;
            }
 
-         newrhs = build_binary_op (location,
-                                   modifycode, lhs, newrhs, true);
+         newrhs = build_binary_op (location, modifycode,
+                                   convert_lvalue_to_rvalue (location, lhs,
+                                                             true, true),
+                                   newrhs, true);
          if (clear_decl_read)
            DECL_READ_P (lhs) = 0;
 
@@ -12765,11 +12824,9 @@ build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
            }
          else
            {
-             struct c_expr expr;
-             memset (&expr, 0, sizeof (expr));
-             expr.value = input;
-             expr = convert_lvalue_to_rvalue (loc, expr, true, false);
-             input = c_fully_fold (expr.value, false, NULL);
+             input = c_fully_fold (convert_lvalue_to_rvalue (loc, input,
+                                                             true, false),
+                                   false, NULL);
 
              if (input != error_mark_node && VOID_TYPE_P (TREE_TYPE (input)))
                {
@@ -15391,12 +15448,8 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
          /* If the array section is pointer based and the pointer
             itself is _Atomic qualified, we need to atomically load
             the pointer.  */
-         c_expr expr;
-         memset (&expr, 0, sizeof (expr));
-         expr.value = ret;
-         expr = convert_lvalue_to_rvalue (OMP_CLAUSE_LOCATION (c),
-                                          expr, false, false);
-         ret = expr.value;
+         ret = convert_lvalue_to_rvalue (OMP_CLAUSE_LOCATION (c),
+                                         ret, false, false);
        }
       return ret;
     }

diff --git a/gcc/testsuite/gcc.dg/torture/hardbool-ai.c b/gcc/testsuite/gcc.dg/torture/hardbool-ai.c
new file mode 100644 (file)
index 0000000..97569a6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/hardbool-ai.c
@@ -0,0 +1,7 @@
+/* { dg-do run } */
+
+#define basetype _Atomic int
+
+#define NO_BITFIELDS 1
+
+#include "hardbool.c"

diff --git a/gcc/testsuite/gcc.dg/torture/hardbool-vi.c b/gcc/testsuite/gcc.dg/torture/hardbool-vi.c
new file mode 100644 (file)
index 0000000..898d395
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/hardbool-vi.c
@@ -0,0 +1,5 @@
+/* { dg-do run } */
+
+#define basetype volatile int
+
+#include "hardbool.c"

diff --git a/gcc/testsuite/gcc.dg/torture/hardbool.c b/gcc/testsuite/gcc.dg/torture/hardbool.c
index 01684952a2a9f4380ddee68dad94f0ce2b6a7e51..ed0c5988d2be39fcd5b542879cee77d65042245a 100644 (file)
--- a/gcc/testsuite/gcc.dg/torture/hardbool.c
+++ b/gcc/testsuite/gcc.dg/torture/hardbool.c
@@ -21,8 +21,12 @@ typedef unsigned char __attribute__ ((__hardbool__ (1, 0))) zbool;
 
 struct hs {
   hbool a[2];
+#ifndef NO_BITFIELDS
   hbool x:2;
   hbool y:5;
+#else
+  hbool x, y;
+#endif
   zbool z:1;
 };
 
@@ -57,6 +61,30 @@ int ghs(hbool s) {
 
 int t = (hbool)2;
 
+hbool add1(hbool *s) {
+  return *s += 1;
+}
+
+hbool preinc(hbool *s) {
+  return ++*s;
+}
+
+hbool postinc(hbool *s) {
+  return (*s)++;
+}
+
+hbool sub1(hbool *s) {
+  return *s -= 1;
+}
+
+hbool predec(hbool *s) {
+  return --*s;
+}
+
+hbool postdec(hbool *s) {
+  return (*s)--;
+}
+
 void check_pfalse (hbool *p)
 {
   assert (!*p);
@@ -114,5 +142,43 @@ int main () {
   check_vtrue (h2 (2));
   check_vtrue (h2 (1));
   check_vfalse (h2 (0));
-}
 
+  hbool v;
+  v = 0;
+  check_vtrue (add1 (&v));
+  assert (v);
+  v = 0;
+  check_vtrue (preinc (&v));
+  assert (v);
+  v = 0;
+  check_vfalse (postinc (&v));
+  assert (v);
+  v = 0;
+  check_vtrue (sub1 (&v));
+  assert (v);
+  v = 0;
+  check_vtrue (predec (&v));
+  assert (v);
+  v = 0;
+  check_vfalse (postdec (&v));
+  assert (v);
+  
+  v = 1;
+  check_vtrue (add1 (&v));
+  assert (v);
+  v = 1;
+  check_vtrue (preinc (&v));
+  assert (v);
+  v = 1;
+  check_vtrue (postinc (&v));
+  assert (v);
+  v = 1;
+  check_vfalse (sub1 (&v));
+  assert (!v);
+  v = 1;
+  check_vfalse (predec (&v));
+  assert (!v);
+  v = 1;
+  check_vtrue (postdec (&v));
+  assert (!v);
+}