/* Copyright (C) 2012-2018 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ #ifndef _VTV_MAP_H #define _VTV_MAP_H 1 #include <string.h> #ifdef __MINGW32__ #include <stdint.h> #include "vtv_utils.h" #else #include <vtv_utils.h> #endif inline uint64_t load8bytes (const void *p) { uint64_t result; memcpy (&result, p, 8); return result; } /* Insert_only_hash_map maps keys to values. The implementation is a basic hash table with open addressing. The keys are not "owned" by the table; it only stores pointers to keys. The key type is specified below (see insert_only_hash_map::key_type) and is, roughly speaking, a string of any length with the string length and a hash code stored at the front. The code here does not compute any hash codes, but rather uses what's given. */ template<typename T, typename Alloc> class insert_only_hash_map { public: typedef size_t size_type; typedef T value_type; typedef Alloc alloc_type; enum { min_capacity = 4 }; #if HASHMAP_STATS enum { stats = true }; #else enum { stats = false }; #endif /* Keys are a byte string (up to 2^32 - 1 long) plus a uint32_t that's used as a hash code. The latter can encode arbitrary information at the client's discretion, so, e.g., multiple keys that are the same string still "differ" if the hash codes differ. Keys are equal if the first 8 bytes are equal and the next n bytes are equal. */ struct key_type { uint32_t n; uint32_t hash; char bytes[0]; bool equals (const key_type *k) const; }; /* Create an empty map with a reasonable number of buckets for the expected size. Returns NULL if the allocator fails. */ static insert_only_hash_map * create (size_type expected_size); /* The opposite of create(). Free the memory for the given map. */ static void destroy (insert_only_hash_map *m) { Alloc().dealloc (m, m->size_in_bytes_); } /* Return a map identical to this except that *k is mapped to v. Typcially it's done by modifying this in place, but if a resize is necessary then this is deallocated and a new map is returned. Requires k to be non-NULL. Does nothing and returns NULL if the allocator fails. */ insert_only_hash_map* put (const key_type *k, const value_type &v) { return this->put_internal (k, v, false); } /* If *k is a key in this then set *v to point to the corresponding value. Otherwise, do the equivalent of insert(k, value_type()) and, if that succeeds, set *v to point to the inserted value. Requires k to be non-NULL. Does nothing and returns NULL if the allocator fails. Typically returns this, but will return a new insert_only_hash_map if a resize occurs. If the return value is non-NULL, *v is set and it's valid until a resize of the map that is the return value. */ insert_only_hash_map * find_or_add_key (const key_type *k, value_type **v); /* Get the value corresponding to *k. Returns NULL if there is none. Requires k to be non-NULL. The return value is valid until any resize. */ const value_type *get (const key_type *k) const; size_type size () const { return num_entries_; } bool empty () const { return this->size () == 0; } size_type bucket_count () const { return num_buckets_; } private: typedef std::pair <const key_type *, value_type> bucket_type; insert_only_hash_map *put_internal (const key_type *, const value_type &, bool); /* This function determines when to resize the table. */ bool is_too_full (size_type entries) const { return entries > (this->bucket_count () * 0.7); } /* Return a copy with double the number of buckets. Returns NULL if the allocator fails. Otherwise, calls destroy (this). */ insert_only_hash_map *destructive_copy (); /* Must be a power of 2 not less than min_capacity. */ size_type num_buckets_; size_type num_entries_; size_type size_in_bytes_; bucket_type buckets[0]; /* Actual array size is num_buckets. */ }; template <typename T, typename Alloc> insert_only_hash_map <T, Alloc> * insert_only_hash_map <T, Alloc>::create (size_type expected_size) { size_t cap = min_capacity; while (expected_size >= cap) { cap *= 2; } size_t size_in_bytes = sizeof (insert_only_hash_map <T, Alloc>) + cap * sizeof (bucket_type); insert_only_hash_map <T, Alloc>* result = static_cast <insert_only_hash_map <T, Alloc>*> (Alloc () .alloc (size_in_bytes)); if (result != NULL) { result->size_in_bytes_ = size_in_bytes; result->num_buckets_ = cap; result->num_entries_ = 0; memset (result->buckets, 0, cap * sizeof (bucket_type)); } return result; } template <typename T, typename Alloc> insert_only_hash_map <T, Alloc>* insert_only_hash_map <T, Alloc>::destructive_copy () { insert_only_hash_map* copy = create (this->bucket_count ()); if (copy == NULL) return NULL; VTV_DEBUG_ASSERT (copy->bucket_count () == 2 * this->bucket_count ()); for (size_type i = 0; i < this->bucket_count (); i++) if (this->buckets[i].first != NULL) copy->put_internal (this->buckets[i].first, this->buckets[i].second, true); VTV_DEBUG_ASSERT (copy->size () == this->size ()); destroy (this); return copy; } template <typename T, typename Alloc> insert_only_hash_map <T, Alloc>* insert_only_hash_map <T, Alloc>::find_or_add_key (const key_type *k, value_type **v) { /* Table size is always a power of 2. */ const size_type mask = this->bucket_count () - 1; size_type bucket_index = k->hash & mask; size_type step = 1; for (;;) { bucket_type &bucket = this->buckets[bucket_index]; if (bucket.first == NULL) { /* Key was not present. */ if (this->is_too_full (this->size () + 1)) { insert_only_hash_map <T, Alloc>* result = this->destructive_copy (); return result == NULL ? NULL : result->find_or_add_key (k, v); } else { bucket.first = k; bucket.second = T (); this->num_entries_++; *v = &bucket.second; return this; } } else if (bucket.first->equals (k)) { /* Key was present. */ *v = &bucket.second; return this; } else bucket_index = (bucket_index + step++) & mask; } } template <typename T, typename Alloc> insert_only_hash_map <T, Alloc>* insert_only_hash_map <T, Alloc>::put_internal ( const insert_only_hash_map::key_type *k, const insert_only_hash_map::value_type &v, bool unique_key_and_resize_not_needed) { /* Table size is always a power of 2. */ const size_type mask = this->bucket_count () - 1; size_type bucket_index = k->hash & mask; size_type step = 1; for (;;) { bucket_type &bucket = this->buckets[bucket_index]; if (bucket.first == NULL) { /* Key was not present. */ if (!unique_key_and_resize_not_needed && this->is_too_full (this->size () + 1)) { insert_only_hash_map <T, Alloc>* result = this->destructive_copy (); return result == NULL ? NULL : result->put_internal (k, v, true); } else { bucket.first = k; bucket.second = v; this->num_entries_++; return this; } } else if (!unique_key_and_resize_not_needed && bucket.first->equals (k)) { /* Key was present. Just change the value. */ bucket.second = v; return this; } else bucket_index = (bucket_index + step++) & mask; } } template <typename T, typename Alloc> inline const typename insert_only_hash_map <T, Alloc>::value_type* insert_only_hash_map <T, Alloc>::get (const insert_only_hash_map::key_type *k) const { /* Table size is always a power of 2. */ const size_type mask = this->bucket_count () - 1; size_type bucket_index = k->hash & mask; size_type step = 1; for (;;) { const bucket_type &bucket = this->buckets[bucket_index]; if (bucket.first == NULL) return NULL; else if (bucket.first->equals (k)) return &bucket.second; else bucket_index = (bucket_index + step++) & mask; } } template <typename T, typename Alloc> inline bool insert_only_hash_map <T, Alloc>::key_type::equals ( const typename insert_only_hash_map <T, Alloc>::key_type *k) const { const char* x = reinterpret_cast <const char *> (k); const char* y = reinterpret_cast <const char *> (this); return (load8bytes (x) == load8bytes (y) && memcmp (x + 8, y + 8, this->n) == 0); } #endif /* _VTV_MAP_H */