* bitmap.c (bitmap_and, bitmap_and_into, bitmap_and_compl,

	bitmap_and_compl_into, bitmap_compl_and_into, bitmap_ior,
	bitmap_ior_into, bitmap_xor, bitmap_xor_into,
	bitmap_ior_and_compl, bitmap_ior_and_compl): Turn internal datastructure
	checks into checking asserts.
	* rtlanal.c (find_reg_note): Use gcc_checking_assert.
	* tree-ssa-sccvn.c (VN_INFO): Likewise.
	* df-scan.c (df_reorganize_refs_by_reg_by_reg, df_install_ref,
	df_ref_create_structure): Likewise.
	* alloc-pool.c (create_alloc_pool, empty_alloc_pool, pool_alloc,
	pool_free): Use gcc_checking_assert.
	* alias.c (get_alias_set): Likewise.
	* var-tracking.c (variable_htab_free, shared_hash_copy,
	canonicalize_values_mark, variable_merge_over_cur): Likewise.
	* lto-streamer.c (bp_unpack_value): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@160681 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 72297411352a6a0f578c9cf9a774a6652bae08ba..8fa56df307b1b7d6296930f50b9af75332c6dc46 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2010-06-13  Jan Hubicka  <jh@suse.cz>
+
+       * bitmap.c (bitmap_and, bitmap_and_into, bitmap_and_compl,
+       bitmap_and_compl_into, bitmap_compl_and_into, bitmap_ior,
+       bitmap_ior_into, bitmap_xor, bitmap_xor_into,
+       bitmap_ior_and_compl, bitmap_ior_and_compl): Turn internal datastructure
+       checks into checking asserts.
+       * rtlanal.c (find_reg_note): Use gcc_checking_assert.
+       * tree-ssa-sccvn.c (VN_INFO): Likewise.
+       * df-scan.c (df_reorganize_refs_by_reg_by_reg, df_install_ref,
+       df_ref_create_structure): Likewise.
+       * alloc-pool.c (create_alloc_pool, empty_alloc_pool, pool_alloc,
+       pool_free): Use gcc_checking_assert.
+       * alias.c (get_alias_set): Likewise.
+       * var-tracking.c (variable_htab_free, shared_hash_copy,
+       canonicalize_values_mark, variable_merge_over_cur): Likewise.
+       * lto-streamer.c (bp_unpack_value): Likewise.
+
 2010-06-13  Richard Guenther  <rguenther@suse.de>
 
        * lto-streamer-in.c (lto_input_ts_type_tree_pointers):

diff --git a/gcc/alias.c b/gcc/alias.c
index 382093161189ee61e849753e006b288ca23e0f8b..08c38bf661601af8c749d541f088ff88c9ca9f7c 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -713,7 +713,7 @@ get_alias_set (tree t)
   t = TYPE_CANONICAL (t);
   /* Canonical types shouldn't form a tree nor should the canonical
      type require structural equality checks.  */
-  gcc_assert (!TYPE_STRUCTURAL_EQUALITY_P (t) && TYPE_CANONICAL (t) == t);
+  gcc_checking_assert (!TYPE_STRUCTURAL_EQUALITY_P (t) && TYPE_CANONICAL (t) == t);
 
   /* If this is a type with a known alias set, return it.  */
   if (TYPE_ALIAS_SET_KNOWN_P (t))
@@ -1136,7 +1136,7 @@ record_set (rtx dest, const_rtx set, void *data ATTRIBUTE_UNUSED)
 
   regno = REGNO (dest);
 
-  gcc_assert (regno < VEC_length (rtx, reg_base_value));
+  gcc_checking_assert (regno < VEC_length (rtx, reg_base_value));
 
   /* If this spans multiple hard registers, then we must indicate that every
      register has an unusable value.  */

diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c
index 6eecef53ee2ce8503323a637d5bb7bce60d9ccef..ade1753c04657c3c6e0e7cc58109b8973df879b6 100644 (file)
--- a/gcc/alloc-pool.c
+++ b/gcc/alloc-pool.c
@@ -137,7 +137,7 @@ create_alloc_pool (const char *name, size_t size, size_t num)
   struct alloc_pool_descriptor *desc;
 #endif
 
-  gcc_assert (name);
+  gcc_checking_assert (name);
 
   /* Make size large enough to store the list header.  */
   if (size < sizeof (alloc_pool_list))
@@ -152,7 +152,7 @@ create_alloc_pool (const char *name, size_t size, size_t num)
 #endif
 
   /* Um, we can't really allocate 0 elements per block.  */
-  gcc_assert (num);
+  gcc_checking_assert (num);
 
   /* Allocate memory for the pool structure.  */
   pool = XNEW (struct alloc_pool_def);
