Misc cleanups and cosmetic changes to ranger.

7 files changed, 94 insertions, 96 deletions

diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc
index a351a9f..2bed7da 100644
--- a/gcc/gimple-range.cc
+++ b/gcc/gimple-range.cc
@@ -224,8 +224,8 @@ gimple_range_fold (const gimple *stmt, irange &res, const irange &r1)
   gcc_checking_assert (gimple_range_handler (stmt));
 
   tree type = gimple_expr_type (stmt);
+  // Unary SSA operations require the LHS type as the second range.
   int_range<1> r2 (type);
-  // Single ssa operations require the LHS type as the second range.
 
   return gimple_range_fold (stmt, res, r1, r2);
 }
@@ -261,9 +261,9 @@ gimple_range_operand1 (const gimple *stmt)
   switch (gimple_code (stmt))
     {
       case GIMPLE_COND:
-        return gimple_cond_lhs (stmt);
+	return gimple_cond_lhs (stmt);
       case GIMPLE_ASSIGN:
-        {
+	{
 	  tree expr = gimple_assign_rhs1 (stmt);
 	  if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
 	    {
@@ -274,7 +274,7 @@ gimple_range_operand1 (const gimple *stmt)
 	      // ADDR_EXPR and do the right thing.
 	      tree base = get_base_address (TREE_OPERAND (expr, 0));
 	      if (base != NULL_TREE && TREE_CODE (base) == MEM_REF)
-	        {
+		{
 		  // If the base address is an SSA_NAME, return it.
 		  tree b = TREE_OPERAND (base, 0);
 		  if (TREE_CODE (b) == SSA_NAME)
@@ -284,7 +284,7 @@ gimple_range_operand1 (const gimple *stmt)
 	  return expr;
 	}
       default:
-        break;
+	break;
     }
   return NULL;
 }
diff --git a/gcc/gimple-range.h b/gcc/gimple-range.h
index 60b4482..641522b 100644
--- a/gcc/gimple-range.h
+++ b/gcc/gimple-range.h
@@ -85,7 +85,7 @@ gimple_range_global (tree name)
   tree type = TREE_TYPE (name);
   if (!POINTER_TYPE_P (type) && SSA_NAME_RANGE_INFO (name))
     {
-      // Return a range from an SSA_NAME's available range.  
+      // Return a range from an SSA_NAME's available range.
       wide_int min, max;
       enum value_range_kind kind = get_range_info (name, &min, &max);
       return value_range (type, min, max, kind);
diff --git a/gcc/ssa-range-cache.cc b/gcc/ssa-range-cache.cc
index 9bb7df2..b8011a5 100644
--- a/gcc/ssa-range-cache.cc
+++ b/gcc/ssa-range-cache.cc
@@ -115,11 +115,11 @@ non_null_ref::process_name (tree name)
 
       // If bit is already set for this block, dont bother looking again.
       if (bitmap_bit_p (b, index))
-        continue;
+	continue;
 
       // If we can infer a != 0 range, then set the bit for this BB
       if (infer_value_range (s, name, &comp_code, &value))
-        {
+	{
 	  if (comp_code == NE_EXPR && integer_zerop (value))
 	    bitmap_set_bit (b, index);
 	}
@@ -309,7 +309,7 @@ block_range_cache::set_bb_varying (tree name, const basic_block bb)
 
 // Return the range for NAME on entry to BB in R.  Return true if here is one.
 
-bool 
+bool
 block_range_cache::get_bb_range (irange &r, tree name, const basic_block bb)
 {
   gcc_checking_assert (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun));
@@ -318,7 +318,7 @@ block_range_cache::get_bb_range (irange &r, tree name, const basic_block bb)
 
 // Return true if NAME has a range set in block BB.
 
-bool 
+bool
 block_range_cache::bb_range_p (tree name, const basic_block bb)
 {
   gcc_checking_assert (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun));
@@ -333,7 +333,7 @@ block_range_cache::dump (FILE *f)
   for (x = 0; x < m_ssa_ranges.length (); ++x)
     {
       if (m_ssa_ranges[x])
-        {
+	{
 	  fprintf (f, " Ranges for ");
 	  print_generic_expr (f, ssa_name (x), TDF_NONE);
 	  fprintf (f, ":\n");
@@ -341,7 +341,6 @@ block_range_cache::dump (FILE *f)
 	  fprintf (f, "\n");
 	}
     }
-  
 }
 
 // Print all known ranges on entry to blobk BB to file F.
@@ -354,9 +353,9 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying)
   for (x = 1; x < m_ssa_ranges.length (); ++x)
     {
       if (!gimple_range_ssa_p (ssa_name (x)))
-        continue;
+	continue;
       if (m_ssa_ranges[x] && m_ssa_ranges[x]->get_bb_range (r, bb))
-        {
+	{
 	  if (!print_varying && r.varying_p ())
 	    {
 	      summarize_varying = true;
@@ -382,7 +381,7 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying)
 		{
 		  print_generic_expr (f, ssa_name (x), TDF_NONE);
 		  fprintf (f, "  ");
-	        }
+		}
 	    }
 	}
       fprintf (f, "\n");
@@ -414,7 +413,7 @@ ssa_global_cache::get_global_range (irange &r, tree name) const
   unsigned v = SSA_NAME_VERSION (name);
   if (v >= m_tab.length ())
     return false;
-   
+
   irange_storage *stow = m_tab[v];
   if (!stow)
     return false;
@@ -462,7 +461,7 @@ ssa_global_cache::clear ()
   memset (m_tab.address(), 0, m_tab.length () * sizeof (irange_storage *));
 }
 
-// Dump the contents of the global cache to F. 
+// Dump the contents of the global cache to F.
 
 void
 ssa_global_cache::dump (FILE *f)
@@ -475,9 +474,9 @@ ssa_global_cache::dump (FILE *f)
     if (gimple_range_ssa_p (ssa_name (x)) &&
 	get_global_range (r, ssa_name (x))  && !r.varying_p ())
       {
-        print_generic_expr (f, ssa_name (x), TDF_NONE);
+	print_generic_expr (f, ssa_name (x), TDF_NONE);
 	fprintf (f, "  : ");
-        r.dump (f);
+	r.dump (f);
 	fprintf (f, "\n");
       }
   fputc ('\n', f);
diff --git a/gcc/ssa-range-cache.h b/gcc/ssa-range-cache.h
index 3316c59..79827df 100644
--- a/gcc/ssa-range-cache.h
+++ b/gcc/ssa-range-cache.h
@@ -23,7 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 
 // This global cache is used with the range engine as markers for what
 // has been visited during this incarnation.  Once the ranger evaluates
-// a name, it is typically not re-evaluated again.   
+// a name, it is typically not re-evaluated again.
 
 typedef int_range<3> irange_storage;
 
@@ -42,7 +42,7 @@ private:
 };
 
 // Class used to track non-null references of an ssa-name
-// A vector of bitmaps indexed by ssa-name is maintained. When indexed by 
+// A vector of bitmaps indexed by ssa-name is maintained. When indexed by
 // Basic Block, an on-bit indicates there is a non-null dereference for
 // that ssa_name in that basic block.
 
diff --git a/gcc/ssa-range.cc b/gcc/ssa-range.cc
index 0ddd5bb..e8fe078 100644
--- a/gcc/ssa-range.cc
+++ b/gcc/ssa-range.cc
@@ -61,7 +61,7 @@ bool
 gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name)
 {
   bool res = false;
-  // If name is specified, make sure it a LHS of S.
+  // If name is specified, make sure it is a LHS of S.
   gcc_checking_assert (name ? SSA_NAME_DEF_STMT (name) == s : true);
 
   if (gimple_range_handler (s))
@@ -92,14 +92,14 @@ gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name)
       if (r.undefined_p ())
 	return true;
       if (name && TREE_TYPE (name) != r.type ())
-        range_cast (r, TREE_TYPE (name));
+	range_cast (r, TREE_TYPE (name));
       return true;
     }
   return false;
 }
 
 
