Assorted --disable-checking fixes [PR117249]

We have currently 3 different definitions of gcc_assert macro, one used most
of the time (unless --disable-checking) which evaluates the condition at
runtime and also checks it at runtime, then one for --disable-checking GCC 4.5+
which looks like
((void)(UNLIKELY (!(EXPR)) ? __builtin_unreachable (), 0 : 0))
and a fallback one
((void)(0 && (EXPR)))
Now, the last one actually doesn't evaluate any of the side-effects in the
argument, just quiets up unused var/parameter warnings.
I've tried to replace the middle definition with
({ [[assume (EXPR)]]; (void) 0; })
for compilers which support assume attribute and statement expressions
(surprisingly quite a few spots use gcc_assert inside of comma expressions),
but ran into PR117287, so for now such a change isn't being proposed.

The following patch attempts to move important side-effects from gcc_assert
arguments.

Bootstrapped/regtested on x86_64-linux and i686-linux with normal
--enable-checking=yes,rtl,extra, plus additionally I've attempted to do
x86_64-linux bootstrap with --disable-checking and gcc_assert changed to the
((void)(0 && (EXPR)))
version when --disable-checking.  That version ran into spurious middle-end
warnings
../../gcc/../include/libiberty.h:733:36: error: argument to ‘alloca’ is too large [-Werror=alloca-larger-than=]
../../gcc/tree-ssa-reassoc.cc:5659:20: note: in expansion of macro ‘XALLOCAVEC’
  int op_num = ops.length ();
  int op_normal_num = op_num;
  gcc_assert (op_num > 0);
  int stmt_num = op_num - 1;
  gimple **stmts = XALLOCAVEC (gimple *, stmt_num);
where we have gcc_assert exactly to work-around middle-end warnings.
Guess I'd need to also disable -Werror for this experiment, which actually
isn't a problem with unmodified system.h, because even for
--disable-checking we use the __builtin_unreachable at least in
stage2/stage3 and so the warnings aren't emitted, and even if it used
[[assume ()]]; it would work too because in stage2/stage3 we could again
rely on assume and statement expression support.

2024-10-25  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/117249
	* tree-ssa-structalias.cc (insert_vi_for_tree): Move put calls out of
	gcc_assert.
	* lto-cgraph.cc (lto_symtab_encoder_delete_node): Likewise.
	* gimple-ssa-strength-reduction.cc (get_alternative_base,
	add_cand_for_stmt): Likewise.
	* tree-eh.cc (add_stmt_to_eh_lp_fn): Likewise.
	* except.cc (duplicate_eh_regions_1): Likewise.
	* tree-ssa-reassoc.cc (insert_operand_rank): Likewise.
	* config/nvptx/nvptx.cc (nvptx_expand_call): Use == rather than = in
	gcc_assert.
	* opts-common.cc (jobserver_info::disconnect): Call close outside of
	gcc_assert and only check result in it.
	(jobserver_info::return_token): Call write outside of gcc_assert and
	only check result in it.
	* genautomata.cc (output_default_latencies): Move j++ side-effect
	outside of gcc_assert.
	* tree-ssa-loop-ivopts.cc (get_alias_ptr_type_for_ptr_address): Use
	== rather than = in gcc_assert.
	* cgraph.cc (symbol_table::create_edge): Move ++edges_max_uid
	side-effect outside of gcc_assert.

diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc
index 93628ef7f264f707e7a6125212ab40c647a48aec..d4c35341ab58f9c410dd666aa2b16d9ce61ff099 100644 (file)
--- a/gcc/cgraph.cc
+++ b/gcc/cgraph.cc
@@ -895,7 +895,8 @@ symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
   edge->m_summary_id = -1;
   edges_count++;
 
-  gcc_assert (++edges_max_uid != 0);
+  ++edges_max_uid;
+  gcc_assert (edges_max_uid != 0);
   edge->m_uid = edges_max_uid;
   edge->aux = NULL;
   edge->caller = caller;

diff --git a/gcc/config/nvptx/nvptx.cc b/gcc/config/nvptx/nvptx.cc
index 883bab67fff11038f841a36ebaeb7538d539c78e..3072d3729a891d703c0e71a9708fe0d1ab13b893 100644 (file)
--- a/gcc/config/nvptx/nvptx.cc
+++ b/gcc/config/nvptx/nvptx.cc
@@ -1902,7 +1902,7 @@ nvptx_expand_call (rtx retval, rtx address)
   if (varargs)
     XVECEXP (pat, 0, vec_pos++) = gen_rtx_USE (VOIDmode, varargs);
 