@@ -201,7 +201,7 @@ empty_alloc_pool (alloc_pool pool)
   struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
 #endif
 
-  gcc_assert (pool);
+  gcc_checking_assert (pool);
 
   /* Free each block allocated to the pool.  */
   for (block = pool->block_list; block != NULL; block = next_block)
@@ -260,7 +260,7 @@ pool_alloc (alloc_pool pool)
     desc->peak = desc->current;
 #endif
 
-  gcc_assert (pool);
+  gcc_checking_assert (pool);
 
   /* If there are no more free elements, make some more!.  */
   if (!pool->returned_free_list)
@@ -328,19 +328,19 @@ pool_free (alloc_pool pool, void *ptr)
   struct alloc_pool_descriptor *desc = alloc_pool_descriptor (pool->name);
 #endif
 
-  gcc_assert (ptr);
 
 #ifdef ENABLE_CHECKING
-  /* Check whether the PTR was allocated from POOL.  */
-  gcc_assert (pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id);
+  gcc_assert (ptr
+             /* Check if we free more than we allocated, which is Bad (TM).  */
+             && pool->elts_free < pool->elts_allocated
+             /* Check whether the PTR was allocated from POOL.  */
+             && pool->id == ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id);
 
   memset (ptr, 0xaf, pool->elt_size - offsetof (allocation_object, u.data));
 
   /* Mark the element to be free.  */
   ALLOCATION_OBJECT_PTR_FROM_USER_PTR (ptr)->id = 0;
 #else
-  /* Check if we free more than we allocated, which is Bad (TM).  */
-  gcc_assert (pool->elts_free < pool->elts_allocated);
 #endif
 
   header = (alloc_pool_list) ptr;

diff --git a/gcc/bitmap.c b/gcc/bitmap.c
index 815960c0b44bffbe4653a8c568f53b341577ea30..aeaf2ea00e1ce779185a9cb2f83f8da10402e4b9 100644 (file)
--- a/gcc/bitmap.c
+++ b/gcc/bitmap.c
@@ -927,7 +927,7 @@ bitmap_and (bitmap dst, const_bitmap a, const_bitmap b)
   /* Ensure that dst->current is valid.  */
   dst->current = dst->first;
   bitmap_elt_clear_from (dst, dst_elt);
-  gcc_assert (!dst->current == !dst->first);
+  gcc_checking_assert (!dst->current == !dst->first);
   if (dst->current)
     dst->indx = dst->current->indx;
 }
@@ -975,8 +975,8 @@ bitmap_and_into (bitmap a, const_bitmap b)
        }
     }
   bitmap_elt_clear_from (a, a_elt);
-  gcc_assert (!a->current == !a->first
-             && (!a->current || a->indx == a->current->indx));
+  gcc_checking_assert (!a->current == !a->first
+                      && (!a->current || a->indx == a->current->indx));
 }
 
 
@@ -1119,7 +1119,7 @@ bitmap_and_compl (bitmap dst, const_bitmap a, const_bitmap b)
       changed = true;
       bitmap_elt_clear_from (dst, dst_elt);
     }
-  gcc_assert (!dst->current == !dst->first);
+  gcc_checking_assert (!dst->current == !dst->first);
   if (dst->current)
     dst->indx = dst->current->indx;
 
@@ -1175,8 +1175,8 @@ bitmap_and_compl_into (bitmap a, const_bitmap b)
          b_elt = b_elt->next;
        }
     }
-  gcc_assert (!a->current == !a->first
-             && (!a->current || a->indx == a->current->indx));
+  gcc_checking_assert (!a->current == !a->first
+                      && (!a->current || a->indx == a->current->indx));
   return changed != 0;
 }
 
@@ -1470,8 +1470,8 @@ bitmap_compl_and_into (bitmap a, const_bitmap b)
          b_elt = b_elt->next;
        }
     }
-  gcc_assert (!a->current == !a->first
-             && (!a->current || a->indx == a->current->indx));
+  gcc_checking_assert (!a->current == !a->first
+                      && (!a->current || a->indx == a->current->indx));
   return;
 }
 
@@ -1576,7 +1576,7 @@ bitmap_ior (bitmap dst, const_bitmap a, const_bitmap b)
       changed = true;
       bitmap_elt_clear_from (dst, dst_elt);
     }
-  gcc_assert (!dst->current == !dst->first);
+  gcc_checking_assert (!dst->current == !dst->first);
   if (dst->current)
     dst->indx = dst->current->indx;
   return changed;
@@ -1615,7 +1615,7 @@ bitmap_ior_into (bitmap a, const_bitmap b)
       a_elt = *a_prev_pnext;
     }
 