-// Calculate a range for NAME on edge E and return it in R.  
+// Calculate a range for NAME on edge E and return it in R.
 // Return false if no range can be determined.
 
 void
@@ -107,7 +107,7 @@ gimple_ranger::range_on_edge (irange &r, edge e, tree name)
 {
   widest_irange edge_range;
   gcc_checking_assert (irange::supports_type_p (TREE_TYPE (name)));
-  
+
   // PHI arguments can be constants, catch these here.
   if (!gimple_range_ssa_p (name))
     {
@@ -147,7 +147,7 @@ gimple_ranger::range_on_exit (irange &r, basic_block bb ATTRIBUTE_UNUSED,
 
 
 // Calculate a range for range_op statement S and return it in R.  If any
-// If a range cannot be calculated, return false.  
+// If a range cannot be calculated, return false.
 
 bool
 gimple_ranger::range_of_range_op (irange &r, gimple *s)
@@ -172,8 +172,8 @@ gimple_ranger::range_of_range_op (irange &r, gimple *s)
 }
 
 
-// Calculate a range for phi statement S and return it in R. 
-// If a range cannot be calculated, return false.  
+// Calculate a range for phi statement S and return it in R.
+// If a range cannot be calculated, return false.
 
 bool
 gimple_ranger::range_of_phi (irange &r, gphi *phi)
@@ -205,8 +205,8 @@ gimple_ranger::range_of_phi (irange &r, gphi *phi)
 }
 
 
-// Calculate a range for call statement S and return it in R.  
-// If a range cannot be calculated, return false.  
+// Calculate a range for call statement S and return it in R.
+// If a range cannot be calculated, return false.
 
 bool
 gimple_ranger::range_of_call (irange &r, gcall *call)
@@ -225,8 +225,8 @@ gimple_ranger::range_of_call (irange &r, gcall *call)
 }
 
 