-  gcc_assert (vec_pos = XVECLEN (pat, 0));
+  gcc_assert (vec_pos == XVECLEN (pat, 0));
 
   nvptx_emit_forking (parallel, true);
   emit_call_insn (pat);

diff --git a/gcc/except.cc b/gcc/except.cc
index f6ff75a228f031a68e3d69786c9b86825cb341d4..3cb2728497a76c3f6abf3514b955f1cbf49a4c22 100644 (file)
--- a/gcc/except.cc
+++ b/gcc/except.cc
@@ -542,7 +542,8 @@ duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
   eh_region new_r;
 
   new_r = gen_eh_region (old_r->type, outer);
-  gcc_assert (!data->eh_map->put (old_r, new_r));
+  bool existed = data->eh_map->put (old_r, new_r);
+  gcc_assert (!existed);
 
   switch (old_r->type)
     {
@@ -587,7 +588,8 @@ duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
        continue;
 
       new_lp = gen_eh_landing_pad (new_r);
-      gcc_assert (!data->eh_map->put (old_lp, new_lp));
+      bool existed = data->eh_map->put (old_lp, new_lp);
+      gcc_assert (!existed);
 
       new_lp->post_landing_pad
        = data->label_map (old_lp->post_landing_pad, data->label_map_data);

diff --git a/gcc/genautomata.cc b/gcc/genautomata.cc
index ec1e5331a4b09dcfe790c8eadf34ce071098d9e0..19531cdc4f78537b2d7868dedf90d66a9057e170 100644 (file)
--- a/gcc/genautomata.cc
+++ b/gcc/genautomata.cc
@@ -8348,7 +8348,8 @@ output_default_latencies (void)
        if ((col = (col+1) % 8) == 0)
          fputs ("\n     ", output_file);
        decl = description->decls[i];
-       gcc_assert (j++ == DECL_INSN_RESERV (decl)->insn_num);
+       gcc_assert (j == DECL_INSN_RESERV (decl)->insn_num);
+       ++j;
        fprintf (output_file, "% 4d,",
                 DECL_INSN_RESERV (decl)->default_latency);
       }

diff --git a/gcc/gimple-ssa-strength-reduction.cc b/gcc/gimple-ssa-strength-reduction.cc
index 24b3dfb57d5c6634bf6fa078b2c0cee2cbbdf155..fab9c24db03a2cbe5f603e225033ee83ba4335e2 100644 (file)
--- a/gcc/gimple-ssa-strength-reduction.cc
+++ b/gcc/gimple-ssa-strength-reduction.cc
@@ -475,7 +475,8 @@ get_alternative_base (tree base)
       aff.offset = 0;
       expr = aff_combination_to_tree (&aff);
 
-      gcc_assert (!alt_base_map->put (base, base == expr ? NULL : expr));
+      bool existed = alt_base_map->put (base, base == expr ? NULL : expr);
+      gcc_assert (!existed);
 
       return expr == base ? NULL : expr;
     }
@@ -793,7 +794,8 @@ base_cand_from_table (tree base_in)
 static void
 add_cand_for_stmt (gimple *gs, slsr_cand_t c)
 {
-  gcc_assert (!stmt_cand_map->put (gs, c));
+  bool existed = stmt_cand_map->put (gs, c);
+  gcc_assert (!existed);
 }
 \f
 /* Given PHI which contains a phi statement, determine whether it

diff --git a/gcc/lto-cgraph.cc b/gcc/lto-cgraph.cc
index 06cd5e6d71ce30879130d7c60e84900c4718615a..b1fc694e562408ce9e78d710acf42e924e7d232b 100644 (file)
--- a/gcc/lto-cgraph.cc
+++ b/gcc/lto-cgraph.cc
@@ -156,7 +156,8 @@ lto_symtab_encoder_delete_node (lto_symtab_encoder_t encoder,
   last_node = encoder->nodes.pop ();
   if (last_node.node != node)
     {
-      gcc_assert (encoder->map->put (last_node.node, index + 1));
+      bool existed = encoder->map->put (last_node.node, index + 1);
+      gcc_assert (existed);
 
       /* Move the last element to the original spot of NODE.  */
       encoder->nodes[index] = last_node;

