2012-02-02 Vladimir Makarov <vmakarov@redhat.com>

[pf3gnuchains/gcc-fork.git] / gcc / pointer-set.c

diff --git a/gcc/pointer-set.c b/gcc/pointer-set.c
index 1c733a7..b57c404 100644 (file)
--- 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)