Skip to content

R
riscv-gcc-1
Commit f11c3779 by Richard Sandiford Committed by Richard Sandiford
Options

hash-table.h: Include hash-traits.h. 

gcc/
	* hash-table.h: Include hash-traits.h.
	(typed_free_remove, typed_noop_remove, pointer_hash, ggc_hasher)
	(ggc_cache_hasher): Move to...
	* hash-traits.h: ...this new file.

From-SVN: r224953
parent fbf196a2
Showing with 168 additions and 138 deletions
gcc/ChangeLog
2015-06-25 Richard Sandiford <richard.sandiford@arm.com>
* hash-table.h: Include hash-traits.h.
(typed_free_remove, typed_noop_remove, pointer_hash, ggc_hasher)
(ggc_cache_hasher): Move to...
* hash-traits.h: ...this new file.
2015-06-25 Andrew MacLeod <amacleod@redhat.com>
* tree-core.h (struct tree_optimization_option): Make opts a pointer to
......
gcc/hash-table.h
......@@ -81,7 +81,7 @@ along with GCC; see the file COPYING3. If not see
We compose this into a few steps.
1. Decide on a removal policy for values stored in the table.
This header provides class templates for the two most common
hash-traits.h provides class templates for the two most common
policies.
* typed_free_remove implements the static 'remove' member function
......@@ -202,6 +202,7 @@ along with GCC; see the file COPYING3. If not see
#include "hashtab.h"
#include "inchash.h"
#include "mem-stats-traits.h"
#include "hash-traits.h"
#include "hash-map-traits.h"
template<typename, typename, typename> class hash_map;
......@@ -238,143 +239,6 @@ xcallocator <Type>::data_free (Type *memory)
}
/* Helpful type for removing with free. */
template <typename Type>
struct typed_free_remove
{
static inline void remove (Type *p);
};
/* Remove with free. */
template <typename Type>
inline void
typed_free_remove <Type>::remove (Type *p)
{
free (p);
}
/* Helpful type for a no-op remove. */
template <typename Type>
struct typed_noop_remove
{
static inline void remove (Type *p);
};
/* Remove doing nothing. */
template <typename Type>
inline void
typed_noop_remove <Type>::remove (Type *p ATTRIBUTE_UNUSED)
{
}
/* Pointer hash with a no-op remove method. */
template <typename Type>
struct pointer_hash : typed_noop_remove <Type>
{
typedef Type *value_type;
typedef Type *compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &existing,
const compare_type &candidate);
};
template <typename Type>
inline hashval_t
pointer_hash <Type>::hash (const value_type &candidate)
{
/* This is a really poor hash function, but it is what the current code uses,
so I am reusing it to avoid an additional axis in testing. */
return (hashval_t) ((intptr_t)candidate >> 3);
}
template <typename Type>
inline bool
pointer_hash <Type>::equal (const value_type &existing,
const compare_type &candidate)
{
return existing == candidate;
}
/* Hasher for entry in gc memory. */
template<typename T>
struct ggc_hasher
{
typedef T value_type;
typedef T compare_type;
static void remove (T) {}
static void
ggc_mx (T p)
{
extern void gt_ggc_mx (T &);
gt_ggc_mx (p);
}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
};
/* Hasher for cache entry in gc memory. */
template<typename T>
struct ggc_cache_hasher
{
typedef T value_type;
typedef T compare_type;
static void remove (T &) {}
/* Entries are weakly held because this is for caches. */
static void ggc_mx (T &) {}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
/* Clear out entries if they are about to be gc'd. */
static void
handle_cache_entry (T &e)
{
if (e != HTAB_EMPTY_ENTRY && e != HTAB_DELETED_ENTRY && !ggc_marked_p (e))
e = static_cast<T> (HTAB_DELETED_ENTRY);
}
};
/* Table of primes and their inversion information. */
struct prime_ent
......
gcc/hash-traits.h 0 → 100644
/* Traits for hashable types.
Copyright (C) 2014-2015 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.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#ifndef hash_traits_h
#define hash_traits_h
/* Helpful type for removing with free. */
template <typename Type>
struct typed_free_remove
{
static inline void remove (Type *p);
};
/* Remove with free. */
template <typename Type>
inline void
typed_free_remove <Type>::remove (Type *p)
{
free (p);
}
/* Helpful type for a no-op remove. */
template <typename Type>
struct typed_noop_remove
{
static inline void remove (Type *p);
};
/* Remove doing nothing. */
template <typename Type>
inline void
typed_noop_remove <Type>::remove (Type *p ATTRIBUTE_UNUSED)
{
}
/* Pointer hash with a no-op remove method. */
template <typename Type>
struct pointer_hash : typed_noop_remove <Type>
{
typedef Type *value_type;
typedef Type *compare_type;
static inline hashval_t hash (const value_type &);
static inline bool equal (const value_type &existing,
const compare_type &candidate);
};
template <typename Type>
inline hashval_t
pointer_hash <Type>::hash (const value_type &candidate)
{
/* This is a really poor hash function, but it is what the current code uses,
so I am reusing it to avoid an additional axis in testing. */
return (hashval_t) ((intptr_t)candidate >> 3);
}
template <typename Type>
inline bool
pointer_hash <Type>::equal (const value_type &existing,
const compare_type &candidate)
{
return existing == candidate;
}
/* Hasher for entry in gc memory. */
template<typename T>
struct ggc_hasher
{
typedef T value_type;
typedef T compare_type;
static void remove (T) {}
static void
ggc_mx (T p)
{
extern void gt_ggc_mx (T &);
gt_ggc_mx (p);
}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
};
/* Hasher for cache entry in gc memory. */
template<typename T>
struct ggc_cache_hasher
{
typedef T value_type;
typedef T compare_type;
static void remove (T &) {}
/* Entries are weakly held because this is for caches. */
static void ggc_mx (T &) {}
static void
pch_nx (T &p)
{
extern void gt_pch_nx (T &);
gt_pch_nx (p);
}
static void
pch_nx (T &p, gt_pointer_operator op, void *cookie)
{
op (&p, cookie);
}
/* Clear out entries if they are about to be gc'd. */
static void
handle_cache_entry (T &e)
{
if (e != HTAB_EMPTY_ENTRY && e != HTAB_DELETED_ENTRY && !ggc_marked_p (e))
e = static_cast<T> (HTAB_DELETED_ENTRY);
}
};
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment