1 /* Value Numbering routines for tree expressions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Daniel Berlin <dan@dberlin.org>, Steven Bosscher
4 <stevenb@suse.de> and Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "coretypes.h"
29 #include "tree-flow.h"
31 #include "langhooks.h"
32 #include "tree-pass.h"
33 #include "tree-dump.h"
34 #include "diagnostic.h"
35 #include "tree-ssa-sccvn.h"
37 /* Most of this is PRE specific. The real grunt work is done in
38 tree-ssa-sccvn.c. This is where the lookup and insertion
39 functions, etc, can be found */
41 /* Create and return a new value handle node of type TYPE. */
44 make_value_handle (tree type)
46 static unsigned int id = 0;
49 vh = build0 (VALUE_HANDLE, type);
50 VALUE_HANDLE_ID (vh) = id++;
56 /* Compare two expressions E1 and E2 and return true if they are
60 expressions_equal_p (tree e1, tree e2)
70 if (TREE_CODE (e1) == TREE_LIST && TREE_CODE (e2) == TREE_LIST)
74 for (lop1 = e1, lop2 = e2;
76 lop1 = TREE_CHAIN (lop1), lop2 = TREE_CHAIN (lop2))
80 if (!expressions_equal_p (TREE_VALUE (lop1), TREE_VALUE (lop2)))
86 else if (TREE_CODE (e1) == TREE_CODE (e2)
88 || types_compatible_p (te1, te2))
89 && operand_equal_p (e1, e2, OEP_PURE_SAME))
95 /* Set the value handle for expression E to value V. */
98 set_value_handle (tree e, tree v)
100 if (TREE_CODE (e) == SSA_NAME)
101 SSA_NAME_VALUE (e) = v;
102 else if (EXPR_P (e) || DECL_P (e) || TREE_CODE (e) == TREE_LIST
104 || TREE_CODE (e) == CONSTRUCTOR)
105 get_tree_common_ann (e)->value_handle = v;
107 /* Do nothing. Constants are their own value handles. */
108 gcc_assert (is_gimple_min_invariant (e));
111 /* A comparison function for use in qsort to compare vuses. Simply
112 subtracts version numbers. */
115 vuses_compare (const void *pa, const void *pb)
117 const tree vusea = *((const tree *)pa);
118 const tree vuseb = *((const tree *)pb);
119 int sn = SSA_NAME_VERSION (vusea) - SSA_NAME_VERSION (vuseb);
124 /* Print out the "Created value <x> for <Y>" statement to the
126 This is factored because both versions of lookup use it, and it
127 obscures the real work going on in those functions. */
130 print_creation_to_file (tree v, tree expr, VEC (tree, gc) *vuses)
132 fprintf (dump_file, "Created value ");
133 print_generic_expr (dump_file, v, dump_flags);
134 fprintf (dump_file, " for ");
135 print_generic_expr (dump_file, expr, dump_flags);
137 if (vuses && VEC_length (tree, vuses) != 0)
142 fprintf (dump_file, " vuses: (");
143 for (i = 0; VEC_iterate (tree, vuses, i, vuse); i++)
145 print_generic_expr (dump_file, vuse, dump_flags);
146 if (VEC_length (tree, vuses) - 1 != i)
147 fprintf (dump_file, ",");
149 fprintf (dump_file, ")");
151 fprintf (dump_file, "\n");
155 /* Sort the VUSE array so that we can do equality comparisons
156 quicker on two vuse vecs. */
159 sort_vuses (VEC (tree,gc) *vuses)
161 if (VEC_length (tree, vuses) > 1)
162 qsort (VEC_address (tree, vuses),
163 VEC_length (tree, vuses),
168 /* Sort the VUSE array so that we can do equality comparisons
169 quicker on two vuse vecs. */
172 sort_vuses_heap (VEC (tree,heap) *vuses)
174 if (VEC_length (tree, vuses) > 1)
175 qsort (VEC_address (tree, vuses),
176 VEC_length (tree, vuses),
180 /* Insert EXPR into VALUE_TABLE with value VAL, and add expression
181 EXPR to the value set for value VAL. */
184 vn_add (tree expr, tree val)
186 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
190 vn_binary_op_insert (expr, val);
193 vn_unary_op_insert (expr, val);
195 /* In the case of array-refs of constants, for example, we can
196 end up with no vuses. */
198 vn_reference_insert (expr, val, NULL);
200 /* The *only* time CALL_EXPR should appear here is
201 when it has no vuses. */
203 case tcc_exceptional:
205 case tcc_declaration:
206 if (TREE_CODE (expr) == CALL_EXPR || DECL_P (expr))
208 vn_reference_insert (expr, val, NULL);
211 else if (TREE_CODE (expr) == SSA_NAME)
213 SSA_NAME_VALUE (expr) = val;
216 else if (TREE_CODE (expr) == ADDR_EXPR)
218 vn_unary_op_insert (expr, val);
225 set_value_handle (expr, val);
226 if (TREE_CODE (val) == VALUE_HANDLE)
227 add_to_value (val, expr);
230 /* Insert EXPR into the value numbering tables. with value VAL, and
231 add expression EXPR to the value set for value VAL. VUSES
232 represents the virtual use operands associated with EXPR. It is
233 used when computing a hash value for EXPR. */
236 vn_add_with_vuses (tree expr, tree val, VEC (tree, gc) *vuses)
243 vn_reference_insert (expr, val, vuses);
245 set_value_handle (expr, val);
246 if (TREE_CODE (val) == VALUE_HANDLE)
247 add_to_value (val, expr);
251 /* Lookup EXPR in the value numbering tables and return the result, if
255 vn_lookup (tree expr)
257 /* Constants are their own value. */
258 if (is_gimple_min_invariant (expr) || TREE_CODE (expr) == FIELD_DECL)
261 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
265 return vn_binary_op_lookup (expr);
267 return vn_unary_op_lookup (expr);
269 /* In the case of array-refs of constants, for example, we can
270 end up with no vuses. */
272 return vn_reference_lookup (expr, NULL);
274 /* It is possible to have CALL_EXPR with no vuses for things
275 like "cos", and these will fall into vn_lookup. */
277 case tcc_exceptional:
279 case tcc_declaration:
280 if (TREE_CODE (expr) == CALL_EXPR || DECL_P (expr))
281 return vn_reference_lookup (expr, NULL);
282 else if (TREE_CODE (expr) == SSA_NAME)
283 return SSA_NAME_VALUE (expr);
284 else if (TREE_CODE (expr) == ADDR_EXPR)
285 return vn_unary_op_lookup (expr);
293 /* Search in the value numbering tables for an existing instance of
294 expression EXPR, and return its value, or NULL if none has been set. STMT
295 represents the stmt associated with EXPR. It is used when computing the
296 hash value for EXPR for reference operations. */
299 vn_lookup_with_stmt (tree expr, tree stmt)
302 return vn_lookup (expr);
304 /* Constants are their own value. */
305 if (is_gimple_min_invariant (expr) || TREE_CODE (expr) == FIELD_DECL)
308 return vn_lookup_with_vuses (expr, shared_vuses_from_stmt (stmt));
311 /* Search in VALUE_TABLE for an existing instance of expression EXPR,
312 and return its value, or NULL if none has been set. VUSES is the
313 list of virtual use operands associated with EXPR. It is used when
314 computing the hash value for EXPR. */
317 vn_lookup_with_vuses (tree expr, VEC (tree, gc) *vuses)
319 if (!vuses || !VEC_length (tree, vuses))
320 return vn_lookup (expr);
322 if (is_gimple_min_invariant (expr) || TREE_CODE (expr) == FIELD_DECL)
325 return vn_reference_lookup (expr, vuses);
329 create_value_handle_for_expr (tree expr, VEC(tree, gc) *vuses)
333 v = make_value_handle (TREE_TYPE (expr));
335 if (dump_file && (dump_flags & TDF_DETAILS))
336 print_creation_to_file (v, expr, vuses);
340 /* Like vn_lookup, but creates a new value for the operation if one
344 vn_lookup_or_add (tree expr)
346 tree v = vn_lookup (expr);
350 v = create_value_handle_for_expr (expr, NULL);
354 set_value_handle (expr, v);
359 /* Like vn_lookup, but handles reference operations as well by using
360 STMT to get the set of vuses. */
363 vn_lookup_or_add_with_stmt (tree expr, tree stmt)
367 return vn_lookup_or_add (expr);
369 v = vn_lookup_with_stmt (expr, stmt);
372 VEC (tree, gc) *vuses = copy_vuses_from_stmt (stmt);
373 v = create_value_handle_for_expr (expr, vuses);
374 vn_add_with_vuses (expr, v, vuses);
377 set_value_handle (expr, v);
382 /* Like vn_lookup, but creates a new value for expression EXPR, if
383 EXPR doesn't already have a value. Return the existing/created
384 value for EXPR. STMT represents the stmt associated with EXPR. It is used
385 when computing the hash value for EXPR. */
388 vn_lookup_or_add_with_vuses (tree expr, VEC (tree, gc) *vuses)
392 if (!vuses || VEC_length (tree, vuses) == 0)
393 return vn_lookup_or_add (expr);
395 v = vn_lookup_with_vuses (expr, vuses);
398 v = create_value_handle_for_expr (expr, vuses);
399 vn_add_with_vuses (expr, v, vuses);
402 set_value_handle (expr, v);