-// Calculate a range for COND_EXPR statement S and return it in R.  
-// If a range cannot be calculated, return false.  
+// Calculate a range for COND_EXPR statement S and return it in R.
+// If a range cannot be calculated, return false.
 
 bool
 gimple_ranger::range_of_cond_expr  (irange &r, gassign *s)
@@ -251,9 +251,9 @@ gimple_ranger::range_of_cond_expr  (irange &r, gassign *s)
     {
       // False, pick second operand
       if (cond_range.zero_p ())
-        r = range2;
+	r = range2;
       else
-        r = range1;
+	r = range1;
     }
   else
     {
@@ -267,7 +267,7 @@ gimple_ranger::range_of_cond_expr  (irange &r, gassign *s)
 // ------------------------------------------------------------------------
 
 
-// COnstruct a global_ranger object.
+// Construct a global_ranger object.
 
 global_ranger::global_ranger ()
 {
@@ -361,7 +361,7 @@ global_ranger::range_of_stmt (irange &r, gimple *s, tree name)
   gcc_checking_assert (TREE_CODE (name) == SSA_NAME &&
 		       irange::supports_type_p (TREE_TYPE (name)));
 
-  // If this STMT has already been processed, return that value. 
+  // If this STMT has already been processed, return that value.
   if (m_globals.get_global_range (r, name))
     return true;
  
@@ -393,8 +393,8 @@ global_ranger::range_of_ssa_name (irange &r, tree name, gimple *s)
 
   basic_block bb = gimple_bb (s);
   gimple *def_stmt = SSA_NAME_DEF_STMT (name);
-    
-  // if name is defined in this block, try to get an range from S.
+
+  // If name is defined in this block, try to get an range from S.
   if (def_stmt && gimple_bb (def_stmt) == bb)
     gcc_assert (range_of_stmt (r, def_stmt, name));
   else
@@ -405,9 +405,9 @@ global_ranger::range_of_ssa_name (irange &r, tree name, gimple *s)
   // We don't care if it's between the def and a use within a block
   // because the entire block must be executed anyway.
   // FIXME:?? For non-call exceptions we could have a statement throw
-  // which causes an early block exit. 
+  // which causes an early block exit.
   // in which case we may need to walk from S back to the def/top of block
-  // to make sure the deref happens between S and there before claiming 
+  // to make sure the deref happens between S and there before claiming
   // there is a deref.   Punt for now.
   if (!cfun->can_throw_non_call_exceptions && r.varying_p () &&
       non_null_deref_p (name, bb))
@@ -426,8 +426,8 @@ global_ranger::range_from_import (irange &r, tree name, irange &import_range)
   // This probably means the IL has changed underneath... just return false
   // until we have a more comprehensive solution
   if (!import || (import_range.undefined_p () ||
-                  useless_type_conversion_p (TREE_TYPE (import),
-                                             import_range.type ())))
+		  useless_type_conversion_p (TREE_TYPE (import),
+					     import_range.type ())))
     return false;
 
   // Only handling range_ops until we find a cond-expr that matters.
