Fwd: Fwd: Re: [patch] move htab_iterator

[Andrew MacLeod <amacleod at redhat dot com>]

bounced from gcc-patches... must have been some html creep in..
Andrew

-------- Original Message --------
Subject: 	Fwd: Re: [patch] move htab_iterator
Date: 	Tue, 01 Oct 2013 16:54:52 -0400
From: 	Andrew MacLeod <amacleod@redhat.com>
To: 	gcc-patches <gcc-patches@gcc.gnu.org>, tromey <tromey@redhat.com>, 
Ian Lance Taylor <ian@airs.com>, DJ Delorie <dj@redhat.com>




Anyone interested in approving the move of these hash table iterators 
into libiberty?  GCC is no longer using them, so I'm either deleting 
them, or moving them...

Thanks
Andrew

-------- Original Message --------
Subject: 	Re: [patch] move htab_iterator
Date: 	Mon, 30 Sep 2013 13:43:14 -0400
From: 	Andrew MacLeod <amacleod@redhat.com>
To: 	Tom Tromey <tromey@redhat.com>
CC: 	gcc-patches <gcc-patches@gcc.gnu.org>, Richard Biener 
<richard.guenther@gmail.com>, Jakub Jelinek <jakub@redhat.com>



On 09/30/2013 01:02 PM, Tom Tromey wrote:
> Tom> How about putting it into libiberty?
> Tom> That way other hashtab users, like gdb, can use it.
>
> Andrew> I have no problem with that, but Jakub didn't seem to think it
> Andrew> belonged there.
>
> All I found was this:
>
> http://gcc.gnu.org/ml/gcc-patches/2013-09/msg00721.html
>
> Quoting from it: "It doesn't belong to hashtab.h, because that is a
> libiberty API, this style of iterators is GCC specific."
>
> I think that's an accurate assessment of the current code, but I don't
> see why it has to continue to be that way.
>
> My argument in favor of moving it to libiberty is that other programs
> can then use it; and furthermore that since it is tightly tied to the
> hashtab implementation, it ought to be maintained there in order to
> preserve the module boundary.
>
> So, please reconsider.
Sure, how's this?

And who has to approve the libiberty bits?

Bootstrapping now... but since its unused I doubt that will be an issue
:-)...

Andrew








	gcc
	* tree-flow.h (htab_iterator, FOR_EACH_HTAB_ELEMENT): Move from here.
	* tree-flow-inline.h (first_htab_element, end_htab_p,
	next_htab_element): Also move from here.

	include
	* hashtab.h (htab_iterator, FOR_EACH_HTAB_ELEMENT,
	first_htab_element, end_htab_p, next_htab_element): Move to here.
	Change boolean to int and 0/1.

Index: gcc/tree-flow.h
===================================================================
*** gcc/tree-flow.h	(revision 203034)
--- gcc/tree-flow.h	(working copy)
*************** struct GTY(()) gimple_df {
*** 92,112 ****
    htab_t GTY ((param_is (struct tm_restart_node))) tm_restart;
  };
  
- 
- typedef struct
- {
-   htab_t htab;
-   PTR *slot;
-   PTR *limit;
- } htab_iterator;
- 
- /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
-    storing each element in RESULT, which is of type TYPE.  */
- #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
-   for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
- 	!end_htab_p (&(ITER)); \
- 	RESULT = (TYPE) next_htab_element (&(ITER)))
- 
  /* It is advantageous to avoid things like life analysis for variables which
     do not need PHI nodes.  This enum describes whether or not a particular
     variable may need a PHI node.  */
--- 92,97 ----
Index: gcc/tree-flow-inline.h
===================================================================
*** gcc/tree-flow-inline.h	(revision 203034)
--- gcc/tree-flow-inline.h	(working copy)
*************** gimple_vop (const struct function *fun)
*** 42,93 ****
    return fun->gimple_df->vop;
  }
  
- /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
- 
- static inline void *
- first_htab_element (htab_iterator *hti, htab_t table)
- {
-   hti->htab = table;
-   hti->slot = table->entries;
-   hti->limit = hti->slot + htab_size (table);
-   do
-     {
-       PTR x = *(hti->slot);
-       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
- 	break;
-     } while (++(hti->slot) < hti->limit);
- 
-   if (hti->slot < hti->limit)
-     return *(hti->slot);
-   return NULL;
- }
- 
- /* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
-    or NULL if we have  reached the end.  */
- 
- static inline bool
- end_htab_p (const htab_iterator *hti)
- {
-   if (hti->slot >= hti->limit)
-     return true;
-   return false;
- }
- 
- /* Advance the hashtable iterator pointed to by HTI to the next element of the
-    hashtable.  */
- 
- static inline void *
- next_htab_element (htab_iterator *hti)
- {
-   while (++(hti->slot) < hti->limit)
-     {
-       PTR x = *(hti->slot);
-       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
- 	return x;
-     };
-   return NULL;
- }
- 
  /* Get the number of the next statement uid to be allocated.  */
  static inline unsigned int
  gimple_stmt_max_uid (struct function *fn)
--- 42,47 ----
Index: include/hashtab.h
===================================================================
*** include/hashtab.h	(revision 203034)
--- include/hashtab.h	(working copy)
*************** extern hashval_t iterative_hash (const v
*** 202,207 ****
--- 202,270 ----
  /* Shorthand for hashing something with an intrinsic size.  */
  #define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof (OB), INIT)
  
+ /* GCC style hash table iterator.  */
+ 
+ typedef struct
+ {
+   htab_t htab;
+   PTR *slot;
+   PTR *limit;
+ } htab_iterator;
+ 
+ /* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
+    storing each element in RESULT, which is of type TYPE.  */
+ #define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
+   for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
+ 	!end_htab_p (&(ITER)); \
+ 	RESULT = (TYPE) next_htab_element (&(ITER)))
+ 
+ 
+ /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
+ 
+ static inline void *
+ first_htab_element (htab_iterator *hti, htab_t table)
+ {
+   hti->htab = table;
+   hti->slot = table->entries;
+   hti->limit = hti->slot + htab_size (table);
+   do
+     {
+       PTR x = *(hti->slot);
+       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ 	break;
+     } while (++(hti->slot) < hti->limit);
+ 
+   if (hti->slot < hti->limit)
+     return *(hti->slot);
+   return NULL;
+ }
+ 
+ /* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
+    or NULL if we have  reached the end.  */
+ 
+ static inline int
+ end_htab_p (const htab_iterator *hti)
+ {
+   if (hti->slot >= hti->limit)
+     return 1;
+   return 0;
+ }
+ 
+ /* Advance the hashtable iterator pointed to by HTI to the next element of the
+    hashtable.  */
+ 
+ static inline void *
+ next_htab_element (htab_iterator *hti)
+ {
+   while (++(hti->slot) < hti->limit)
+     {
+       PTR x = *(hti->slot);
+       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ 	return x;
+     };
+   return NULL;
+ }
+ 
  #ifdef __cplusplus
  }
  #endif /* __cplusplus */