Line data Source code
1 : /* Header file for routines that straddle the border between GIMPLE and
2 : SSA in gimple.
3 : Copyright (C) 2009-2026 Free Software Foundation, Inc.
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation; either version 3, or (at your option)
10 : any later version.
11 :
12 : GCC is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 : #ifndef GCC_GIMPLE_SSA_H
22 : #define GCC_GIMPLE_SSA_H
23 :
24 : #include "tree-ssa-operands.h"
25 :
26 : /* This structure is used to map a gimple statement to a label,
27 : or list of labels to represent transaction restart. */
28 :
29 : struct GTY((for_user)) tm_restart_node {
30 : gimple *stmt;
31 : tree label_or_list;
32 : };
33 :
34 : /* Hasher for tm_restart_node. */
35 :
36 : struct tm_restart_hasher : ggc_ptr_hash<tm_restart_node>
37 : {
38 8540 : static hashval_t hash (tm_restart_node *n) { return htab_hash_pointer (n); }
39 :
40 : static bool
41 : equal (tm_restart_node *a, tm_restart_node *b)
42 : {
43 : return a == b;
44 : }
45 : };
46 :
47 : extern void gt_ggc_mx (gimple *&);
48 : extern void gt_pch_nx (gimple *&);
49 :
50 : struct ssa_name_hasher : ggc_ptr_hash<tree_node>
51 : {
52 : /* Hash a tree in a uid_decl_map. */
53 :
54 : static hashval_t
55 529092349 : hash (tree item)
56 : {
57 529092349 : return item->ssa_name.var->decl_minimal.uid;
58 : }
59 :
60 : /* Return true if the DECL_UID in both trees are equal. */
61 :
62 : static bool
63 891716800 : equal (tree a, tree b)
64 : {
65 891716800 : return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
66 : }
67 : };
68 :
69 : /* Gimple dataflow datastructure. All publicly available fields shall have
70 : gimple_ accessor defined, all publicly modifiable fields should have
71 : gimple_set accessor. */
72 : struct GTY(()) gimple_df {
73 : /* Array of all SSA_NAMEs used in the function. */
74 : vec<tree, va_gc> *ssa_names;
75 :
76 : /* Artificial variable used for the virtual operand FUD chain. */
77 : tree vop;
78 :
79 : /* The PTA solution for the ESCAPED and ESCAPED_RETURN artificial
80 : variables. */
81 : struct pt_solution escaped;
82 : struct pt_solution escaped_return;
83 :
84 : /* A map of decls to artificial ssa-names that point to the partition
85 : of the decl. */
86 : hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers;
87 :
88 : /* Free list of SSA_NAMEs. */
89 : vec<tree, va_gc> *free_ssanames;
90 :
91 : /* Queue of SSA_NAMEs to be freed at the next opportunity. */
92 : vec<tree, va_gc> *free_ssanames_queue;
93 :
94 : /* Hashtable holding definition for symbol. If this field is not NULL, it
95 : means that the first reference to this variable in the function is a
96 : USE or a VUSE. In those cases, the SSA renamer creates an SSA name
97 : for this variable with an empty defining statement. */
98 : hash_table<ssa_name_hasher> *default_defs;
99 :
100 : /* True if there are any symbols that need to be renamed. */
101 : unsigned int ssa_renaming_needed : 1;
102 :
103 : /* True if all virtual operands need to be renamed. */
104 : unsigned int rename_vops : 1;
105 :
106 : /* True if the code is in ssa form. */
107 : unsigned int in_ssa_p : 1;
108 :
109 : /* True if IPA points-to information was computed for this function. */
110 : unsigned int ipa_pta : 1;
111 :
112 : struct ssa_operands ssa_operands;
113 :
114 : /* Map gimple stmt to tree label (or list of labels) for transaction
115 : restart and abort. */
116 : hash_table<tm_restart_hasher> *tm_restart;
117 : };
118 :
119 :
120 : /* Return true when gimple SSA form was built.
121 : gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
122 : infrastructure is initialized. Check for presence of the datastructures
123 : at first place. */
124 : inline bool
125 207997155 : gimple_in_ssa_p (const struct function *fun)
126 : {
127 206668666 : return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
128 : }
129 :
130 : /* Artificial variable used for the virtual operand FUD chain. */
131 : inline tree
132 10806247285 : gimple_vop (const struct function *fun)
133 : {
134 10806247285 : gcc_checking_assert (fun && fun->gimple_df);
135 10806247285 : return fun->gimple_df->vop;
136 : }
137 :
138 : /* Return the set of VUSE operand for statement G. */
139 :
140 : inline use_operand_p
141 3018107409 : gimple_vuse_op (const gimple *g)
142 : {
143 3018107409 : struct use_optype_d *ops;
144 3018107409 : const gimple_statement_with_memory_ops *mem_ops_stmt =
145 6036214818 : dyn_cast <const gimple_statement_with_memory_ops *> (g);
146 3018107409 : if (!mem_ops_stmt)
147 : return NULL_USE_OPERAND_P;
148 3018107409 : ops = mem_ops_stmt->use_ops;
149 3018107409 : if (ops
150 3018107409 : && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse)
151 3018107409 : return USE_OP_PTR (ops);
152 : return NULL_USE_OPERAND_P;
153 : }
154 :
155 : /* Return the set of VDEF operand for statement G. */
156 :
157 : inline def_operand_p
158 : gimple_vdef_op (gimple *g)
159 : {
160 : gimple_statement_with_memory_ops *mem_ops_stmt =
161 : dyn_cast <gimple_statement_with_memory_ops *> (g);
162 : if (!mem_ops_stmt)
163 : return NULL_DEF_OPERAND_P;
164 : if (mem_ops_stmt->vdef)
165 : return &mem_ops_stmt->vdef;
166 : return NULL_DEF_OPERAND_P;
167 : }
168 :
169 : /* Mark statement S as modified, and update it. */
170 :
171 : inline void
172 205924599 : update_stmt (gimple *s)
173 : {
174 205924599 : if (gimple_has_ops (s))
175 : {
176 204414559 : gimple_set_modified (s, true);
177 204414559 : update_stmt_operands (cfun, s);
178 : }
179 205924599 : }
180 :
181 : /* Update statement S if it has been optimized. */
182 :
183 : inline void
184 1505328665 : update_stmt_if_modified (gimple *s)
185 : {
186 2982816839 : if (gimple_modified_p (s))
187 177583059 : update_stmt_operands (cfun, s);
188 1505328665 : }
189 :
190 : /* Mark statement S as modified, and update it. */
191 :
192 : inline void
193 667823 : update_stmt_fn (struct function *fn, gimple *s)
194 : {
195 667823 : if (gimple_has_ops (s))
196 : {
197 667823 : gimple_set_modified (s, true);
198 667823 : update_stmt_operands (fn, s);
199 : }
200 667823 : }
201 :
202 :
203 : #endif /* GCC_GIMPLE_SSA_H */
|