@@ -442,7 +442,7 @@ global_ranger::range_from_import (irange &r, tree name, irange &import_range)
   // its possible 2 different chains occur in one stmt, ie:
   // if (b_4 < d_6), but there is no DEF for this stmt, so it can't happen.
   // f_5 = b_4 + d_6 would have no import since there are 2 symbolics.
-  
+
   gimple *s = SSA_NAME_DEF_STMT (name);
   if (!s || !gimple_range_handler (s))
     return false;
@@ -555,7 +555,7 @@ global_ranger::dump (FILE *f)
 
       dump_bb (f, bb, 4, TDF_NONE);
 
-      // Now find any globals defined in this block 
+      // Now find any globals defined in this block
       for (x = 1; x < num_ssa_names; x++)
 	{
 	  tree name = ssa_name (x);
@@ -623,7 +623,7 @@ global_ranger::dump (FILE *f)
     }
 }
 
-// Calculate all ranges by visiting every block and asking for the range of 
+// Calculate all ranges by visiting every block and asking for the range of
 // each ssa_name on each statement, and then dump those ranges to OUTPUT.
 
 void
@@ -631,7 +631,7 @@ global_ranger::calculate_and_dump (FILE *output)
 {
   basic_block bb;
   widest_irange r;
-  
+
   //  Walk every statement asking for a range.
   FOR_EACH_BB_FN (bb, cfun)
     {
@@ -659,7 +659,7 @@ global_ranger::calculate_and_dump (FILE *output)
 	    {
 	      tree use = gimple_range_ssa_p (USE_FROM_PTR (use_p));
 	      if (use)
-	        range_of_expr (r, use, stmt);
+		range_of_expr (r, use, stmt);
 	    }
 	}
     }
@@ -669,7 +669,7 @@ global_ranger::calculate_and_dump (FILE *output)
 }
 
 // Return a static range for NAME on entry to basic block BB in R.
-// If calc is true, Fill any cache entries required between BB and the def 
+// If calc is true, Fill any cache entries required between BB and the def
 // block for NAME.  Otherwise, return false if the cache is empty.
 
 bool
@@ -686,14 +686,14 @@ global_ranger::block_range (irange &r, basic_block bb, tree name, bool calc)
       if (def_stmt)
 	def_bb = gimple_bb (def_stmt);;
       if (!def_bb)
