OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Convert lto streamer out hashing to inchash 

No substantial changes, although the hash values will be slightly
different.

v2: add_flag moved to inchash. Some minor changes.

gcc/:

2014-07-25  Andi Kleen  <ak@linux.intel.com>

	* lto-streamer-out.c (hash_tree): Convert to inchash.

From-SVN: r213057
This commit is contained in:
Andi Kleen 2014-07-25 13:39:49 +00:00 committed by Andi Kleen
parent 56fdfd3e85
commit e8326772b3
2 changed files with 134 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gcc/ChangeLog
View File

@ -1,3 +1,7 @@
2014-07-25 Andi Kleen <ak@linux.intel.com>
* lto-streamer-out.c (hash_tree): Convert to inchash.
2014-07-25 Andi Kleen <ak@linux.intel.com> 2014-07-25 Andi Kleen <ak@linux.intel.com>
* tree.c (build_type_attribute_qual_variant): Use inchash. * tree.c (build_type_attribute_qual_variant): Use inchash.

251
gcc/lto-streamer-out.c
View File

@ -695,207 +695,213 @@ DFS_write_tree_body (struct output_block *ob,
static hashval_t static hashval_t
hash_tree (struct streamer_tree_cache_d *cache, tree t) hash_tree (struct streamer_tree_cache_d *cache, tree t)
{ {
inchash hstate;
#define visit(SIBLING) \ #define visit(SIBLING) \
do { \ do { \
unsigned ix; \ unsigned ix; \
if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \ if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
v = iterative_hash_hashval_t (streamer_tree_cache_get_hash (cache, ix), v); \ hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
} while (0) } while (0)
/* Hash TS_BASE. */ /* Hash TS_BASE. */
enum tree_code code = TREE_CODE (t); enum tree_code code = TREE_CODE (t);
hashval_t v = iterative_hash_host_wide_int (code, 0); hstate.add_int (code);
if (!TYPE_P (t)) if (!TYPE_P (t))
{ {
v = iterative_hash_host_wide_int (TREE_SIDE_EFFECTS (t) hstate.add_flag (TREE_SIDE_EFFECTS (t));
| (TREE_CONSTANT (t) << 1) hstate.add_flag (TREE_CONSTANT (t));
| (TREE_READONLY (t) << 2) hstate.add_flag (TREE_READONLY (t));
| (TREE_PUBLIC (t) << 3), v); hstate.add_flag (TREE_PUBLIC (t));
} }
v = iterative_hash_host_wide_int (TREE_ADDRESSABLE (t) hstate.add_flag (TREE_ADDRESSABLE (t));
| (TREE_THIS_VOLATILE (t) << 1), v); hstate.add_flag (TREE_THIS_VOLATILE (t));
if (DECL_P (t)) if (DECL_P (t))
v = iterative_hash_host_wide_int (DECL_UNSIGNED (t), v); hstate.add_flag (DECL_UNSIGNED (t));
else if (TYPE_P (t)) else if (TYPE_P (t))
v = iterative_hash_host_wide_int (TYPE_UNSIGNED (t), v); hstate.add_flag (TYPE_UNSIGNED (t));
if (TYPE_P (t)) if (TYPE_P (t))
v = iterative_hash_host_wide_int (TYPE_ARTIFICIAL (t), v); hstate.add_flag (TYPE_ARTIFICIAL (t));
else else
v = iterative_hash_host_wide_int (TREE_NO_WARNING (t), v); hstate.add_flag (TREE_NO_WARNING (t));
v = iterative_hash_host_wide_int (TREE_NOTHROW (t) hstate.add_flag (TREE_NOTHROW (t));
| (TREE_STATIC (t) << 1) hstate.add_flag (TREE_STATIC (t));
| (TREE_PROTECTED (t) << 2) hstate.add_flag (TREE_PROTECTED (t));
| (TREE_DEPRECATED (t) << 3), v); hstate.add_flag (TREE_DEPRECATED (t));
if (code != TREE_BINFO) if (code != TREE_BINFO)
v = iterative_hash_host_wide_int (TREE_PRIVATE (t), v); hstate.add_flag (TREE_PRIVATE (t));
if (TYPE_P (t)) if (TYPE_P (t))
v = iterative_hash_host_wide_int (TYPE_SATURATING (t) {
| (TYPE_ADDR_SPACE (t) << 1), v); hstate.add_flag (TYPE_SATURATING (t));
hstate.add_flag (TYPE_ADDR_SPACE (t));
}
else if (code == SSA_NAME) else if (code == SSA_NAME)
v = iterative_hash_host_wide_int (SSA_NAME_IS_DEFAULT_DEF (t), v); hstate.add_flag (SSA_NAME_IS_DEFAULT_DEF (t));
hstate.commit_flag ();
if (CODE_CONTAINS_STRUCT (code, TS_INT_CST)) if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
{ {
int i; int i;
v = iterative_hash_host_wide_int (TREE_INT_CST_NUNITS (t), v); hstate.add_wide_int (TREE_INT_CST_NUNITS (t));
v = iterative_hash_host_wide_int (TREE_INT_CST_EXT_NUNITS (t), v); hstate.add_wide_int (TREE_INT_CST_EXT_NUNITS (t));
for (i = 0; i < TREE_INT_CST_NUNITS (t); i++) for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
v = iterative_hash_host_wide_int (TREE_INT_CST_ELT (t, i), v); hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
} }
if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST)) if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
{ {
REAL_VALUE_TYPE r = TREE_REAL_CST (t); REAL_VALUE_TYPE r = TREE_REAL_CST (t);
v = iterative_hash_host_wide_int (r.cl, v); hstate.add_flag (r.cl);
v = iterative_hash_host_wide_int (r.decimal hstate.add_flag (r.sign);
| (r.sign << 1) hstate.add_flag (r.signalling);
| (r.signalling << 2) hstate.add_flag (r.canonical);
| (r.canonical << 3), v); hstate.commit_flag ();
v = iterative_hash_host_wide_int (r.uexp, v); hstate.add_int (r.uexp);
for (unsigned i = 0; i < SIGSZ; ++i) hstate.add (r.sig, sizeof (r.sig));
v = iterative_hash_host_wide_int (r.sig[i], v);
} }
if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
{ {
FIXED_VALUE_TYPE f = TREE_FIXED_CST (t); FIXED_VALUE_TYPE f = TREE_FIXED_CST (t);
v = iterative_hash_host_wide_int (f.mode, v); hstate.add_int (f.mode);
v = iterative_hash_host_wide_int (f.data.low, v); hstate.add_int (f.data.low);
v = iterative_hash_host_wide_int (f.data.high, v); hstate.add_int (f.data.high);
} }
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{ {
v = iterative_hash_host_wide_int (DECL_MODE (t), v); hstate.add_wide_int (DECL_MODE (t));
v = iterative_hash_host_wide_int (DECL_NONLOCAL (t) hstate.add_flag (DECL_NONLOCAL (t));
| (DECL_VIRTUAL_P (t) << 1) hstate.add_flag (DECL_VIRTUAL_P (t));
| (DECL_IGNORED_P (t) << 2) hstate.add_flag (DECL_IGNORED_P (t));
| (DECL_ABSTRACT (t) << 3) hstate.add_flag (DECL_ABSTRACT (t));
| (DECL_ARTIFICIAL (t) << 4) hstate.add_flag (DECL_ARTIFICIAL (t));
| (DECL_USER_ALIGN (t) << 5) hstate.add_flag (DECL_USER_ALIGN (t));
| (DECL_PRESERVE_P (t) << 6) hstate.add_flag (DECL_PRESERVE_P (t));
| (DECL_EXTERNAL (t) << 7) hstate.add_flag (DECL_EXTERNAL (t));
| (DECL_GIMPLE_REG_P (t) << 8), v); hstate.add_flag (DECL_GIMPLE_REG_P (t));
v = iterative_hash_host_wide_int (DECL_ALIGN (t), v); hstate.commit_flag ();
hstate.add_int (DECL_ALIGN (t));
if (code == LABEL_DECL) if (code == LABEL_DECL)
{ {
v = iterative_hash_host_wide_int (EH_LANDING_PAD_NR (t), v); hstate.add_int (EH_LANDING_PAD_NR (t));
v = iterative_hash_host_wide_int (LABEL_DECL_UID (t), v); hstate.add_int (LABEL_DECL_UID (t));
} }
else if (code == FIELD_DECL) else if (code == FIELD_DECL)
{ {
v = iterative_hash_host_wide_int (DECL_PACKED (t) hstate.add_flag (DECL_PACKED (t));
| (DECL_NONADDRESSABLE_P (t) << 1), hstate.add_flag (DECL_NONADDRESSABLE_P (t));
v); hstate.add_int (DECL_OFFSET_ALIGN (t));
v = iterative_hash_host_wide_int (DECL_OFFSET_ALIGN (t), v);
} }
else if (code == VAR_DECL) else if (code == VAR_DECL)
{ {
v = iterative_hash_host_wide_int (DECL_HAS_DEBUG_EXPR_P (t) hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t));
| (DECL_NONLOCAL_FRAME (t) << 1), hstate.add_flag (DECL_NONLOCAL_FRAME (t));
v);
} }
if (code == RESULT_DECL if (code == RESULT_DECL
|| code == PARM_DECL || code == PARM_DECL
|| code == VAR_DECL) || code == VAR_DECL)
{ {
v = iterative_hash_host_wide_int (DECL_BY_REFERENCE (t), v); hstate.add_flag (DECL_BY_REFERENCE (t));
if (code == VAR_DECL if (code == VAR_DECL
|| code == PARM_DECL) || code == PARM_DECL)
v = iterative_hash_host_wide_int (DECL_HAS_VALUE_EXPR_P (t), v); hstate.add_flag (DECL_HAS_VALUE_EXPR_P (t));
} }
hstate.commit_flag ();
} }
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
v = iterative_hash_host_wide_int (DECL_REGISTER (t), v); hstate.add_int (DECL_REGISTER (t));
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{ {
v = iterative_hash_host_wide_int ((DECL_COMMON (t)) hstate.add_flag (DECL_COMMON (t));
| (DECL_DLLIMPORT_P (t) << 1) hstate.add_flag (DECL_DLLIMPORT_P (t));
| (DECL_WEAK (t) << 2) hstate.add_flag (DECL_WEAK (t));
| (DECL_SEEN_IN_BIND_EXPR_P (t) << 3) hstate.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t));
| (DECL_COMDAT (t) << 4) hstate.add_flag (DECL_COMDAT (t));
| (DECL_VISIBILITY_SPECIFIED (t) << 6), hstate.add_flag (DECL_VISIBILITY_SPECIFIED (t));
v); hstate.add_int (DECL_VISIBILITY (t));
v = iterative_hash_host_wide_int (DECL_VISIBILITY (t), v);
if (code == VAR_DECL) if (code == VAR_DECL)
{ {
/* DECL_IN_TEXT_SECTION is set during final asm output only. */ /* DECL_IN_TEXT_SECTION is set during final asm output only. */
v = iterative_hash_host_wide_int (DECL_HARD_REGISTER (t) hstate.add_flag (DECL_HARD_REGISTER (t));
| (DECL_IN_CONSTANT_POOL (t) << 1), hstate.add_flag (DECL_IN_CONSTANT_POOL (t));
v);
} }
if (TREE_CODE (t) == FUNCTION_DECL) if (TREE_CODE (t) == FUNCTION_DECL)
v = iterative_hash_host_wide_int (DECL_FINAL_P (t) {
| (DECL_CXX_CONSTRUCTOR_P (t) << 1) hstate.add_flag (DECL_FINAL_P (t));
| (DECL_CXX_DESTRUCTOR_P (t) << 2), hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (t));
v); hstate.add_flag (DECL_CXX_DESTRUCTOR_P (t));
}
hstate.commit_flag ();
} }
if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
{ {
v = iterative_hash_host_wide_int (DECL_BUILT_IN_CLASS (t), v); hstate.add_int (DECL_BUILT_IN_CLASS (t));
v = iterative_hash_host_wide_int (DECL_STATIC_CONSTRUCTOR (t) hstate.add_flag (DECL_STATIC_CONSTRUCTOR (t));
| (DECL_STATIC_DESTRUCTOR (t) << 1) hstate.add_flag (DECL_STATIC_DESTRUCTOR (t));
| (DECL_UNINLINABLE (t) << 2) hstate.add_flag (DECL_UNINLINABLE (t));
| (DECL_POSSIBLY_INLINED (t) << 3) hstate.add_flag (DECL_POSSIBLY_INLINED (t));
| (DECL_IS_NOVOPS (t) << 4) hstate.add_flag (DECL_IS_NOVOPS (t));
| (DECL_IS_RETURNS_TWICE (t) << 5) hstate.add_flag (DECL_IS_RETURNS_TWICE (t));
| (DECL_IS_MALLOC (t) << 6) hstate.add_flag (DECL_IS_MALLOC (t));
| (DECL_IS_OPERATOR_NEW (t) << 7) hstate.add_flag (DECL_IS_OPERATOR_NEW (t));
| (DECL_DECLARED_INLINE_P (t) << 8) hstate.add_flag (DECL_DECLARED_INLINE_P (t));
| (DECL_STATIC_CHAIN (t) << 9) hstate.add_flag (DECL_STATIC_CHAIN (t));
| (DECL_NO_INLINE_WARNING_P (t) << 10) hstate.add_flag (DECL_NO_INLINE_WARNING_P (t));
| (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t) << 11) hstate.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t));
| (DECL_NO_LIMIT_STACK (t) << 12) hstate.add_flag (DECL_NO_LIMIT_STACK (t));
| (DECL_DISREGARD_INLINE_LIMITS (t) << 13) hstate.add_flag (DECL_DISREGARD_INLINE_LIMITS (t));
| (DECL_PURE_P (t) << 14) hstate.add_flag (DECL_PURE_P (t));
| (DECL_LOOPING_CONST_OR_PURE_P (t) << 15), v); hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t));
hstate.commit_flag ();
if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN) if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
v = iterative_hash_host_wide_int (DECL_FUNCTION_CODE (t), v); hstate.add_int (DECL_FUNCTION_CODE (t));
} }
if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
{ {
v = iterative_hash_host_wide_int (TYPE_MODE (t), v); hstate.add_wide_int (TYPE_MODE (t));
v = iterative_hash_host_wide_int (TYPE_STRING_FLAG (t) hstate.add_flag (TYPE_STRING_FLAG (t));
| (TYPE_NO_FORCE_BLK (t) << 1) hstate.add_flag (TYPE_NO_FORCE_BLK (t));
| (TYPE_NEEDS_CONSTRUCTING (t) << 2) hstate.add_flag (TYPE_NEEDS_CONSTRUCTING (t));
| (TYPE_PACKED (t) << 3) hstate.add_flag (TYPE_PACKED (t));
| (TYPE_RESTRICT (t) << 4) hstate.add_flag (TYPE_RESTRICT (t));
| (TYPE_USER_ALIGN (t) << 5) hstate.add_flag (TYPE_USER_ALIGN (t));
| (TYPE_READONLY (t) << 6), v); hstate.add_flag (TYPE_READONLY (t));
if (RECORD_OR_UNION_TYPE_P (t)) if (RECORD_OR_UNION_TYPE_P (t))
{ {
v = iterative_hash_host_wide_int (TYPE_TRANSPARENT_AGGR (t) hstate.add_flag (TYPE_TRANSPARENT_AGGR (t));
| (TYPE_FINAL_P (t) << 1), v); hstate.add_flag (TYPE_FINAL_P (t));
} }
else if (code == ARRAY_TYPE) else if (code == ARRAY_TYPE)
v = iterative_hash_host_wide_int (TYPE_NONALIASED_COMPONENT (t), v); hstate.add_flag (TYPE_NONALIASED_COMPONENT (t));
v = iterative_hash_host_wide_int (TYPE_PRECISION (t), v); hstate.commit_flag ();
v = iterative_hash_host_wide_int (TYPE_ALIGN (t), v); hstate.add_int (TYPE_PRECISION (t));
v = iterative_hash_host_wide_int ((TYPE_ALIAS_SET (t) == 0 hstate.add_int (TYPE_ALIGN (t));
hstate.add_int ((TYPE_ALIAS_SET (t) == 0
|| (!in_lto_p || (!in_lto_p
&& get_alias_set (t) == 0)) && get_alias_set (t) == 0))
? 0 : -1, v); ? 0 : -1);
} }
if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
v = iterative_hash (TRANSLATION_UNIT_LANGUAGE (t), hstate.add (TRANSLATION_UNIT_LANGUAGE (t),
strlen (TRANSLATION_UNIT_LANGUAGE (t)), v); strlen (TRANSLATION_UNIT_LANGUAGE (t)));
if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)) if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
gcc_unreachable (); gcc_unreachable ();
if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION)) if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
v = iterative_hash (t, sizeof (struct cl_optimization), v); hstate.add (t, sizeof (struct cl_optimization));
if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER)) if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
v = iterative_hash_host_wide_int (IDENTIFIER_HASH_VALUE (t), v); hstate.merge_hash (IDENTIFIER_HASH_VALUE (t));
if (CODE_CONTAINS_STRUCT (code, TS_STRING)) if (CODE_CONTAINS_STRUCT (code, TS_STRING))
v = iterative_hash (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t), v); hstate.add (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
{ {
@ -913,7 +919,7 @@ hash_tree (struct streamer_tree_cache_d *cache, tree t)
x = streamer_tree_cache_get_hash (cache, ix); x = streamer_tree_cache_get_hash (cache, ix);
else else
x = hash_tree (cache, TREE_TYPE (t)); x = hash_tree (cache, TREE_TYPE (t));
v = iterative_hash_hashval_t (x, v); hstate.merge_hash (x);
} }
else if (code != IDENTIFIER_NODE) else if (code != IDENTIFIER_NODE)
visit (TREE_TYPE (t)); visit (TREE_TYPE (t));
@ -1035,7 +1041,7 @@ hash_tree (struct streamer_tree_cache_d *cache, tree t)
if (CODE_CONTAINS_STRUCT (code, TS_EXP)) if (CODE_CONTAINS_STRUCT (code, TS_EXP))
{ {
v = iterative_hash_host_wide_int (TREE_OPERAND_LENGTH (t), v); hstate.add_wide_int (TREE_OPERAND_LENGTH (t));
for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i) for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i)
visit (TREE_OPERAND (t, i)); visit (TREE_OPERAND (t, i));
} }
@ -1059,7 +1065,7 @@ hash_tree (struct streamer_tree_cache_d *cache, tree t)
{ {
unsigned i; unsigned i;
tree index, value; tree index, value;
v = iterative_hash_host_wide_int (CONSTRUCTOR_NELTS (t), v); hstate.add_wide_int (CONSTRUCTOR_NELTS (t));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value) FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value)
{ {
visit (index); visit (index);
@ -1070,37 +1076,40 @@ hash_tree (struct streamer_tree_cache_d *cache, tree t)
if (code == OMP_CLAUSE) if (code == OMP_CLAUSE)
{ {
int i; int i;
HOST_WIDE_INT val;
v = iterative_hash_host_wide_int (OMP_CLAUSE_CODE (t), v); hstate.add_wide_int (OMP_CLAUSE_CODE (t));
switch (OMP_CLAUSE_CODE (t)) switch (OMP_CLAUSE_CODE (t))
{ {
case OMP_CLAUSE_DEFAULT: case OMP_CLAUSE_DEFAULT:
v = iterative_hash_host_wide_int (OMP_CLAUSE_DEFAULT_KIND (t), v); val = OMP_CLAUSE_DEFAULT_KIND (t);
break; break;
case OMP_CLAUSE_SCHEDULE: case OMP_CLAUSE_SCHEDULE:
v = iterative_hash_host_wide_int (OMP_CLAUSE_SCHEDULE_KIND (t), v); val = OMP_CLAUSE_SCHEDULE_KIND (t);
break; break;
case OMP_CLAUSE_DEPEND: case OMP_CLAUSE_DEPEND:
v = iterative_hash_host_wide_int (OMP_CLAUSE_DEPEND_KIND (t), v); val = OMP_CLAUSE_DEPEND_KIND (t);
break; break;
case OMP_CLAUSE_MAP: case OMP_CLAUSE_MAP:
v = iterative_hash_host_wide_int (OMP_CLAUSE_MAP_KIND (t), v); val = OMP_CLAUSE_MAP_KIND (t);
break; break;
case OMP_CLAUSE_PROC_BIND: case OMP_CLAUSE_PROC_BIND:
v = iterative_hash_host_wide_int (OMP_CLAUSE_PROC_BIND_KIND (t), v); val = OMP_CLAUSE_PROC_BIND_KIND (t);
break; break;
case OMP_CLAUSE_REDUCTION: case OMP_CLAUSE_REDUCTION:
v = iterative_hash_host_wide_int (OMP_CLAUSE_REDUCTION_CODE (t), v); val = OMP_CLAUSE_REDUCTION_CODE (t);
break; break;
default: default:
val = 0;
break; break;
} }
hstate.add_wide_int (val);
for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
visit (OMP_CLAUSE_OPERAND (t, i)); visit (OMP_CLAUSE_OPERAND (t, i));
visit (OMP_CLAUSE_CHAIN (t)); visit (OMP_CLAUSE_CHAIN (t));
} }
return v; return hstate.end ();
#undef visit #undef visit
} }