+2014-12-19 Jan Hubicka <hubicka@ucw.cz>
+
+ * hash-table.h (struct pointer_hash): Fix formating.
+ (hash_table_higher_prime_index): Declare pure.
+ (hash_table_mod2, hash_table_mod1, mul_mod): Move inline;
+ assume that uint64_t always exists.
+ (hash_table<Descriptor, Allocator, false>): Use gcc_checking_assert.
+ (hash_table<Descriptor, Allocator, false>::expand ()): Fix formating.
+ (hash_table<Descriptor, Allocator, false>::clear_slot (value_type **slot)):
+ Use checking assert.
+ * hash-table.c: Remove #if 0 code.
+ (hash_table_higher_prime_index): Use gcc_assert.
+ (mul_mod, hash-table_mod1, hash_table_mod2): move to hash-table.h
+
2014-12-19 Matthew Fortune <matthew.fortune@imgtec.com>
* config.gcc: Support mips*-img-linux* and mips*-img-elf*.
For the record, here's the function that computed the table; it's a
vastly simplified version of the function of the same name from gcc. */
-#if 0
-unsigned int
-ceil_log2 (unsigned int x)
-{
- int i;
- for (i = 31; i >= 0 ; --i)
- if (x > (1u << i))
- return i+1;
- abort ();
-}
-
-unsigned int
-choose_multiplier (unsigned int d, unsigned int *mlp, unsigned char *shiftp)
-{
- unsigned long long mhigh;
- double nx;
- int lgup, post_shift;
- int pow, pow2;
- int n = 32, precision = 32;
-
- lgup = ceil_log2 (d);
- pow = n + lgup;
- pow2 = n + lgup - precision;
-
- nx = ldexp (1.0, pow) + ldexp (1.0, pow2);
- mhigh = nx / d;
-
- *shiftp = lgup - 1;
- *mlp = mhigh;
- return mhigh >> 32;
-}
-#endif
-
struct prime_ent const prime_tab[] = {
{ 7, 0x24924925, 0x9999999b, 2 },
{ 13, 0x3b13b13c, 0x745d1747, 3 },
}
/* If we've run out of primes, abort. */
- if (n > prime_tab[low].prime)
- {
- fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
- abort ();
- }
+ gcc_assert (n <= prime_tab[low].prime);
return low;
}
-/* Return X % Y using multiplicative inverse values INV and SHIFT.
-
- The multiplicative inverses computed above are for 32-bit types,
- and requires that we be able to compute a highpart multiply.
-
- FIX: I am not at all convinced that
- 3 loads, 2 multiplications, 3 shifts, and 3 additions
- will be faster than
- 1 load and 1 modulus
- on modern systems running a compiler. */
-
-#ifdef UNSIGNED_64BIT_TYPE
-static inline hashval_t
-mul_mod (hashval_t x, hashval_t y, hashval_t inv, int shift)
-{
- __extension__ typedef UNSIGNED_64BIT_TYPE ull;
- hashval_t t1, t2, t3, t4, q, r;
-
- t1 = ((ull)x * inv) >> 32;
- t2 = x - t1;
- t3 = t2 >> 1;
- t4 = t1 + t3;
- q = t4 >> shift;
- r = x - (q * y);
-
- return r;
-}
-#endif
-
-/* Compute the primary table index for HASH given current prime index. */
-
-hashval_t
-hash_table_mod1 (hashval_t hash, unsigned int index)
-{
- const struct prime_ent *p = &prime_tab[index];
-#ifdef UNSIGNED_64BIT_TYPE
- if (sizeof (hashval_t) * CHAR_BIT <= 32)
- return mul_mod (hash, p->prime, p->inv, p->shift);
-#endif
- return hash % p->prime;
-}
-
-
-/* Compute the secondary table index for HASH given current prime index. */
-
-hashval_t
-hash_table_mod2 (hashval_t hash, unsigned int index)
-{
- const struct prime_ent *p = &prime_tab[index];
-#ifdef UNSIGNED_64BIT_TYPE
- if (sizeof (hashval_t) * CHAR_BIT <= 32)
- return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift);
-#endif
- return 1 + hash % (p->prime - 2);
-}
static inline hashval_t hash (const value_type &);
- static inline bool equal (const value_type &existing, const compare_type &candidate);
+ static inline bool equal (const value_type &existing,
+ const compare_type &candidate);
};
template <typename Type>
/* Functions for computing hash table indexes. */
-extern unsigned int hash_table_higher_prime_index (unsigned long n);
-extern hashval_t hash_table_mod1 (hashval_t hash, unsigned int index);
-extern hashval_t hash_table_mod2 (hashval_t hash, unsigned int index);
+extern unsigned int hash_table_higher_prime_index (unsigned long n)
+ ATTRIBUTE_PURE;
+
+/* Return X % Y using multiplicative inverse values INV and SHIFT.
+
+ The multiplicative inverses computed above are for 32-bit types,
+ and requires that we be able to compute a highpart multiply.
+
+ FIX: I am not at all convinced that
+ 3 loads, 2 multiplications, 3 shifts, and 3 additions
+ will be faster than
+ 1 load and 1 modulus
+ on modern systems running a compiler. */
+
+inline hashval_t
+mul_mod (hashval_t x, hashval_t y, hashval_t inv, int shift)
+{
+ hashval_t t1, t2, t3, t4, q, r;
+
+ t1 = ((uint64_t)x * inv) >> 32;
+ t2 = x - t1;
+ t3 = t2 >> 1;
+ t4 = t1 + t3;
+ q = t4 >> shift;
+ r = x - (q * y);
+
+ return r;
+}
+
+/* Compute the primary table index for HASH given current prime index. */
+
+inline hashval_t
+hash_table_mod1 (hashval_t hash, unsigned int index)
+{
+ const struct prime_ent *p = &prime_tab[index];
+ gcc_checking_assert (sizeof (hashval_t) * CHAR_BIT <= 32);
+ return mul_mod (hash, p->prime, p->inv, p->shift);
+}
+
+/* Compute the secondary table index for HASH given current prime index. */
+
+inline hashval_t
+hash_table_mod2 (hashval_t hash, unsigned int index)
+{
+ const struct prime_ent *p = &prime_tab[index];
+ gcc_checking_assert (sizeof (hashval_t) * CHAR_BIT <= 32);
+ return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift);
+}
/* The below is some template meta programming to decide if we should use the
hash table partial specialization that directly stores value_type instead of
if (*slot == HTAB_EMPTY_ENTRY)
return slot;
- else if (*slot == HTAB_DELETED_ENTRY)
- abort ();
+ gcc_checking_assert (*slot != HTAB_DELETED_ENTRY);
hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
slot = m_entries + index;
if (*slot == HTAB_EMPTY_ENTRY)
return slot;
- else if (*slot == HTAB_DELETED_ENTRY)
- abort ();
+ gcc_checking_assert (*slot != HTAB_DELETED_ENTRY);
}
}
table entries is changed. If memory allocation fails, this function
will abort. */
- template<typename Descriptor, template<typename Type> class Allocator>
+template<typename Descriptor, template<typename Type> class Allocator>
void
hash_table<Descriptor, Allocator, false>::expand ()
{
void
hash_table<Descriptor, Allocator, false>::clear_slot (value_type **slot)
{
- if (slot < m_entries || slot >= m_entries + size ()
- || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
- abort ();
+ gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size ()
+ || *slot == HTAB_EMPTY_ENTRY
+ || *slot == HTAB_DELETED_ENTRY));
Descriptor::remove (*slot);
if (is_empty (*slot))
return slot;
- else if (is_deleted (*slot))
- abort ();
+#ifdef ENABLE_CHECKING
+ gcc_checking_assert (!is_deleted (*slot));
+#endif
hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
slot = m_entries + index;
if (is_empty (*slot))
return slot;
- else if (is_deleted (*slot))
- abort ();
+#ifdef ENABLE_CHECKING
+ gcc_checking_assert (!is_deleted (*slot));
+#endif
}
}
void
hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot)
{
- if (slot < m_entries || slot >= m_entries + size ()
- || is_empty (*slot) || is_deleted (*slot))
- abort ();
+ gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size ()
+ || is_empty (*slot) || is_deleted (*slot)));
Descriptor::remove (*slot);
projects / gcc.git / commitdiff