-        {
+	{
 	  // IF we get to the entry block, this better be a default def
-	  // or range_on_entry was called fo a block not dominated by 
+	  // or range_on_entry was called fo a block not dominated by
 	  // the def.  This would be a bug.
 	  gcc_checking_assert (SSA_NAME_IS_DEFAULT_DEF (name));
 	  def_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
 	}
-      
+
       // There is no range on entry for the defintion block.
       if (def_bb == bb)
 	return false;
@@ -710,7 +710,7 @@ global_ranger::block_range (irange &r, basic_block bb, tree name, bool calc)
 // range-on-entry cache for E->src, then return false.
 // If this is the def block, then see if the DEF can be evaluated with them
 // import name, otherwise use varying as the range.
-// If there is any outgoing range information on edge E, incorporate it 
+// If there is any outgoing range information on edge E, incorporate it
 // into the results.
 
 bool
@@ -728,12 +728,12 @@ global_ranger::edge_range (irange &r, edge e, tree name)
       // in an evaluation to get a static starting value.
       // The import should have a range if the global range is requested
       // before any other lookups.
-      tree term = has_edge_range_p (e, name) ? m_gori_map.terminal_name (name)
-      					     : NULL_TREE;
+      tree term = (has_edge_range_p (e, name) ? m_gori_map.terminal_name (name)
+		   : NULL_TREE);
       if (!term || !(m_on_entry.get_bb_range (tmp, term, src) &&
 		     range_from_import (r, name, tmp)))
 	{
-	  // Try to pick up any known value first. 
+	  // Try to pick up any known value first.
 	  if (!m_globals.get_global_range (r, name))
 	    r = gimple_range_global (name);
 	}
@@ -764,7 +764,7 @@ global_ranger::add_to_update (basic_block bb)
 #define DEBUG_CACHE (0 && dump_file)
 
 // If there is anything in the iterative update_list, continue processing NAME
-// until the list of blocks is empty.  
+// until the list of blocks is empty.
 
 void
 global_ranger::iterative_cache_update (tree name)
@@ -777,10 +777,10 @@ global_ranger::iterative_cache_update (tree name)
   widest_irange e_range;
 
   // Process each block by seeing if it's calculated range on entry is the same
-  // as it's cached value. IF there is a difference, update the cache to 
-  // reflect the new value, and check to see if any successors have cache 
+  // as it's cached value. IF there is a difference, update the cache to
+  // reflect the new value, and check to see if any successors have cache
   // entries which may need to be checked for updates.
-  
+
   while (m_update_list.length () > 0)
     {
       bb = m_update_list.pop ();
@@ -801,7 +801,7 @@ if (DEBUG_CACHE) fprintf (dump_file, "FWD visiting block %d\n", bb->index);
 	{
 if (DEBUG_CACHE) { fprintf (dump_file, "updating range from/to "); current_range.dump (dump_file); new_range.dump (dump_file); }
 	  m_on_entry.set_bb_range (name, bb, new_range);
-	  // Mark each successor that has a range to re-check it's range 
+	  // Mark each successor that has a range to re-check it's range
 	  FOR_EACH_EDGE (e, ei, bb->succs)
 	    if (m_on_entry.bb_range_p (name, e->dest))
 	      add_to_update (e->dest);
@@ -811,7 +811,7 @@ if (DEBUG_CACHE) fprintf (dump_file, "DONE visiting blocks \n\n");
 }
 
 // Make sure that the range-on-entry cache for NAME is set for block BB.
-// Work back thourgh the CFG to DEF_BB ensuring the range is calculated 
+// Work back thourgh the CFG to DEF_BB ensuring the range is calculated
 // on the block/edges leading back to that point.
 
 void
@@ -851,7 +851,7 @@ if (DEBUG_CACHE)  fprintf (dump_file, "BACK visiting block %d\n", node->index);
 	  basic_block pred = e->src;
 	  widest_irange r;
 	  // If the pred block is the def block add this BB to update list.
-	  if (pred == def_bb) 
+	  if (pred == def_bb)
 	    {
 	      add_to_update (node);
 	      continue;
@@ -875,7 +875,7 @@ if (DEBUG_CACHE)  fprintf (dump_file, "BACK visiting block %d\n", node->index);
 		add_to_update (node);
 	      continue;
 	    }
-	    
+
 	  // If the pred hasn't been visited (has no range), add it to the list.
 	  gcc_checking_assert (!m_on_entry.bb_range_p (name, pred));
 	  m_on_entry.set_bb_range (name, pred, undefined);
@@ -962,7 +962,7 @@ trace_ranger::dumping (unsigned counter, bool trailing)
 	fprintf (dump_file, "         ");
       unsigned x;
       for (x = 0; x< indent; x++)
-        fputc (' ', dump_file);
+	fputc (' ', dump_file);
       return true;
     }
   return false;
@@ -1013,7 +1013,7 @@ trace_ranger::range_of_ssa_name (irange &r, tree name, gimple *s)
       if (s)
 	print_gimple_stmt (dump_file, s , 0, TDF_SLIM);
       else
-        fprintf (dump_file, " NULL\n");
+	fprintf (dump_file, " NULL\n");
       indent += bump;
     }
 
@@ -1121,7 +1121,7 @@ trace_ranger::outgoing_edge_range_p (irange &r, edge e, tree name,
 	  fprintf (dump_file, "\n");
 	}
       else
-        fputs ("NULL\n", dump_file);
+	fputs ("NULL\n", dump_file);
       indent += bump;
     }
 
diff --git a/gcc/ssa-range.h b/gcc/ssa-range.h
index 09f1d7c..941a84f 100644
--- a/gcc/ssa-range.h
+++ b/gcc/ssa-range.h
@@ -32,11 +32,11 @@ along with GCC; see the file COPYING3.  If not see
 // functionality at the statement level.  Ie, it can calculate ranges on
 // statements, but does no additonal lookup.
 //
