c-common.c (const_strip_array_types): New.

	* c-common.c (const_strip_array_types): New.
	* c-common.h (lang_missing_noreturn_ok_p): Delete.
	(const_strip_array_types): New.
	* c-objc-common.c (c_disregard_inline_limits,
	c_warn_unused_global_decl): Constify.
	* c-tree.h (c_disregard_inline_limits, c_warn_unused_global_decl,
	c_vla_type_p, c_incomplete_type_error): Likewise.
	* c-typeck.c (c_incomplete_type_error, c_vla_type_p): Likewise.
	* hooks.c (hook_bool_const_tree_false): New.
	* hooks.h (hook_bool_const_tree_false): Likewise.
	* langhooks-def.h (lhd_warn_unused_global_decl,
	lhd_incomplete_type_error, lhd_expr_size,
	lhd_tree_inlining_disregard_inline_limits,
	lhd_tree_inlining_auto_var_in_fn_p, lhd_tree_dump_type_quals,
	LANG_HOOKS_GENERIC_TYPE_P, LANG_HOOKS_TYPE_MAX_SIZE): Constify.
	* langhooks.c (lhd_warn_unused_global_decl,
	lhd_incomplete_type_error,
	lhd_tree_inlining_disregard_inline_limits,
	lhd_tree_inlining_auto_var_in_fn_p, lhd_tree_dump_type_quals,
	lhd_expr_size): Likewise.
	* langhooks.h (lang_hooks_for_tree_inlining,
	lang_hooks_for_tree_dump, lang_hooks_for_types,
	lang_hooks_for_decls, lang_hooks): Likewise.
	* pointer-set.c (pointer_set_t, pointer_set_create,
	pointer_set_contains, insert_aux, pointer_set_insert,
	pointer_set_traverse, pointer_map_t, pointer_map_create,
	pointer_map_contains, pointer_map_insert, pointer_map_traverse):
	Likewise.
	* pointer-set.h (pointer_set_contains, pointer_set_insert,
	pointer_set_traverse, pointer_map_contains, pointer_map_insert,
	pointer_map_traverse): Likewise.
	* predict.c (assert_is_empty): Likewise.
	* tree-affine.c (free_name_expansion): Likewise.
	* tree-cfg.c (edge_to_cases_cleanup): Likewise.
	* tree.c (size_in_bytes, max_int_size_in_bytes): Likewise.
	* tree.h (size_in_bytes, max_int_size_in_bytes): Likewise.
	
ada:
	* misc.c (gnat_type_max_size): Constify.

cp:
	* cp-objcp-common.c (cxx_warn_unused_global_decl, cp_expr_size):
	Constify.
	* cp-tree.h (local_variable_p, nonstatic_local_decl_p,
	class_tmpl_impl_spec_p, cp_auto_var_in_fn_p, cp_type_quals,
	cxx_incomplete_type_diagnostic, cxx_incomplete_type_error,
	cxx_warn_unused_global_decl, cp_expr_size): Likewise.
	* decl.c (local_variable_p, nonstatic_local_decl_p): Likewise.
	* tree.c (class_tmpl_impl_spec_p, cp_auto_var_in_fn_p): Likewise.
	* typeck.c (cp_type_quals): Likewise.
	* typeck2.c (cxx_incomplete_type_diagnostic,
	cxx_incomplete_type_error): Likewise.

From-SVN: r127560

1 files changed, 17 insertions, 17 deletions

diff --git a/gcc/pointer-set.c b/gcc/pointer-set.c
index 1c733a7..b57c404 100644
--- a/gcc/pointer-set.c
+++ b/gcc/pointer-set.c
@@ -34,7 +34,7 @@ struct pointer_set_t
   size_t n_slots;		/* n_slots = 2^log_slots */
   size_t n_elements;
 
-  void **slots;
+  const void **slots;
 };
 
 /* Use the multiplicative method, as described in Knuth 6.4, to obtain
@@ -77,7 +77,7 @@ pointer_set_create (void)
   result->log_slots = 8;
   result->n_slots = (size_t) 1 << result->log_slots;
 
-  result->slots = XCNEWVEC (void *, result->n_slots);
+  result->slots = XCNEWVEC (const void *, result->n_slots);
   return result;
 }
 
@@ -93,7 +93,7 @@ pointer_set_destroy (struct pointer_set_t *pset)
 
    Collisions are resolved by linear probing.  */
 int
