1 /* Header file for routines that straddle the border between GIMPLE and
3 Copyright (C) 2009-2023 Free Software Foundation, Inc.
5 This file is part of GCC.
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)
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.
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/>. */
21 #ifndef GCC_GIMPLE_SSA_H
22 #define GCC_GIMPLE_SSA_H
24 #include "tree-ssa-operands.h"
26 /* This structure is used to map a gimple statement to a label,
27 or list of labels to represent transaction restart. */
29 struct GTY((for_user
)) tm_restart_node
{
34 /* Hasher for tm_restart_node. */
36 struct tm_restart_hasher
: ggc_ptr_hash
<tm_restart_node
>
38 static hashval_t
hash (tm_restart_node
*n
) { return htab_hash_pointer (n
); }
41 equal (tm_restart_node
*a
, tm_restart_node
*b
)
47 extern void gt_ggc_mx (gimple
*&);
48 extern void gt_pch_nx (gimple
*&);
50 struct ssa_name_hasher
: ggc_ptr_hash
<tree_node
>
52 /* Hash a tree in a uid_decl_map. */
57 return item
->ssa_name
.var
->decl_minimal
.uid
;
60 /* Return true if the DECL_UID in both trees are equal. */
63 equal (tree a
, tree b
)
65 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
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
;
76 /* Artificial variable used for the virtual operand FUD chain. */
79 /* The PTA solution for the ESCAPED artificial variable. */
80 struct pt_solution escaped
;
82 /* A map of decls to artificial ssa-names that point to the partition
84 hash_map
<tree
, tree
> * GTY((skip(""))) decls_to_pointers
;
86 /* Free list of SSA_NAMEs. */
87 vec
<tree
, va_gc
> *free_ssanames
;
89 /* Queue of SSA_NAMEs to be freed at the next opportunity. */
90 vec
<tree
, va_gc
> *free_ssanames_queue
;
92 /* Hashtable holding definition for symbol. If this field is not NULL, it
93 means that the first reference to this variable in the function is a
94 USE or a VUSE. In those cases, the SSA renamer creates an SSA name
95 for this variable with an empty defining statement. */
96 hash_table
<ssa_name_hasher
> *default_defs
;
98 /* True if there are any symbols that need to be renamed. */
99 unsigned int ssa_renaming_needed
: 1;
101 /* True if all virtual operands need to be renamed. */
102 unsigned int rename_vops
: 1;
104 /* True if the code is in ssa form. */
105 unsigned int in_ssa_p
: 1;
107 /* True if IPA points-to information was computed for this function. */
108 unsigned int ipa_pta
: 1;
110 struct ssa_operands ssa_operands
;
112 /* Map gimple stmt to tree label (or list of labels) for transaction
113 restart and abort. */
114 hash_table
<tm_restart_hasher
> *tm_restart
;
118 /* Return true when gimple SSA form was built.
119 gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
120 infrastructure is initialized. Check for presence of the datastructures
123 gimple_in_ssa_p (const struct function
*fun
)
125 return fun
&& fun
->gimple_df
&& fun
->gimple_df
->in_ssa_p
;
128 /* Artificial variable used for the virtual operand FUD chain. */
130 gimple_vop (const struct function
*fun
)
132 gcc_checking_assert (fun
&& fun
->gimple_df
);
133 return fun
->gimple_df
->vop
;
136 /* Return the set of VUSE operand for statement G. */
138 static inline use_operand_p
139 gimple_vuse_op (const gimple
*g
)
141 struct use_optype_d
*ops
;
142 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
143 dyn_cast
<const gimple_statement_with_memory_ops
*> (g
);
145 return NULL_USE_OPERAND_P
;
146 ops
= mem_ops_stmt
->use_ops
;
148 && USE_OP_PTR (ops
)->use
== &mem_ops_stmt
->vuse
)
149 return USE_OP_PTR (ops
);
150 return NULL_USE_OPERAND_P
;
153 /* Return the set of VDEF operand for statement G. */
155 static inline def_operand_p
156 gimple_vdef_op (gimple
*g
)
158 gimple_statement_with_memory_ops
*mem_ops_stmt
=
159 dyn_cast
<gimple_statement_with_memory_ops
*> (g
);
161 return NULL_DEF_OPERAND_P
;
162 if (mem_ops_stmt
->vdef
)
163 return &mem_ops_stmt
->vdef
;
164 return NULL_DEF_OPERAND_P
;
167 /* Mark statement S as modified, and update it. */
170 update_stmt (gimple
*s
)
172 if (gimple_has_ops (s
))
174 gimple_set_modified (s
, true);
175 update_stmt_operands (cfun
, s
);
179 /* Update statement S if it has been optimized. */
182 update_stmt_if_modified (gimple
*s
)
184 if (gimple_modified_p (s
))
185 update_stmt_operands (cfun
, s
);
188 /* Mark statement S as modified, and update it. */
191 update_stmt_fn (struct function
*fn
, gimple
*s
)
193 if (gimple_has_ops (s
))
195 gimple_set_modified (s
, true);
196 update_stmt_operands (fn
, s
);
201 #endif /* GCC_GIMPLE_SSA_H */