-  gcc_assert (!a->current == !a->first);
+  gcc_checking_assert (!a->current == !a->first);
   if (a->current)
     a->indx = a->current->indx;
   return changed;
@@ -1693,7 +1693,7 @@ bitmap_xor (bitmap dst, const_bitmap a, const_bitmap b)
   /* Ensure that dst->current is valid.  */
   dst->current = dst->first;
   bitmap_elt_clear_from (dst, dst_elt);
-  gcc_assert (!dst->current == !dst->first);
+  gcc_checking_assert (!dst->current == !dst->first);
   if (dst->current)
     dst->indx = dst->current->indx;
 }
@@ -1750,7 +1750,7 @@ bitmap_xor_into (bitmap a, const_bitmap b)
          a_elt = next;
        }
     }
-  gcc_assert (!a->current == !a->first);
+  gcc_checking_assert (!a->current == !a->first);
   if (a->current)
     a->indx = a->current->indx;
 }
@@ -1932,7 +1932,7 @@ bitmap_ior_and_compl (bitmap dst, const_bitmap a, const_bitmap b, const_bitmap k
       changed = true;
       bitmap_elt_clear_from (dst, dst_elt);
     }
-  gcc_assert (!dst->current == !dst->first);
+  gcc_checking_assert (!dst->current == !dst->first);
   if (dst->current)
     dst->indx = dst->current->indx;
 
@@ -2028,7 +2028,7 @@ bitmap_ior_and_into (bitmap a, const_bitmap b, const_bitmap c)
     }
 
  done:
-  gcc_assert (!a->current == !a->first);
+  gcc_checking_assert (!a->current == !a->first);
   if (a->current)
     a->indx = a->current->indx;
   return changed;

diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index 902afdae4979984df112369c1e2f2a04e92259cf..353442923c2e0bb8835d43c3123156c8566ed662 100644 (file)
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -1554,7 +1554,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
              DF_REF_ID (ref) = offset++;
              count++;
              ref = DF_REF_NEXT_REG (ref);
-             gcc_assert (offset < ref_info->refs_size);
+             gcc_checking_assert (offset < ref_info->refs_size);
            }
        }
       if (include_uses)
@@ -1566,7 +1566,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
              DF_REF_ID (ref) = offset++;
              count++;
              ref = DF_REF_NEXT_REG (ref);
-             gcc_assert (offset < ref_info->refs_size);
+             gcc_checking_assert (offset < ref_info->refs_size);
            }
        }
       if (include_eq_uses)
@@ -1578,7 +1578,7 @@ df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
              DF_REF_ID (ref) = offset++;
              count++;
              ref = DF_REF_NEXT_REG (ref);
-             gcc_assert (offset < ref_info->refs_size);
+             gcc_checking_assert (offset < ref_info->refs_size);
            }
        }
       ref_info->count[regno] = count;
@@ -2593,8 +2593,8 @@ df_install_ref (df_ref this_ref,
       df->hard_regs_live_count[regno]++;
     }
 
-  gcc_assert (DF_REF_NEXT_REG (this_ref) == NULL
-             && DF_REF_PREV_REG (this_ref) == NULL);
+  gcc_checking_assert (DF_REF_NEXT_REG (this_ref) == NULL
+                      && DF_REF_PREV_REG (this_ref) == NULL);
 
   DF_REF_NEXT_REG (this_ref) = head;
 
