From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/tree-ssa-sccvn.h | 212 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 gcc/tree-ssa-sccvn.h (limited to 'gcc/tree-ssa-sccvn.h') diff --git a/gcc/tree-ssa-sccvn.h b/gcc/tree-ssa-sccvn.h new file mode 100644 index 000000000..bf99702e4 --- /dev/null +++ b/gcc/tree-ssa-sccvn.h @@ -0,0 +1,212 @@ +/* Tree SCC value numbering + Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Contributed by Daniel Berlin + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, 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 + . */ + +#ifndef TREE_SSA_SCCVN_H +#define TREE_SSA_SCCVN_H + +/* In tree-ssa-sccvn.c */ +bool expressions_equal_p (tree, tree); + + +/* TOP of the VN lattice. */ +extern tree VN_TOP; + +/* N-ary operations in the hashtable consist of length operands, an + opcode, and a type. Result is the value number of the operation, + and hashcode is stored to avoid having to calculate it + repeatedly. */ + +typedef struct vn_nary_op_s +{ + /* Unique identify that all expressions with the same value have. */ + unsigned int value_id; + ENUM_BITFIELD(tree_code) opcode : 16; + unsigned length : 16; + hashval_t hashcode; + tree result; + tree type; + tree op[4]; +} *vn_nary_op_t; +typedef const struct vn_nary_op_s *const_vn_nary_op_t; + +/* Phi nodes in the hashtable consist of their non-VN_TOP phi + arguments, and the basic block the phi is in. Result is the value + number of the operation, and hashcode is stored to avoid having to + calculate it repeatedly. Phi nodes not in the same block are never + considered equivalent. */ + +typedef struct vn_phi_s +{ + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + hashval_t hashcode; + VEC (tree, heap) *phiargs; + basic_block block; + tree result; +} *vn_phi_t; +typedef const struct vn_phi_s *const_vn_phi_t; + +/* Reference operands only exist in reference operations structures. + They consist of an opcode, type, and some number of operands. For + a given opcode, some, all, or none of the operands may be used. + The operands are there to store the information that makes up the + portion of the addressing calculation that opcode performs. */ + +typedef struct vn_reference_op_struct +{ + enum tree_code opcode; + /* Constant offset this op adds or -1 if it is variable. */ + HOST_WIDE_INT off; + tree type; + tree op0; + tree op1; + tree op2; +} vn_reference_op_s; +typedef vn_reference_op_s *vn_reference_op_t; +typedef const vn_reference_op_s *const_vn_reference_op_t; + +DEF_VEC_O(vn_reference_op_s); +DEF_VEC_ALLOC_O(vn_reference_op_s, heap); + +/* A reference operation in the hashtable is representation as + the vuse, representing the memory state at the time of + the operation, and a collection of operands that make up the + addressing calculation. If two vn_reference_t's have the same set + of operands, they access the same memory location. We also store + the resulting value number, and the hashcode. */ + +typedef struct vn_reference_s +{ + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + hashval_t hashcode; + tree vuse; + alias_set_type set; + tree type; + VEC (vn_reference_op_s, heap) *operands; + tree result; +} *vn_reference_t; +typedef const struct vn_reference_s *const_vn_reference_t; + +typedef struct vn_constant_s +{ + unsigned int value_id; + hashval_t hashcode; + tree constant; +} *vn_constant_t; + +/* Hash the constant CONSTANT with distinguishing type incompatible + constants in the types_compatible_p sense. */ + +static inline hashval_t +vn_hash_constant_with_type (tree constant) +{ + tree type = TREE_TYPE (constant); + return (iterative_hash_expr (constant, 0) + + INTEGRAL_TYPE_P (type) + + (INTEGRAL_TYPE_P (type) + ? TYPE_PRECISION (type) + TYPE_UNSIGNED (type) : 0)); +} + +/* Compare the constants C1 and C2 with distinguishing type incompatible + constants in the types_compatible_p sense. */ + +static inline bool +vn_constant_eq_with_type (tree c1, tree c2) +{ + return (expressions_equal_p (c1, c2) + && types_compatible_p (TREE_TYPE (c1), TREE_TYPE (c2))); +} + +typedef struct vn_ssa_aux +{ + /* Value number. This may be an SSA name or a constant. */ + tree valnum; + /* Representative expression, if not a direct constant. */ + tree expr; + + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + + /* SCC information. */ + unsigned int dfsnum; + unsigned int low; + unsigned visited : 1; + unsigned on_sccstack : 1; + + /* Whether the representative expression contains constants. */ + unsigned has_constants : 1; + /* Whether the SSA_NAME has been value numbered already. This is + only saying whether visit_use has been called on it at least + once. It cannot be used to avoid visitation for SSA_NAME's + involved in non-singleton SCC's. */ + unsigned use_processed : 1; + + /* Whether the SSA_NAME has no defining statement and thus an + insertion of such with EXPR as definition is required before + a use can be created of it. */ + unsigned needs_insertion : 1; +} *vn_ssa_aux_t; + +typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind; + +/* Return the value numbering info for an SSA_NAME. */ +extern vn_ssa_aux_t VN_INFO (tree); +extern vn_ssa_aux_t VN_INFO_GET (tree); +tree vn_get_expr_for (tree); +bool run_scc_vn (vn_lookup_kind); +void free_scc_vn (void); +tree vn_nary_op_lookup (tree, vn_nary_op_t *); +tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *); +tree vn_nary_op_lookup_pieces (unsigned int, enum tree_code, + tree, tree, tree, tree, tree, + vn_nary_op_t *); +vn_nary_op_t vn_nary_op_insert (tree, tree); +vn_nary_op_t vn_nary_op_insert_stmt (gimple, tree); +vn_nary_op_t vn_nary_op_insert_pieces (unsigned int, enum tree_code, + tree, tree, tree, tree, + tree, tree, unsigned int); +void vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **, + unsigned int *); +void copy_reference_ops_from_ref (tree, VEC(vn_reference_op_s, heap) **); +void copy_reference_ops_from_call (gimple, VEC(vn_reference_op_s, heap) **); +bool ao_ref_init_from_vn_reference (ao_ref *, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *); +tree vn_reference_lookup_pieces (tree, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *, + vn_reference_t *, vn_lookup_kind); +tree vn_reference_lookup (tree, tree, vn_lookup_kind, vn_reference_t *); +vn_reference_t vn_reference_insert (tree, tree, tree); +vn_reference_t vn_reference_insert_pieces (tree, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *, + tree, unsigned int); + +hashval_t vn_nary_op_compute_hash (const vn_nary_op_t); +int vn_nary_op_eq (const void *, const void *); +bool vn_nary_may_trap (vn_nary_op_t); +hashval_t vn_reference_compute_hash (const vn_reference_t); +int vn_reference_eq (const void *, const void *); +unsigned int get_max_value_id (void); +unsigned int get_next_value_id (void); +unsigned int get_constant_value_id (tree); +unsigned int get_or_alloc_constant_value_id (tree); +bool value_id_constant_p (unsigned int); +tree fully_constant_vn_reference_p (vn_reference_t); +#endif /* TREE_SSA_SCCVN_H */ -- cgit v1.2.3