/usr/lib/gcc-cross/powerpc64-linux-gnu/7/plugin/include/gimple-ssa.h is in gcc-7-plugin-dev-powerpc64-linux-gnu 7.3.0-16ubuntu3cross1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 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 */
|