(reg_names): Make it static. Use DEBUG_REGISTER_NAMES if that's defined.

(DEBUG_PRINT_REG): Define if not defined.
(print_rtx): Use DEBUG_PRINT_REG for hard regs.

(reg_name): Moved here.
Get rid of RCS headers.  Fix up whitespace and comments.
Make key field and corresponding args `const void *'.
Don't use assert.
Get rid of spurious array-level in node_table field; make it void **.
Declare module_hash_table, class_hash_table.
(hash_int): Divide by sizeof (void *), not by 2**that minus 1.

From-SVN: r2455

gcc/objc/hash.h

-/* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
+/* Hash tables for Objective C method dispatch.
+   Copyright (C) 1992 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -22,64 +23,10 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
    This exception does not however invalidate any other reasons why
    the executable file might be covered by the GNU General Public License.  */
 
-/* 
-  $Header: /home/fsf/rms/c-runtime/dispatch/RCS/hash.h,v 0.12 1992/09/02 01:59:40 rms Exp rms $
-  $Author: rms $
-  $Date: 1992/09/02 01:59:40 $
-  $Log: hash.h,v $
- * Revision 0.12  1992/09/02  01:59:40  rms
- * Changed the format of various sections to conform with GNU standard.
- * Deleted dependencies on some header files.
- * Replaced the use of the functions from memory.h with funtions like bzero.
- * Changed the include format.
- *
- * Revision 0.11  1992/08/31  21:15:02  dglattin
- * minor documentation changes.
- *
- * Revision 0.10  1992/08/18  04:46:58  dglattin
- * Saving a working version before release.
- *
- * Revision 0.9  1992/04/13  11:43:08  dennisg
- * Check in after array version of run-time works.
- * Expect more changes as hash version and other changes are made.
- *
- * Revision 0.8  1991/12/10  12:05:28  dennisg
- * Cleaned up file format for a distribution.
- *
- * Revision 0.7  1991/12/03  02:01:23  dennisg
- * fixed assert macro.
- * added memory allocation adjustment macro for hash size allocation.
- *
- * Revision 0.6  1991/11/24  01:20:02  dennisg
- * changed shorts back to ints.
- * the efficiency gained didn't out weight the grossness of the code.
- *
- * Revision 0.5  1991/11/23  22:19:21  dennisg
- * converted some entries in the hash structure from ints to shorts.
- * this was done to use a less expensive division instruction
- * in the hashIndex  routine.
- *
- * Revision 0.4  1991/11/21  22:25:19  dennisg
- * deleted hash mask information from hash struct.
- * changed hashing algorithm.  those values are no longer needed.
- *
- * Revision 0.3  1991/11/07  23:23:40  dennisg
- * implemented hash table expansion as suggested by rms.
- *
- * Revision 0.2  1991/11/07  22:30:54  dennisg
- * added copyleft
- *
- * Revision 0.1  1991/10/24  00:45:39  dennisg
- * Initial check in.  Preliminary development stage.
- *
-*/
- 
 
-#ifndef _hash_INCLUDE_GNU
-#define _hash_INCLUDE_GNU
+#ifndef __hash_INCLUDE_GNU
+#define __hash_INCLUDE_GNU
 
-
-#include "assert.h"
 #include "mutex.h"
 
 
@@ -88,12 +35,13 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  *  stored in a hash table.  Each node holds 
  *  a key/value pair.
  *
- * Items in the cache are really of type void*.
+ * Items in the cache are really of type void *.
  */
-typedef struct cache_node {
+typedef struct cache_node
+{
   struct cache_node *next;	/* Pointer to next entry on the list.
 				   NULL indicates end of list. */
-  void *key;			/* Key used to locate the value.  Used
+  const void *key;		/* Key used to locate the value.  Used
 				   to locate value when more than one
 				   key computes the same hash
 				   value. */
@@ -110,7 +58,7 @@ typedef struct cache_node {
  * typedef.  Therefore, to remove compiler warnings the functions passed to
  * hash_new will have to be casted to this type. 
  */
-typedef unsigned int   (*hash_func_type)(void*, void*);
+typedef unsigned int (*hash_func_type)(void *, const void *);
 
 /*
  * This data type is the function that compares two hash keys and returns an
@@ -119,7 +67,7 @@ typedef unsigned int   (*hash_func_type)(void*, void*);
  * second. 
  */
 
-typedef int     (*compare_func_type)(void*, void*);
+typedef int (*compare_func_type)(const void *, const void *);
 
 
 /*
@@ -128,9 +76,10 @@ typedef int     (*compare_func_type)(void*, void*);
  * It must be passed to all of the hashing routines
  *   (except for new).
  */
-typedef struct cache {
+typedef struct cache
+{
   /* Variables used to implement the hash itself.  */
-  node_ptr  (*node_table)[]; /* Pointer to an array of hash nodes.  */
+  node_ptr *node_table; /* Pointer to an array of hash nodes.  */
   /* Variables used to track the size of the hash table so to determine
     when to resize it.  */
   unsigned int size; /* Number of buckets allocated for the hash table
@@ -151,10 +100,14 @@ typedef struct cache {
 } *cache_ptr;
 
 
+/* Two important hash tables.  */
+extern cache_ptr module_hash_table, class_hash_table;
+
 /* Allocate and initialize a hash table.  */ 
 
 cache_ptr hash_new (unsigned int size,
-		    hash_func_type hash_func, compare_func_type compare_func);
+		    hash_func_type hash_func,
+		    compare_func_type compare_func);
                        
 /* Deallocate all of the hash nodes and the cache itself.  */
 
@@ -165,12 +118,12 @@ void hash_delete (cache_ptr cache);
                                                    
    assert if the key is already in the hash.  */
 
-void hash_add (cache_ptr *cachep, void *key, void *value);
+void hash_add (cache_ptr *cachep, const void *key, void *value);
      
 /* Remove the key/value pair from the hash table.  
    assert if the key isn't in the table.  */
 
-void hash_remove (cache_ptr cache, void *key);
+void hash_remove (cache_ptr cache, const void *key);
 
 /* Used to index through the hash table.  Start with NULL
    to get the first entry.
@@ -185,7 +138,7 @@ node_ptr hash_next (cache_ptr cache, node_ptr node);
 
 /* Used to return a value from a hash table using a given key.  */
 
-void *hash_value_for_key (cache_ptr cache, void *key);
+void *hash_value_for_key (cache_ptr cache, const void *key);
 
 
 /************************************************
@@ -197,20 +150,20 @@ void *hash_value_for_key (cache_ptr cache, void *key);
 ************************************************/
 
 /* Calculate a hash code by performing some 
-   manipulation of the key pointer.  */
+   manipulation of the key pointer.  (Use the lowest bits
+   except for those likely to be 0 due to alignment.)  */
+
 static inline unsigned int 
-hash_int (cache_ptr cache, void *key)
+hash_int (cache_ptr cache, const void *key)
 {
-  assert (sizeof (unsigned int) == sizeof (key));
-
-  return ((unsigned int)key >> (sizeof (void *) - 1)) & cache->mask;
+  return ((unsigned int)key / sizeof (void *)) & cache->mask;
 }
 
 
 /* Calculate a hash code by iterating over a NULL 
    terminate string.  */
 static inline unsigned int 
-hash_string (cache_ptr cache, void *key)
+hash_string (cache_ptr cache, const void *key)
 {
   unsigned int ret = 0;
   unsigned int ctr = 0;
@@ -227,7 +180,7 @@ hash_string (cache_ptr cache, void *key)
 
 /* Compare two integers.  */
 static inline int 
-compare_ints (void *k1, void *k2)
+compare_ints (const void *k1, const void *k2)
 {
   return !((int)k1 - (int)k2);
 }
@@ -235,10 +188,10 @@ compare_ints (void *k1, void *k2)
 
 /* Compare two strings.  */
 static inline int 
-compare_strings (void *k1, void *k2)
+compare_strings (const void *k1, const void *k2)
 {
   return !strcmp (k1, k2);
 }
 
 
-#endif /* _hash_INCLUDE_GNU */
+#endif /* not __hash_INCLUDE_GNU */