Mercurial > hg > CbC > CbC_gcc
diff gcc/gimple-ssa.h @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gcc/gimple-ssa.h Fri Oct 27 22:46:09 2017 +0900 @@ -0,0 +1,201 @@ +/* Header file for routines that straddle the border between GIMPLE and + SSA in gimple. + Copyright (C) 2009-2017 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 GCC_GIMPLE_SSA_H +#define GCC_GIMPLE_SSA_H + +#include "tree-ssa-operands.h" + +/* This structure is used to map a gimple statement to a label, + or list of labels to represent transaction restart. */ + +struct GTY((for_user)) tm_restart_node { + gimple *stmt; + tree label_or_list; +}; + +/* Hasher for tm_restart_node. */ + +struct tm_restart_hasher : ggc_ptr_hash<tm_restart_node> +{ + static hashval_t hash (tm_restart_node *n) { return htab_hash_pointer (n); } + + static bool + equal (tm_restart_node *a, tm_restart_node *b) + { + return a == b; + } +}; + +extern void gt_ggc_mx (gimple *&); +extern void gt_pch_nx (gimple *&); + +struct ssa_name_hasher : ggc_ptr_hash<tree_node> +{ + /* Hash a tree in a uid_decl_map. */ + + static hashval_t + hash (tree item) + { + return item->ssa_name.var->decl_minimal.uid; + } + + /* Return true if the DECL_UID in both trees are equal. */ + + static bool + equal (tree a, tree b) +{ + return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid); +} +}; + +/* Gimple dataflow datastructure. All publicly available fields shall have + gimple_ accessor defined, all publicly modifiable fields should have + gimple_set accessor. */ +struct GTY(()) gimple_df { + /* Array of all SSA_NAMEs used in the function. */ + vec<tree, va_gc> *ssa_names; + + /* Artificial variable used for the virtual operand FUD chain. */ + tree vop; + + /* The PTA solution for the ESCAPED artificial variable. */ + struct pt_solution escaped; + + /* A map of decls to artificial ssa-names that point to the partition + of the decl. */ + hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers; + + /* Free list of SSA_NAMEs. */ + vec<tree, va_gc> *free_ssanames; + + /* Queue of SSA_NAMEs to be freed at the next opportunity. */ + vec<tree, va_gc> *free_ssanames_queue; + + /* Hashtable holding definition for symbol. If this field is not NULL, it + means that the first reference to this variable in the function is a + USE or a VUSE. In those cases, the SSA renamer creates an SSA name + for this variable with an empty defining statement. */ + hash_table<ssa_name_hasher> *default_defs; + + /* True if there are any symbols that need to be renamed. */ + unsigned int ssa_renaming_needed : 1; + + /* True if all virtual operands need to be renamed. */ + unsigned int rename_vops : 1; + + /* True if the code is in ssa form. */ + unsigned int in_ssa_p : 1; + + /* True if IPA points-to information was computed for this function. */ + unsigned int ipa_pta : 1; + + struct ssa_operands ssa_operands; + + /* Map gimple stmt to tree label (or list of labels) for transaction + restart and abort. */ + hash_table<tm_restart_hasher> *tm_restart; +}; + + +/* Return true when gimple SSA form was built. + gimple_in_ssa_p is queried by gimplifier in various early stages before SSA + infrastructure is initialized. Check for presence of the datastructures + at first place. */ +static inline bool +gimple_in_ssa_p (const struct function *fun) +{ + return fun && fun->gimple_df && fun->gimple_df->in_ssa_p; +} + +/* Artificial variable used for the virtual operand FUD chain. */ +static inline tree +gimple_vop (const struct function *fun) +{ + gcc_checking_assert (fun && fun->gimple_df); + return fun->gimple_df->vop; +} + +/* Return the set of VUSE operand for statement G. */ + +static inline use_operand_p +gimple_vuse_op (const gimple *g) +{ + struct use_optype_d *ops; + const gimple_statement_with_memory_ops *mem_ops_stmt = + dyn_cast <const gimple_statement_with_memory_ops *> (g); + if (!mem_ops_stmt) + return NULL_USE_OPERAND_P; + ops = mem_ops_stmt->use_ops; + if (ops + && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse) + return USE_OP_PTR (ops); + return NULL_USE_OPERAND_P; +} + +/* Return the set of VDEF operand for statement G. */ + +static inline def_operand_p +gimple_vdef_op (gimple *g) +{ + gimple_statement_with_memory_ops *mem_ops_stmt = + dyn_cast <gimple_statement_with_memory_ops *> (g); + if (!mem_ops_stmt) + return NULL_DEF_OPERAND_P; + if (mem_ops_stmt->vdef) + return &mem_ops_stmt->vdef; + return NULL_DEF_OPERAND_P; +} + +/* Mark statement S as modified, and update it. */ + +static inline void +update_stmt (gimple *s) +{ + if (gimple_has_ops (s)) + { + gimple_set_modified (s, true); + update_stmt_operands (cfun, s); + } +} + +/* Update statement S if it has been optimized. */ + +static inline void +update_stmt_if_modified (gimple *s) +{ + if (gimple_modified_p (s)) + update_stmt_operands (cfun, s); +} + +/* Mark statement S as modified, and update it. */ + +static inline void +update_stmt_fn (struct function *fn, gimple *s) +{ + if (gimple_has_ops (s)) + { + gimple_set_modified (s, true); + update_stmt_operands (fn, s); + } +} + + +#endif /* GCC_GIMPLE_SSA_H */