-// All the range_of_* methods will return a range if the types is supported
-// by the range engine. It may be the full range for the type, AKA varying_p
-// or it may be a refined range.
-// If the range type is not supported, then false is returned.
-// non-statement related dwmethods return whatever the current global value is.
+// All the range_of_* methods will return a range if the types is
+// supported by the range engine.  It may be the full range for the
+// type, AKA varying_p or it may be a refined range.  If the range
+// type is not supported, then false is returned.  Non-statement
+// related methods return whatever the current global value is.
 
 class gimple_ranger : public gori_compute
 {
@@ -64,9 +64,9 @@ public:
   virtual bool range_of_stmt (irange &r, gimple *s, tree name = NULL_TREE);
 
   void export_global_ranges ();
-  
+
   void dump (FILE *f);
-  void calculate_and_dump (FILE *f);   /* Calculate all stmts and dump */
+  void calculate_and_dump (FILE *f);
 protected:
   virtual void range_of_ssa_name (irange &r, tree name, gimple *s = NULL);
   bool range_from_import (irange &r, tree name, irange &import_range);
@@ -128,16 +128,15 @@ private:
 		const irange &r);
 };
 
-  
 
-// Like global_ranger::range_of_expr (), but make an on-the-fly ranger.
-// Return TRUE if SSA as seen from within STMT has a known range the is not
-// varying.  Set this range in R.
+
+// Like global_ranger::range_of_expr (), but make an on-the-fly
+// ranger.  If SSA, as seen from STMT, has a known range, set it in R
+// and return TRUE.
 //
-// NOTE: There is overhead involved with this function, so it
-// should only be used for very lightweight or unrelated range
-// queries.  This function is mostly meant for range queries that
-// don't need caching in subsequent calls.  */
+// NOTE: There is overhead involved with this function, so it should
+// only be used for lightweight queries.  It is mostly meant for range
+// queries that don't need caching in subsequent calls.
 
 static inline bool
 on_demand_get_range_on_stmt (irange &r, tree ssa, gimple *stmt)
diff --git a/gcc/vr-values.c b/gcc/vr-values.c
index d327f22..f001aa4 100644
--- a/gcc/vr-values.c
+++ b/gcc/vr-values.c
@@ -469,7 +469,7 @@ simplify_using_ranges::op_with_boolean_value_range_p (tree op, gimple *stmt)
     return false;
 
   widest_irange r;
-  gcc_checking_assert (store->range_of_expr (r, op, stmt));
+  gcc_assert (store->range_of_expr (r, op, stmt));
   return (r.kind () == VR_RANGE
 	  && integer_zerop (r.min ())
 	  && integer_onep (r.max ()));