-pointer_set_contains (struct pointer_set_t *pset, const void *p)
+pointer_set_contains (const struct pointer_set_t *pset, const void *p)
 {
   size_t n = hash1 (p, pset->n_slots, pset->log_slots);
 
@@ -115,7 +115,7 @@ pointer_set_contains (struct pointer_set_t *pset, const void *p)
 /* Subroutine of pointer_set_insert.  Return the insertion slot for P into
    an empty element of SLOTS, an array of length N_SLOTS.  */
 static inline size_t
-insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
+insert_aux (const void *p, const void **slots, size_t n_slots, size_t log_slots)
 {
   size_t n = hash1 (p, n_slots, log_slots);
   while (true)
@@ -134,7 +134,7 @@ insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
 /* Inserts P into PSET if it wasn't already there.  Returns nonzero
    if it was already there. P must be nonnull.  */
 int
-pointer_set_insert (struct pointer_set_t *pset, void *p)
+pointer_set_insert (struct pointer_set_t *pset, const void *p)
 {
   size_t n;
 
@@ -144,12 +144,12 @@ pointer_set_insert (struct pointer_set_t *pset, void *p)
     {
       size_t new_log_slots = pset->log_slots + 1;
       size_t new_n_slots = pset->n_slots * 2;
-      void **new_slots = XCNEWVEC (void *, new_n_slots);
+      const void **new_slots = XCNEWVEC (const void *, new_n_slots);
       size_t i;
 
       for (i = 0; i < pset->n_slots; ++i)
         {
-	  void *value = pset->slots[i];
+	  const void *value = pset->slots[i];
 	  n = insert_aux (value, new_slots, new_n_slots, new_log_slots);
 	  new_slots[n] = value;
 	}
@@ -172,8 +172,8 @@ pointer_set_insert (struct pointer_set_t *pset, void *p)
 /* Pass each pointer in PSET to the function in FN, together with the fixed
    parameter DATA.  If FN returns false, the iteration stops.  */
 
-void pointer_set_traverse (struct pointer_set_t *pset,
-			   bool (*fn) (void *, void *), void *data)
+void pointer_set_traverse (const struct pointer_set_t *pset,
+			   bool (*fn) (const void *, void *), void *data)
 {
   size_t i;
   for (i = 0; i < pset->n_slots; ++i)
@@ -194,7 +194,7 @@ struct pointer_map_t
   size_t n_slots;		/* n_slots = 2^log_slots */
   size_t n_elements;
 
-  void **keys;
+  const void **keys;
   void **values;
 };
 
@@ -208,7 +208,7 @@ pointer_map_create (void)
   result->log_slots = 8;
   result->n_slots = (size_t) 1 << result->log_slots;
 
-  result->keys = XCNEWVEC (void *, result->n_slots);
+  result->keys = XCNEWVEC (const void *, result->n_slots);
   result->values = XCNEWVEC (void *, result->n_slots);
   return result;
 }
@@ -226,7 +226,7 @@ void pointer_map_destroy (struct pointer_map_t *pmap)
 
    Collisions are resolved by linear probing.  */
 void **
-pointer_map_contains (struct pointer_map_t *pmap, const void *p)
+pointer_map_contains (const struct pointer_map_t *pmap, const void *p)
 {
   size_t n = hash1 (p, pmap->n_slots, pmap->log_slots);
 
@@ -248,7 +248,7 @@ pointer_map_contains (struct pointer_map_t *pmap, const void *p)
 /* Inserts P into PMAP if it wasn't already there.  Returns a pointer
    to the value.  P must be nonnull.  */
 void **
-pointer_map_insert (struct pointer_map_t *pmap, void *p)
+pointer_map_insert (struct pointer_map_t *pmap, const void *p)
 {
   size_t n;
 
@@ -258,14 +258,14 @@ pointer_map_insert (struct pointer_map_t *pmap, void *p)
     {
       size_t new_log_slots = pmap->log_slots + 1;
       size_t new_n_slots = pmap->n_slots * 2;
-      void **new_keys = XCNEWVEC (void *, new_n_slots);
+      const void **new_keys = XCNEWVEC (const void *, new_n_slots);
       void **new_values = XCNEWVEC (void *, new_n_slots);
       size_t i;
 
       for (i = 0; i < pmap->n_slots; ++i)
 	if (pmap->keys[i])
 	  {
-	    void *key = pmap->keys[i];
+	    const void *key = pmap->keys[i];
 	    n = insert_aux (key, new_keys, new_n_slots, new_log_slots);
 	    new_keys[n] = key;
 	    new_values[n] = pmap->values[i];
@@ -293,8 +293,8 @@ pointer_map_insert (struct pointer_map_t *pmap, void *p)
    to the value and the fixed parameter DATA.  If FN returns false, the
    iteration stops.  */
 
-void pointer_map_traverse (struct pointer_map_t *pmap,
-			   bool (*fn) (void *, void **, void *), void *data)
+void pointer_map_traverse (const struct pointer_map_t *pmap,
+			   bool (*fn) (const void *, void **, void *), void *data)
 {
   size_t i;
   for (i = 0; i < pmap->n_slots; ++i)