@@ -2789,19 +2789,19 @@ df_ref_create_structure (enum df_ref_class cl,
     {
     case DF_REF_BASE:
       this_ref = (df_ref) pool_alloc (problem_data->ref_base_pool);
-      gcc_assert (loc == NULL);
+      gcc_checking_assert (loc == NULL);
       break;
 
     case DF_REF_ARTIFICIAL:
       this_ref = (df_ref) pool_alloc (problem_data->ref_artificial_pool);
       this_ref->artificial_ref.bb = bb;
-      gcc_assert (loc == NULL);
+      gcc_checking_assert (loc == NULL);
       break;
 
     case DF_REF_REGULAR:
       this_ref = (df_ref) pool_alloc (problem_data->ref_regular_pool);
       this_ref->regular_ref.loc = loc;
-      gcc_assert (loc);
+      gcc_checking_assert (loc);
       break;
 
     case DF_REF_EXTRACT:
@@ -2810,7 +2810,7 @@ df_ref_create_structure (enum df_ref_class cl,
       DF_REF_EXTRACT_OFFSET (this_ref) = offset;
       DF_REF_EXTRACT_MODE (this_ref) = mode;
       this_ref->regular_ref.loc = loc;
-      gcc_assert (loc);
+      gcc_checking_assert (loc);
       break;
     }
 
@@ -2880,7 +2880,7 @@ df_ref_record (enum df_ref_class cl,
 {
   unsigned int regno;
 
-  gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
+  gcc_checking_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
 
   regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
   if (regno < FIRST_PSEUDO_REGISTER)

diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c
index 5b0e7748b2f8e2d8253b78515447ecc37ccadfec..216bc9536dfa709bc2c0a1a4748c12fd86c9ebdf 100644 (file)
--- a/gcc/lto-streamer.c
+++ b/gcc/lto-streamer.c
@@ -382,7 +382,7 @@ bp_unpack_value (struct bitpack_d *bp, unsigned nbits)
   unsigned ix;
 
   /* We cannot decode more bits than BITS_PER_BITPACK_WORD.  */
-  gcc_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD);
+  gcc_checking_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD);
 
   /* Compute which word contains the next NBITS.  */
   ix = bp_get_next_word (bp, nbits);

diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index a3608732dbb0d44344804a06badeb510c01cf4c4..a26bf3b2272ee88b85ab05396eb5ccbb40feeee9 100644 (file)
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -1694,7 +1694,7 @@ find_reg_note (const_rtx insn, enum reg_note kind, const_rtx datum)
 {
   rtx link;
 
-  gcc_assert (insn);
+  gcc_checking_assert (insn);
 
   /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN.  */
   if (! INSN_P (insn))

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 240885570546aaadaa9f19247f1b3d9860464370..bb4a5172de8ec97769735eb3cbb88226badc5668 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -176,7 +176,7 @@ VN_INFO (tree name)
 {
   vn_ssa_aux_t res = VEC_index (vn_ssa_aux_t, vn_ssa_aux_table,
                                SSA_NAME_VERSION (name));
-  gcc_assert (res);
+  gcc_checking_assert (res);
   return res;
 }
 

diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index 57405583e58404616af3476e78a7d8b6fe1bd65d..8786a7d784cbde4c3c672520a8f3bdec4c2967fd 100644 (file)
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -1167,7 +1167,7 @@ variable_htab_free (void *elem)
   variable var = (variable) elem;
   location_chain node, next;
 
-  gcc_assert (var->refcount > 0);
+  gcc_checking_assert (var->refcount > 0);
 
   var->refcount--;
   if (var->refcount > 0)
@@ -1370,7 +1370,7 @@ shared_hash_copy (shared_hash vars)
 static void
 shared_hash_destroy (shared_hash vars)
 {
-  gcc_assert (vars->refcount > 0);
+  gcc_checking_assert (vars->refcount > 0);
   if (--vars->refcount == 0)
     {
       htab_delete (vars->htab);
@@ -3066,7 +3066,7 @@ canonicalize_values_mark (void **slot, void *data)
   if (!dv_is_value_p (dv))
     return 1;
 
-  gcc_assert (var->n_var_parts == 1);
+  gcc_checking_assert (var->n_var_parts == 1);
 
   val = dv_as_value (dv);
 
@@ -3109,7 +3109,7 @@ canonicalize_values_star (void **slot, void *data)
   if (!dv_onepart_p (dv))
     return 1;
 
-  gcc_assert (var->n_var_parts == 1);
+  gcc_checking_assert (var->n_var_parts == 1);
 
   if (dv_is_value_p (dv))
     {
@@ -3299,8 +3299,8 @@ canonicalize_values_star (void **slot, void *data)
 
   /* Variable may have been unshared.  */
   var = (variable)*slot;
-  gcc_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
-             && var->var_part[0].loc_chain->next == NULL);
+  gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
+                      && var->var_part[0].loc_chain->next == NULL);
 
   if (VALUE_RECURSED_INTO (cval))
     goto restart_with_cval;
@@ -3389,14 +3389,14 @@ variable_merge_over_cur (variable s1var, struct dfset_merge *dsm)
   /* If the incoming onepart variable has an empty location list, then
      the intersection will be just as empty.  For other variables,
      it's always union.  */
-  gcc_assert (s1var->n_var_parts
-             && s1var->var_part[0].loc_chain);
+  gcc_checking_assert (s1var->n_var_parts
+                      && s1var->var_part[0].loc_chain);
 
   if (!onepart)
     return variable_union (s1var, dst);
 
-  gcc_assert (s1var->n_var_parts == 1
-             && s1var->var_part[0].offset == 0);
+  gcc_checking_assert (s1var->n_var_parts == 1
+                      && s1var->var_part[0].offset == 0);
 
   dvhash = dv_htab_hash (dv);
   if (dv_is_value_p (dv))