middle-end: Avoid calling targetm.c.bitint_type_info inside of gcc_assert [PR102989]

On Thu, Sep 07, 2023 at 10:36:02AM +0200, Thomas Schwinge wrote:
> Minor comment/question: are we doing away with the property that
> 'assert'-like "calls" must not have side effects?  Per 'gcc/system.h',
> this is "OK" for 'gcc_assert' for '#if ENABLE_ASSERT_CHECKING' or
> '#elif (GCC_VERSION >= 4005)' -- that is, GCC 4.5, which is always-true,
> thus the "offending" '#else' is never active.  However, it's different
> for standard 'assert' and 'gcc_checking_assert', so I'm not sure if
> that's a good property for 'gcc_assert' only?  For example, see also
> <https://gcc.gnu.org/PR6906> "warn about asserts with side effects", or
> recent <https://gcc.gnu.org/PR111144>
> "RFE: could -fanalyzer warn about assertions that have side effects?".

You're right, the
  #define gcc_assert(EXPR) ((void)(0 && (EXPR)))
fallback definition is incompatible with the way I've used it, so for
--disable-checking built by non-GCC it would not work properly.

2023-09-07  Jakub Jelinek  <jakub@redhat.com>

	PR c/102989
	* expr.cc (expand_expr_real_1): Don't call targetm.c.bitint_type_info
	inside gcc_assert, as later code relies on it filling info variable.
	* gimple-fold.cc (clear_padding_bitint_needs_padding_p,
	clear_padding_type): Likewise.
	* varasm.cc (output_constant): Likewise.
	* fold-const.cc (native_encode_int, native_interpret_int): Likewise.
	* stor-layout.cc (finish_bitfield_representative, layout_type):
	Likewise.
	* gimple-lower-bitint.cc (bitint_precision_kind): Likewise.

diff --git a/gcc/expr.cc b/gcc/expr.cc
index d6b5bd0e09858b1860f18f0fcbe8cf3c0b467a21..d5b6494b4fc1de8403934da0c355b9afeab083ba 100644 (file)
--- a/gcc/expr.cc
+++ b/gcc/expr.cc
@@ -11039,7 +11039,8 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
          {
            unsigned int prec = TYPE_PRECISION (type);
            struct bitint_info info;
-           gcc_assert (targetm.c.bitint_type_info (prec, &info));
+           bool ok = targetm.c.bitint_type_info (prec, &info);
+           gcc_assert (ok);
            scalar_int_mode limb_mode
              = as_a <scalar_int_mode> (info.limb_mode);
            unsigned int limb_prec = GET_MODE_PRECISION (limb_mode);

diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
index 5b481a247f2f23861f518c1ef11d8e3f62105f2b..1da498a3152f6eca2e4f4fd202b3ccecafdab180 100644 (file)
--- a/gcc/fold-const.cc
+++ b/gcc/fold-const.cc
@@ -7731,8 +7731,8 @@ native_encode_int (const_tree expr, unsigned char *ptr, int len, int off)
   if (TREE_CODE (type) == BITINT_TYPE)
     {
       struct bitint_info info;
-      gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type),
-                                             &info));
+      bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+      gcc_assert (ok);
       scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
       if (TYPE_PRECISION (type) > GET_MODE_PRECISION (limb_mode))
        {
@@ -8661,8 +8661,8 @@ native_interpret_int (tree type, const unsigned char *ptr, int len)
   if (TREE_CODE (type) == BITINT_TYPE)
     {
       struct bitint_info info;
-      gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type),
-                                             &info));
+      bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+      gcc_assert (ok);
       scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
       if (TYPE_PRECISION (type) > GET_MODE_PRECISION (limb_mode))
        {

diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
index a25b2fd56e1bf617d26af7dcceeb9649b381d8fb..04d9faca8ff7466de02ec88a41d64d6ded198d68 100644 (file)
--- a/gcc/gimple-fold.cc
+++ b/gcc/gimple-fold.cc
@@ -4602,7 +4602,8 @@ static bool
 clear_padding_bitint_needs_padding_p (tree type)
 {
   struct bitint_info info;
-  gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type), &info));
+  bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+  gcc_assert (ok);
   if (info.extended)
     return false;
   scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
@@ -4880,7 +4881,8 @@ clear_padding_type (clear_padding_struct *buf, tree type,
     case BITINT_TYPE:
       {
        struct bitint_info info;
-       gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type), &info));
+       bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+       gcc_assert (ok);
        scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
        if (TYPE_PRECISION (type) <= GET_MODE_PRECISION (limb_mode))
          {

diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc
index dceaec779c82359b42b586ecd6a3ffd760124938..cf4bcfc5ba485e7afd8599b23dd618d69096a1e0 100644 (file)
--- a/gcc/gimple-lower-bitint.cc
+++ b/gcc/gimple-lower-bitint.cc
@@ -92,7 +92,8 @@ bitint_precision_kind (int prec)
     return bitint_prec_middle;
 
   struct bitint_info info;
-  gcc_assert (targetm.c.bitint_type_info (prec, &info));
+  bool ok = targetm.c.bitint_type_info (prec, &info);
+  gcc_assert (ok);
   scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
   if (prec <= GET_MODE_PRECISION (limb_mode))
     {

diff --git a/gcc/stor-layout.cc b/gcc/stor-layout.cc
index 7471127bfd09cf42ea84e6120772604f8c9e0db4..ba375fa423c95be4bb021226e69d98954b080f36 100644 (file)
--- a/gcc/stor-layout.cc
+++ b/gcc/stor-layout.cc
@@ -2152,7 +2152,8 @@ finish_bitfield_representative (tree repr, tree field)
        {
          struct bitint_info info;
          unsigned prec = TYPE_PRECISION (TREE_TYPE (field));
-         gcc_assert (targetm.c.bitint_type_info (prec, &info));
+         bool ok = targetm.c.bitint_type_info (prec, &info);
+         gcc_assert (ok);
          scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
          unsigned lprec = GET_MODE_PRECISION (limb_mode);
          if (prec > lprec)
@@ -2413,7 +2414,8 @@ layout_type (tree type)
       {
        struct bitint_info info;
        int cnt;
-       gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type), &info));
+       bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+       gcc_assert (ok);
        scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
        if (TYPE_PRECISION (type) <= GET_MODE_PRECISION (limb_mode))
          {

diff --git a/gcc/varasm.cc b/gcc/varasm.cc
index 76064af66e7684db75ffbe54441b0783246b132c..b0eff17b8b5c5931d069ee0a68e5b3c38fa98cd2 100644 (file)
--- a/gcc/varasm.cc
+++ b/gcc/varasm.cc
@@ -5289,8 +5289,8 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align,
        {
          struct bitint_info info;
          tree type = TREE_TYPE (exp);
-         gcc_assert (targetm.c.bitint_type_info (TYPE_PRECISION (type),
-                                                 &info));
+         bool ok = targetm.c.bitint_type_info (TYPE_PRECISION (type), &info);
+         gcc_assert (ok);
          scalar_int_mode limb_mode = as_a <scalar_int_mode> (info.limb_mode);
          if (TYPE_PRECISION (type) <= GET_MODE_PRECISION (limb_mode))
            {