@@ -1029,7 +1029,7 @@ check_for_binary_op_overflow (range_store *store,
 {
   value_range vr0, vr1;
   if (TREE_CODE (op0) == SSA_NAME)
-    gcc_checking_assert (store->range_of_expr (vr0, op0));
+    gcc_assert (store->range_of_expr (vr0, op0));
   else if (TREE_CODE (op0) == INTEGER_CST)
     vr0.set (op0);
   else
@@ -2649,7 +2649,7 @@ find_case_label_ranges (gswitch *stmt, const irange *vr,
   tree case_low, case_high;
   tree min = vr->min (), max = vr->max ();
 
-  gcc_checking_assert (!vr->varying_p () && !vr->undefined_p ());
+  gcc_assert (!vr->varying_p () && !vr->undefined_p ());
 
   take_default = !find_case_label_range (stmt, min, max, &i, &j);
 
@@ -3145,7 +3145,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
     }
   else
     {
-      gcc_checking_assert (store->range_of_expr (vr, op0, stmt));
+      gcc_assert (store->range_of_expr (vr, op0, stmt));
       if (range_int_cst_p (&vr))
 	{
 	  op0min = vr.min ();
@@ -3157,7 +3157,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
       && TREE_CODE (op1) == SSA_NAME)
     {
       value_range vr1;
-      gcc_checking_assert (store->range_of_expr (vr1, op1, stmt));
+      gcc_assert (store->range_of_expr (vr1, op1, stmt));
       if (range_int_cst_p (&vr1))
 	op1min = vr1.min ();
     }
@@ -3263,13 +3263,13 @@ simplify_using_ranges::simplify_min_or_max_using_ranges
   tree op1 = gimple_assign_rhs2 (stmt);
   value_range vr0, vr1;
   if (TREE_CODE (op0) == SSA_NAME)
-    gcc_checking_assert (store->range_of_expr (vr0, op0, stmt));
+    gcc_assert (store->range_of_expr (vr0, op0, stmt));
   else if (TREE_CODE (op0) == INTEGER_CST)
     vr0.set (op0);
   else
     vr0.set_varying (TREE_TYPE (op0));
   if (TREE_CODE (op1) == SSA_NAME)
-    gcc_checking_assert (store->range_of_expr (vr1, op1, stmt));
+    gcc_assert (store->range_of_expr (vr1, op1, stmt));
   else if (TREE_CODE (op1) == INTEGER_CST)
     vr1.set (op1);
   else
@@ -3310,7 +3310,7 @@ simplify_using_ranges::simplify_abs_using_ranges (gimple_stmt_iterator *gsi,
 {
   tree op = gimple_assign_rhs1 (stmt);
   value_range vr;
-  gcc_checking_assert (store->range_of_expr (vr, op, stmt));
+  gcc_assert (store->range_of_expr (vr, op, stmt));
 
   if (!vr.varying_p () && !vr.undefined_p ())
     {
@@ -3400,14 +3400,14 @@ simplify_using_ranges::simplify_bit_ops_using_ranges
   wide_int mask;
 
   if (TREE_CODE (op0) == SSA_NAME)
-    gcc_checking_assert (store->range_of_expr (vr0, op0, stmt));
+    gcc_assert (store->range_of_expr (vr0, op0, stmt));
   else if (is_gimple_min_invariant (op0))
     vr0.set (op0);
   else
     return false;
 
   if (TREE_CODE (op1) == SSA_NAME)
-    gcc_checking_assert (store->range_of_expr (vr1, op1, stmt));
+    gcc_assert (store->range_of_expr (vr1, op1, stmt));
   else if (is_gimple_min_invariant (op1))
     vr1.set (op1);
   else
@@ -3622,7 +3622,7 @@ simplify_using_ranges::simplify_cond_using_ranges_1 (gcond *stmt)
       && is_gimple_min_invariant (op1))
     {
       value_range vr;
-      gcc_checking_assert (store->range_of_expr (vr, op0, stmt));
+      gcc_assert (store->range_of_expr (vr, op0, stmt));
 
       /* If we have range information for OP0, then we might be
 	 able to simplify this conditional. */
@@ -3726,7 +3726,7 @@ simplify_cond_using_ranges_2 (range_store *store, gcond *stmt)
 	  && desired_pro_or_demotion_p (TREE_TYPE (innerop), TREE_TYPE (op0)))
 	{
 	  value_range vr;
-	  gcc_checking_assert (store->range_of_expr (vr, innerop, stmt));
+	  gcc_assert (store->range_of_expr (vr, innerop, stmt));
 
 	  if (range_int_cst_p (&vr)
 	      && range_fits_type_p (&vr,
@@ -3767,7 +3767,7 @@ simplify_using_ranges::simplify_switch_using_ranges (gswitch *stmt)
 
   if (TREE_CODE (op) == SSA_NAME)
     {
-      gcc_checking_assert (store->range_of_expr (vr, op, stmt));
+      gcc_assert (store->range_of_expr (vr, op, stmt));
 
       /* We can only handle integer ranges.  */
       if (vr.varying_p ()
@@ -4058,7 +4058,7 @@ simplify_using_ranges::simplify_float_conversion_using_ranges
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
   value_range vr;
-  gcc_checking_assert (store->range_of_expr (vr, rhs1, stmt));
+  gcc_assert (store->range_of_expr (vr, rhs1, stmt));
   scalar_float_mode fltmode
     = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)));
   scalar_int_mode mode;
@@ -4223,7 +4223,7 @@ bool
 simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b)
 {
   value_range vr;
-  gcc_checking_assert (store->range_of_expr (vr, var));
+  gcc_assert (store->range_of_expr (vr, var));
   if (vr.varying_p ()
       || vr.undefined_p ()
       || TREE_CODE (vr.min ()) != INTEGER_CST