diff --git a/gcc/opts-common.cc b/gcc/opts-common.cc
index d336a17579adc900dc60e16f74e3b77d4ab33122..22774457bf0fe2da9ff8d3821ed33866eedcb3cb 100644 (file)
--- a/gcc/opts-common.cc
+++ b/gcc/opts-common.cc
@@ -2157,7 +2157,8 @@ jobserver_info::disconnect ()
 {
   if (!pipe_path.empty ())
     {
-      gcc_assert (close (pipefd) == 0);
+      int res = close (pipefd);
+      gcc_assert (res == 0);
       pipefd = -1;
     }
 }
@@ -2182,5 +2183,6 @@ jobserver_info::return_token ()
 {
   int fd = pipe_path.empty () ? wfd : pipefd;
   char c = 'G';
-  gcc_assert (write (fd, &c, 1) == 1);
+  int res = write (fd, &c, 1);
+  gcc_assert (res == 1);
 }

diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc
index 2e85d498ee78868e725d0494a37463bcc779c7bc..ae0a4e3864cd51b3654355af71a4ffe432064b4c 100644 (file)
--- a/gcc/tree-eh.cc
+++ b/gcc/tree-eh.cc
@@ -76,7 +76,8 @@ add_stmt_to_eh_lp_fn (struct function *ifun, gimple *t, int num)
   if (!get_eh_throw_stmt_table (ifun))
     set_eh_throw_stmt_table (ifun, hash_map<gimple *, int>::create_ggc (31));
 
-  gcc_assert (!get_eh_throw_stmt_table (ifun)->put (t, num));
+  bool existed = get_eh_throw_stmt_table (ifun)->put (t, num);
+  gcc_assert (!existed);
 }
 
 /* Add statement T in the current function (cfun) to EH landing pad NUM.  */

diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc
index 68d091dc4a3a6bcbf5f6b6ddf07c03b792473281..023bd645df21b40447b1e084942594dfb0e740ba 100644 (file)
--- a/gcc/tree-ssa-loop-ivopts.cc
+++ b/gcc/tree-ssa-loop-ivopts.cc
@@ -7564,7 +7564,7 @@ get_alias_ptr_type_for_ptr_address (iv_use *use)
     case IFN_MASK_LEN_LOAD:
     case IFN_MASK_LEN_STORE:
       /* The second argument contains the correct alias type.  */
-      gcc_assert (use->op_p = gimple_call_arg_ptr (call, 0));
+      gcc_assert (use->op_p == gimple_call_arg_ptr (call, 0));
       return TREE_TYPE (gimple_call_arg (call, 1));
 
     default:

diff --git a/gcc/tree-ssa-reassoc.cc b/gcc/tree-ssa-reassoc.cc
index 3eddf6df391739949504c58849741c6f25ab5dff..ba2a1804052193fe61d76c440d44cc2406c53d36 100644 (file)
--- a/gcc/tree-ssa-reassoc.cc
+++ b/gcc/tree-ssa-reassoc.cc
@@ -405,7 +405,8 @@ static inline void
 insert_operand_rank (tree e, int64_t rank)
 {
   gcc_assert (rank > 0);
-  gcc_assert (!operand_rank->put (e, rank));
+  bool existed = operand_rank->put (e, rank);
+  gcc_assert (!existed);
 }
 
 /* Given an expression E, return the rank of the expression.  */

diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc
index b64faa7fe7ae338f7217bed746e215e457753eb4..6424f7e7ad2f723bcb67b8b936afbabc7ed934d3 100644 (file)
--- a/gcc/tree-ssa-structalias.cc
+++ b/gcc/tree-ssa-structalias.cc
@@ -2987,7 +2987,8 @@ static void
 insert_vi_for_tree (tree t, varinfo_t vi)
 {
   gcc_assert (vi);
-  gcc_assert (!vi_for_tree->put (t, vi));
+  bool existed = vi_for_tree->put (t, vi);
+  gcc_assert (!existed);
 }
 
 /* Find the variable info for tree T in VI_FOR_TREE.  If T does not