diff mbox

move htab_iterator

Message ID 5249B832.8000504@redhat.com
State New
Headers show

Commit Message

Andrew MacLeod Sept. 30, 2013, 5:43 p.m. UTC 
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

Comments

Tom Tromey Oct. 1, 2013, 8:23 p.m. UTC | #1 
>>>>> "Andrew" == Andrew MacLeod <amacleod@redhat.com> writes:

Andrew> Sure, how's this?

Thanks!

Andrew> And who has to approve the libiberty bits?

libiberty		DJ Delorie		dj@redhat.com
libiberty		Ian Lance Taylor	ian@airs.com

Tom
DJ Delorie Oct. 1, 2013, 9:04 p.m. UTC | #2 
I'm typically against adding things to libiberty "because there's no
other place for them".  The purpose of libiberty is to provide a
portability layer, not a trash can.  However, htab is already in
there, and the argument for putting its accessors there is sound.

However, most of the other functions in hashtab.h are of the form
htab_*().  Could these be changed to match that pattern?  If these
functions are unused, it shouldn't matter to rename them.  (although,
if they're unused, it shouldn't matter to discard them, either)
diff mbox

Patch



	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 */