Line data Source code
1 : /* Header file for SSA dominator optimizations.
2 : Copyright (C) 2013-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #include "config.h"
21 : #include "system.h"
22 : #include "coretypes.h"
23 : #include "function.h"
24 : #include "basic-block.h"
25 : #include "tree.h"
26 : #include "gimple.h"
27 : #include "tree-pass.h"
28 : #include "tree-pretty-print.h"
29 : #include "tree-ssa-scopedtables.h"
30 : #include "tree-ssa-threadedge.h"
31 : #include "stor-layout.h"
32 : #include "fold-const.h"
33 : #include "tree-eh.h"
34 : #include "internal-fn.h"
35 : #include "tree-dfa.h"
36 : #include "options.h"
37 :
38 : static bool hashable_expr_equal_p (const struct hashable_expr *,
39 : const struct hashable_expr *);
40 :
41 : /* Initialize local stacks for this optimizer and record equivalences
42 : upon entry to BB. Equivalences can come from the edge traversed to
43 : reach BB or they may come from PHI nodes at the start of BB. */
44 :
45 : /* Pop items off the unwinding stack, removing each from the hash table
46 : until a marker is encountered. */
47 :
48 : void
49 64099135 : avail_exprs_stack::pop_to_marker ()
50 : {
51 : /* Remove all the expressions made available in this block. */
52 181832203 : while (m_stack.length () > 0)
53 : {
54 181832203 : std::pair<expr_hash_elt_t, expr_hash_elt_t> victim = m_stack.pop ();
55 181832203 : expr_hash_elt **slot;
56 :
57 181832203 : if (victim.first == NULL)
58 : break;
59 :
60 : /* This must precede the actual removal from the hash table,
61 : as ELEMENT and the table entry may share a call argument
62 : vector which will be freed during removal. */
63 117733068 : if (dump_file && (dump_flags & TDF_DETAILS))
64 : {
65 3320 : fprintf (dump_file, "<<<< ");
66 3320 : victim.first->print (dump_file);
67 : }
68 :
69 117733068 : slot = m_avail_exprs->find_slot (victim.first, NO_INSERT);
70 117733068 : gcc_assert (slot && *slot == victim.first);
71 117733068 : if (victim.second != NULL)
72 : {
73 4542317 : delete *slot;
74 4542317 : *slot = victim.second;
75 : }
76 : else
77 113190751 : m_avail_exprs->clear_slot (slot);
78 : }
79 64099135 : }
80 :
81 : /* Add <ELT1,ELT2> to the unwinding stack so they can be later removed
82 : from the hash table. */
83 :
84 : void
85 181832203 : avail_exprs_stack::record_expr (class expr_hash_elt *elt1,
86 : class expr_hash_elt *elt2,
87 : char type)
88 : {
89 181832203 : if (elt1 && dump_file && (dump_flags & TDF_DETAILS))
90 : {
91 3320 : fprintf (dump_file, "%c>>> ", type);
92 3320 : elt1->print (dump_file);
93 : }
94 :
95 181832203 : m_stack.safe_push (std::pair<expr_hash_elt_t, expr_hash_elt_t> (elt1, elt2));
96 181832203 : }
97 :
98 : /* Helper for walk_non_aliased_vuses. Determine if we arrived at
99 : the desired memory state. */
100 :
101 : static void *
102 19102963 : vuse_eq (ao_ref *, tree vuse1, void *data)
103 : {
104 19102963 : tree vuse2 = (tree) data;
105 19102963 : if (vuse1 == vuse2)
106 542121 : return data;
107 :
108 : return NULL;
109 : }
110 :
111 : /* We looked for STMT in the hash table, but did not find it.
112 :
113 : If STMT is an assignment from a binary operator, we may know something
114 : about the operands relationship to each other which would allow
115 : us to derive a constant value for the RHS of STMT. */
116 :
117 : tree
118 45785561 : avail_exprs_stack::simplify_binary_operation (gimple *stmt,
119 : class expr_hash_elt element)
120 : {
121 45785561 : if (is_gimple_assign (stmt))
122 : {
123 35987413 : struct hashable_expr *expr = element.expr ();
124 35987413 : if (expr->kind == EXPR_BINARY)
125 : {
126 10563167 : enum tree_code code = expr->ops.binary.op;
127 :
128 10563167 : switch (code)
129 : {
130 : /* For these cases, if we know some relationships
131 : between the operands, then we can simplify. */
132 209349 : case MIN_EXPR:
133 209349 : case MAX_EXPR:
134 209349 : {
135 : /* Build a simple equality expr and query the hash table
136 : for it. */
137 209349 : struct hashable_expr expr;
138 209349 : expr.type = boolean_type_node;
139 209349 : expr.kind = EXPR_BINARY;
140 209349 : expr.ops.binary.op = LE_EXPR;
141 209349 : tree rhs1 = gimple_assign_rhs1 (stmt);
142 209349 : tree rhs2 = gimple_assign_rhs2 (stmt);
143 209349 : if (tree_swap_operands_p (rhs1, rhs2))
144 1328 : std::swap (rhs1, rhs2);
145 209349 : expr.ops.binary.opnd0 = rhs1;
146 209349 : expr.ops.binary.opnd1 = rhs2;
147 209349 : class expr_hash_elt element2 (&expr, NULL_TREE);
148 209349 : expr_hash_elt **slot
149 209349 : = m_avail_exprs->find_slot (&element2, NO_INSERT);
150 :
151 : /* If the query was successful and returned a nonzero
152 : result, then we know the result of the MIN/MAX, even
153 : though it is not a constant value. */
154 209349 : if (slot && *slot && integer_onep ((*slot)->lhs ()))
155 797 : return code == MIN_EXPR ? rhs1 : rhs2;
156 :
157 : /* Try again, this time with GE_EXPR. */
158 208910 : expr.ops.binary.op = GE_EXPR;
159 208910 : class expr_hash_elt element3 (&expr, NULL_TREE);
160 208910 : slot = m_avail_exprs->find_slot (&element3, NO_INSERT);
161 :
162 : /* If the query was successful and returned a nonzero
163 : result, then we know the result of the MIN/MAX, even
164 : though it is not a constant value. */
165 208910 : if (slot && *slot && integer_onep ((*slot)->lhs ()))
166 505 : return code == MIN_EXPR ? rhs2 : rhs1;
167 :
168 208405 : break;
169 209349 : }
170 :
171 : /* For these cases, if we know the operands
172 : are equal, then we know the result. */
173 2083973 : case BIT_IOR_EXPR:
174 2083973 : case BIT_AND_EXPR:
175 2083973 : case BIT_XOR_EXPR:
176 2083973 : case MINUS_EXPR:
177 2083973 : case TRUNC_DIV_EXPR:
178 2083973 : case CEIL_DIV_EXPR:
179 2083973 : case FLOOR_DIV_EXPR:
180 2083973 : case ROUND_DIV_EXPR:
181 2083973 : case EXACT_DIV_EXPR:
182 2083973 : case TRUNC_MOD_EXPR:
183 2083973 : case CEIL_MOD_EXPR:
184 2083973 : case FLOOR_MOD_EXPR:
185 2083973 : case ROUND_MOD_EXPR:
186 2083973 : {
187 : /* Build a simple equality expr and query the hash table
188 : for it. */
189 2083973 : struct hashable_expr expr;
190 2083973 : expr.type = boolean_type_node;
191 2083973 : expr.kind = EXPR_BINARY;
192 2083973 : expr.ops.binary.op = EQ_EXPR;
193 2083973 : tree rhs1 = gimple_assign_rhs1 (stmt);
194 2083973 : tree rhs2 = gimple_assign_rhs2 (stmt);
195 2083973 : if (tree_swap_operands_p (rhs1, rhs2))
196 373700 : std::swap (rhs1, rhs2);
197 2083973 : expr.ops.binary.opnd0 = rhs1;
198 2083973 : expr.ops.binary.opnd1 = rhs2;
199 2083973 : class expr_hash_elt element2 (&expr, NULL_TREE);
200 2083973 : expr_hash_elt **slot
201 2083973 : = m_avail_exprs->find_slot (&element2, NO_INSERT);
202 2083973 : tree result_type = TREE_TYPE (gimple_assign_lhs (stmt));
203 :
204 : /* If the query was successful and returned a nonzero
205 : result, then we know that the operands of the binary
206 : expression are the same. In many cases this allows
207 : us to compute a constant result of the expression
208 : at compile time, even if we do not know the exact
209 : values of the operands. */
210 2083973 : if (slot && *slot && integer_onep ((*slot)->lhs ()))
211 : {
212 194 : switch (code)
213 : {
214 3 : case BIT_IOR_EXPR:
215 3 : case BIT_AND_EXPR:
216 3 : return gimple_assign_rhs1 (stmt);
217 :
218 146 : case MINUS_EXPR:
219 : /* This is unsafe for certain floats even in non-IEEE
220 : formats. In IEEE, it is unsafe because it does
221 : wrong for NaNs. */
222 116 : if (FLOAT_TYPE_P (result_type)
223 146 : && HONOR_NANS (result_type))
224 : break;
225 : /* FALLTHRU */
226 160 : case BIT_XOR_EXPR:
227 160 : case TRUNC_MOD_EXPR:
228 160 : case CEIL_MOD_EXPR:
229 160 : case FLOOR_MOD_EXPR:
230 160 : case ROUND_MOD_EXPR:
231 160 : return build_zero_cst (result_type);
232 :
233 1 : case TRUNC_DIV_EXPR:
234 1 : case CEIL_DIV_EXPR:
235 1 : case FLOOR_DIV_EXPR:
236 1 : case ROUND_DIV_EXPR:
237 1 : case EXACT_DIV_EXPR:
238 : /* Avoid _Fract types where we can't build 1. */
239 1 : if (ALL_FRACT_MODE_P (TYPE_MODE (result_type)))
240 : break;
241 1 : return build_one_cst (result_type);
242 :
243 0 : default:
244 0 : gcc_unreachable ();
245 : }
246 : }
247 2083809 : break;
248 2083973 : }
249 :
250 : default:
251 : break;
252 : }
253 : }
254 : }
255 : return NULL_TREE;
256 : }
257 :
258 : /* Search for an existing instance of STMT in the AVAIL_EXPRS_STACK table.
259 : If found, return its LHS. Otherwise insert STMT in the table and
260 : return NULL_TREE.
261 :
262 : Also, when an expression is first inserted in the table, it is also
263 : is also added to AVAIL_EXPRS_STACK, so that it can be removed when
264 : we finish processing this block and its children. */
265 :
266 : tree
267 121346596 : avail_exprs_stack::lookup_avail_expr (gimple *stmt, bool insert, bool tbaa_p,
268 : expr_hash_elt **elt)
269 : {
270 121346596 : expr_hash_elt **slot;
271 121346596 : tree lhs;
272 :
273 : /* Get LHS of phi, assignment, or call; else NULL_TREE. */
274 121346596 : if (gimple_code (stmt) == GIMPLE_PHI)
275 8728995 : lhs = gimple_phi_result (stmt);
276 : else
277 112617601 : lhs = gimple_get_lhs (stmt);
278 :
279 121346596 : class expr_hash_elt element (stmt, lhs);
280 :
281 121346596 : if (dump_file && (dump_flags & TDF_DETAILS))
282 : {
283 2869 : fprintf (dump_file, "LKUP ");
284 2869 : element.print (dump_file);
285 : }
286 :
287 : /* Don't bother remembering constant assignments and copy operations.
288 : Constants and copy operations are handled by the constant/copy propagator
289 : in optimize_stmt. */
290 121346596 : if (element.expr()->kind == EXPR_SINGLE
291 121346596 : && (TREE_CODE (element.expr()->ops.single.rhs) == SSA_NAME
292 55085914 : || is_gimple_min_invariant (element.expr()->ops.single.rhs)))
293 13397109 : return NULL_TREE;
294 :
295 : /* Finally try to find the expression in the main expression hash table. */
296 165144111 : slot = m_avail_exprs->find_slot (&element, (insert ? INSERT : NO_INSERT));
297 107949487 : if (slot == NULL)
298 : {
299 : return NULL_TREE;
300 : }
301 55595909 : else if (*slot == NULL)
302 : {
303 : /* We have, in effect, allocated *SLOT for ELEMENT at this point.
304 : We must initialize *SLOT to a real entry, even if we found a
305 : way to prove ELEMENT was a constant after not finding ELEMENT
306 : in the hash table.
307 :
308 : An uninitialized or empty slot is an indication no prior objects
309 : entered into the hash table had a hash collection with ELEMENT.
310 :
311 : If we fail to do so and had such entries in the table, they
312 : would become unreachable. */
313 45785561 : class expr_hash_elt *element2 = new expr_hash_elt (element);
314 45785561 : *slot = element2;
315 :
316 : /* If we did not find the expression in the hash table, we may still
317 : be able to produce a result for some expressions. */
318 45785561 : tree retval = avail_exprs_stack::simplify_binary_operation (stmt,
319 : element);
320 :
321 45785561 : record_expr (element2, NULL, '2');
322 45785561 : return retval;
323 : }
324 :
325 : /* If we found a redundant memory operation do an alias walk to
326 : check if we can re-use it. */
327 19420215 : if (gimple_vuse (stmt) != (*slot)->vop ())
328 : {
329 8219663 : tree vuse1 = (*slot)->vop ();
330 8219663 : tree vuse2 = gimple_vuse (stmt);
331 : /* If we have a load of a register and a candidate in the
332 : hash with vuse1 then try to reach its stmt by walking
333 : up the virtual use-def chain using walk_non_aliased_vuses.
334 : But don't do this when removing expressions from the hash. */
335 8219663 : ao_ref ref;
336 8219663 : unsigned limit = param_sccvn_max_alias_queries_per_access;
337 15508449 : if (!(vuse1 && vuse2
338 8219663 : && gimple_assign_single_p (stmt)
339 8101461 : && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
340 7288786 : && (ao_ref_init (&ref, gimple_assign_rhs1 (stmt)),
341 7288786 : ref.base_alias_set = ref.ref_alias_set = tbaa_p ? -1 : 0, true)
342 7288786 : && walk_non_aliased_vuses (&ref, vuse2, true, vuse_eq, NULL, NULL,
343 : NULL, limit, vuse1) != NULL))
344 : {
345 7677542 : if (insert)
346 : {
347 4542317 : class expr_hash_elt *element2 = new expr_hash_elt (element);
348 :
349 : /* Insert the expr into the hash by replacing the current
350 : entry and recording the value to restore in the
351 : avail_exprs_stack. */
352 4542317 : record_expr (element2, *slot, '2');
353 4542317 : *slot = element2;
354 : }
355 7677542 : return NULL_TREE;
356 : }
357 : }
358 :
359 : /* Extract the LHS of the assignment so that it can be used as the current
360 : definition of another variable. */
361 2132806 : lhs = (*slot)->lhs ();
362 2132806 : if (elt)
363 843086 : *elt = *slot;
364 :
365 : /* Valueize the result. */
366 2132806 : if (TREE_CODE (lhs) == SSA_NAME)
367 : {
368 1834869 : tree tem = SSA_NAME_VALUE (lhs);
369 1554889 : if (tem)
370 2132806 : lhs = tem;
371 : }
372 :
373 2132806 : if (dump_file && (dump_flags & TDF_DETAILS))
374 : {
375 172 : fprintf (dump_file, "FIND: ");
376 172 : print_generic_expr (dump_file, lhs);
377 172 : fprintf (dump_file, "\n");
378 : }
379 :
380 : return lhs;
381 121346596 : }
382 :
383 : /* Enter condition equivalence P into the hash table.
384 :
385 : This indicates that a conditional expression has a known
386 : boolean value. */
387 :
388 : void
389 67896910 : avail_exprs_stack::record_cond (cond_equivalence *p)
390 : {
391 67896910 : class expr_hash_elt *element = new expr_hash_elt (&p->cond, p->value);
392 67896910 : expr_hash_elt **slot;
393 :
394 67896910 : slot = m_avail_exprs->find_slot_with_hash (element, element->hash (), INSERT);
395 67896910 : if (*slot == NULL)
396 : {
397 67405190 : *slot = element;
398 67405190 : record_expr (element, NULL, '1');
399 : }
400 : else
401 491720 : delete element;
402 67896910 : }
403 :
404 : /* Generate a hash value for a pair of expressions. This can be used
405 : iteratively by passing a previous result in HSTATE.
406 :
407 : The same hash value is always returned for a given pair of expressions,
408 : regardless of the order in which they are presented. This is useful in
409 : hashing the operands of commutative functions. */
410 :
411 : namespace inchash
412 : {
413 :
414 : static void
415 66439604 : add_expr_commutative (const_tree t1, const_tree t2, hash &hstate)
416 : {
417 66439604 : hash one, two;
418 :
419 66439604 : inchash::add_expr (t1, one);
420 66439604 : inchash::add_expr (t2, two);
421 66439604 : hstate.add_commutative (one, two);
422 66439604 : }
423 :
424 : /* Compute a hash value for a hashable_expr value EXPR and a
425 : previously accumulated hash value VAL. If two hashable_expr
426 : values compare equal with hashable_expr_equal_p, they must
427 : hash to the same value, given an identical value of VAL.
428 : The logic is intended to follow inchash::add_expr in tree.cc. */
429 :
430 : static void
431 152003576 : add_hashable_expr (const struct hashable_expr *expr, hash &hstate)
432 : {
433 152003576 : switch (expr->kind)
434 : {
435 21860183 : case EXPR_SINGLE:
436 21860183 : inchash::add_expr (expr->ops.single.rhs, hstate);
437 21860183 : break;
438 :
439 8159085 : case EXPR_UNARY:
440 8159085 : hstate.add_object (expr->ops.unary.op);
441 :
442 : /* Make sure to include signedness in the hash computation.
443 : Don't hash the type, that can lead to having nodes which
444 : compare equal according to operand_equal_p, but which
445 : have different hash codes. */
446 8159085 : if (CONVERT_EXPR_CODE_P (expr->ops.unary.op)
447 959420 : || expr->ops.unary.op == NON_LVALUE_EXPR)
448 7199665 : hstate.add_int (TYPE_UNSIGNED (expr->type));
449 :
450 8159085 : inchash::add_expr (expr->ops.unary.opnd, hstate);
451 8159085 : break;
452 :
453 110022604 : case EXPR_BINARY:
454 110022604 : hstate.add_object (expr->ops.binary.op);
455 110022604 : if (commutative_tree_code (expr->ops.binary.op))
456 66438854 : inchash::add_expr_commutative (expr->ops.binary.opnd0,
457 66438854 : expr->ops.binary.opnd1, hstate);
458 : else
459 : {
460 43583750 : inchash::add_expr (expr->ops.binary.opnd0, hstate);
461 43583750 : inchash::add_expr (expr->ops.binary.opnd1, hstate);
462 : }
463 : break;
464 :
465 230786 : case EXPR_TERNARY:
466 230786 : hstate.add_object (expr->ops.ternary.op);
467 230786 : if (commutative_ternary_tree_code (expr->ops.ternary.op))
468 750 : inchash::add_expr_commutative (expr->ops.ternary.opnd0,
469 750 : expr->ops.ternary.opnd1, hstate);
470 : else
471 : {
472 230036 : inchash::add_expr (expr->ops.ternary.opnd0, hstate);
473 230036 : inchash::add_expr (expr->ops.ternary.opnd1, hstate);
474 : }
475 230786 : inchash::add_expr (expr->ops.ternary.opnd2, hstate);
476 230786 : break;
477 :
478 3001923 : case EXPR_CALL:
479 3001923 : {
480 3001923 : size_t i;
481 3001923 : enum tree_code code = CALL_EXPR;
482 3001923 : gcall *fn_from;
483 :
484 3001923 : hstate.add_object (code);
485 3001923 : fn_from = expr->ops.call.fn_from;
486 3001923 : if (gimple_call_internal_p (fn_from))
487 272350 : hstate.merge_hash ((hashval_t) gimple_call_internal_fn (fn_from));
488 : else
489 2729573 : inchash::add_expr (gimple_call_fn (fn_from), hstate);
490 8869050 : for (i = 0; i < expr->ops.call.nargs; i++)
491 5867127 : inchash::add_expr (expr->ops.call.args[i], hstate);
492 : }
493 3001923 : break;
494 :
495 : case EXPR_PHI:
496 : {
497 : size_t i;
498 :
499 31247060 : for (i = 0; i < expr->ops.phi.nargs; i++)
500 22518065 : inchash::add_expr (expr->ops.phi.args[i], hstate);
501 : }
502 : break;
503 :
504 0 : default:
505 0 : gcc_unreachable ();
506 : }
507 152003576 : }
508 :
509 : }
510 :
511 : /* Hashing and equality functions. We compute a value number for expressions
512 : using the code of the expression and the SSA numbers of its operands. */
513 :
514 : static hashval_t
515 191745738 : avail_expr_hash (class expr_hash_elt *p)
516 : {
517 191745738 : const struct hashable_expr *expr = p->expr ();
518 191745738 : inchash::hash hstate;
519 :
520 191745738 : if (expr->kind == EXPR_SINGLE)
521 : {
522 : /* T could potentially be a switch index or a goto dest. */
523 61602345 : tree t = expr->ops.single.rhs;
524 61602345 : if (TREE_CODE (t) == MEM_REF || handled_component_p (t))
525 : {
526 : /* Make equivalent statements of both these kinds hash together.
527 : Dealing with both MEM_REF and ARRAY_REF allows us not to care
528 : about equivalence with other statements not considered here. */
529 41060815 : bool reverse;
530 41060815 : poly_int64 offset, size, max_size;
531 41060815 : tree base = get_ref_base_and_extent (t, &offset, &size, &max_size,
532 : &reverse);
533 : /* Strictly, we could try to normalize variable-sized accesses too,
534 : but here we just deal with the common case. */
535 41060815 : if (known_size_p (max_size)
536 41060815 : && known_eq (size, max_size))
537 : {
538 39742162 : enum tree_code code = MEM_REF;
539 39742162 : hstate.add_object (code);
540 39742162 : inchash::add_expr (base, hstate,
541 39742162 : TREE_CODE (base) == MEM_REF
542 : ? OEP_ADDRESS_OF : 0);
543 39742162 : hstate.add_object (offset);
544 39742162 : hstate.add_object (size);
545 39742162 : return hstate.end ();
546 : }
547 : }
548 : }
549 :
550 152003576 : inchash::add_hashable_expr (expr, hstate);
551 :
552 152003576 : return hstate.end ();
553 : }
554 :
555 : /* Compares trees T0 and T1 to see if they are MEM_REF or ARRAY_REFs equivalent
556 : to each other. (That is, they return the value of the same bit of memory.)
557 :
558 : Return TRUE if the two are so equivalent; FALSE if not (which could still
559 : mean the two are equivalent by other means). */
560 :
561 : static bool
562 9046986 : equal_mem_array_ref_p (tree t0, tree t1)
563 : {
564 9046986 : if (TREE_CODE (t0) != MEM_REF && ! handled_component_p (t0))
565 : return false;
566 9180827 : if (TREE_CODE (t1) != MEM_REF && ! handled_component_p (t1))
567 : return false;
568 :
569 7774237 : if (!types_compatible_p (TREE_TYPE (t0), TREE_TYPE (t1)))
570 : return false;
571 7770247 : bool rev0;
572 7770247 : poly_int64 off0, sz0, max0;
573 7770247 : tree base0 = get_ref_base_and_extent (t0, &off0, &sz0, &max0, &rev0);
574 7770247 : if (!known_size_p (max0)
575 7770247 : || maybe_ne (sz0, max0))
576 : return false;
577 :
578 7640400 : bool rev1;
579 7640400 : poly_int64 off1, sz1, max1;
580 7640400 : tree base1 = get_ref_base_and_extent (t1, &off1, &sz1, &max1, &rev1);
581 7640400 : if (!known_size_p (max1)
582 7640400 : || maybe_ne (sz1, max1))
583 : return false;
584 :
585 7640400 : if (rev0 != rev1 || maybe_ne (sz0, sz1) || maybe_ne (off0, off1))
586 : return false;
587 :
588 7640396 : return operand_equal_p (base0, base1,
589 7640396 : (TREE_CODE (base0) == MEM_REF
590 7640396 : || TREE_CODE (base0) == TARGET_MEM_REF)
591 2706848 : && (TREE_CODE (base1) == MEM_REF
592 2706848 : || TREE_CODE (base1) == TARGET_MEM_REF)
593 7640396 : ? OEP_ADDRESS_OF : 0);
594 : }
595 :
596 : /* Compare two hashable_expr structures for equivalence. They are
597 : considered equivalent when the expressions they denote must
598 : necessarily be equal. The logic is intended to follow that of
599 : operand_equal_p in fold-const.cc */
600 :
601 : static bool
602 10618332 : hashable_expr_equal_p (const struct hashable_expr *expr0,
603 : const struct hashable_expr *expr1)
604 : {
605 10618332 : tree type0 = expr0->type;
606 10618332 : tree type1 = expr1->type;
607 :
608 : /* If either type is NULL, there is nothing to check. */
609 10618332 : if ((type0 == NULL_TREE) ^ (type1 == NULL_TREE))
610 : return false;
611 :
612 : /* If both types don't have the same signedness, precision, and mode,
613 : then we can't consider them equal. */
614 10618332 : if (type0 != type1
615 10618332 : && (TREE_CODE (type0) == ERROR_MARK
616 1423648 : || TREE_CODE (type1) == ERROR_MARK
617 1423648 : || TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1)
618 1360551 : || element_precision (type0) != element_precision (type1)
619 1249745 : || TYPE_MODE (type0) != TYPE_MODE (type1)))
620 252816 : return false;
621 :
622 10365516 : if (expr0->kind != expr1->kind)
623 : return false;
624 :
625 10365516 : switch (expr0->kind)
626 : {
627 9046986 : case EXPR_SINGLE:
628 9046986 : return equal_mem_array_ref_p (expr0->ops.single.rhs,
629 9046986 : expr1->ops.single.rhs)
630 10456519 : || operand_equal_p (expr0->ops.single.rhs,
631 1409533 : expr1->ops.single.rhs, 0);
632 203981 : case EXPR_UNARY:
633 203981 : if (expr0->ops.unary.op != expr1->ops.unary.op)
634 : return false;
635 :
636 16360 : if ((CONVERT_EXPR_CODE_P (expr0->ops.unary.op)
637 16360 : || expr0->ops.unary.op == NON_LVALUE_EXPR)
638 203981 : && TYPE_UNSIGNED (expr0->type) != TYPE_UNSIGNED (expr1->type))
639 : return false;
640 :
641 203981 : return operand_equal_p (expr0->ops.unary.opnd,
642 203981 : expr1->ops.unary.opnd, 0);
643 :
644 960776 : case EXPR_BINARY:
645 960776 : if (expr0->ops.binary.op != expr1->ops.binary.op)
646 : return false;
647 :
648 960770 : if (operand_equal_p (expr0->ops.binary.opnd0,
649 960770 : expr1->ops.binary.opnd0, 0)
650 1906065 : && operand_equal_p (expr0->ops.binary.opnd1,
651 945295 : expr1->ops.binary.opnd1, 0))
652 : return true;
653 :
654 : /* For commutative ops, allow the other order. */
655 18725 : return (commutative_tree_code (expr0->ops.binary.op)
656 16200 : && operand_equal_p (expr0->ops.binary.opnd0,
657 16200 : expr1->ops.binary.opnd1, 0)
658 25380 : && operand_equal_p (expr0->ops.binary.opnd1,
659 6655 : expr1->ops.binary.opnd0, 0));
660 :
661 959 : case EXPR_TERNARY:
662 959 : if (expr0->ops.ternary.op != expr1->ops.ternary.op
663 1918 : || !operand_equal_p (expr0->ops.ternary.opnd2,
664 959 : expr1->ops.ternary.opnd2, 0))
665 0 : return false;
666 :
667 : /* BIT_INSERT_EXPR has an implicit operand as the type precision
668 : of op1. Need to check to make sure they are the same. */
669 959 : if (expr0->ops.ternary.op == BIT_INSERT_EXPR
670 0 : && TREE_CODE (expr0->ops.ternary.opnd1) == INTEGER_CST
671 0 : && TREE_CODE (expr1->ops.ternary.opnd1) == INTEGER_CST
672 959 : && TYPE_PRECISION (TREE_TYPE (expr0->ops.ternary.opnd1))
673 0 : != TYPE_PRECISION (TREE_TYPE (expr1->ops.ternary.opnd1)))
674 : return false;
675 :
676 959 : if (operand_equal_p (expr0->ops.ternary.opnd0,
677 959 : expr1->ops.ternary.opnd0, 0)
678 1918 : && operand_equal_p (expr0->ops.ternary.opnd1,
679 959 : expr1->ops.ternary.opnd1, 0))
680 : return true;
681 :
682 : /* For commutative ops, allow the other order. */
683 0 : return (commutative_ternary_tree_code (expr0->ops.ternary.op)
684 0 : && operand_equal_p (expr0->ops.ternary.opnd0,
685 0 : expr1->ops.ternary.opnd1, 0)
686 0 : && operand_equal_p (expr0->ops.ternary.opnd1,
687 0 : expr1->ops.ternary.opnd0, 0));
688 :
689 129516 : case EXPR_CALL:
690 129516 : {
691 129516 : size_t i;
692 :
693 : /* If the calls are to different functions, then they
694 : clearly cannot be equal. */
695 129516 : if (!gimple_call_same_target_p (expr0->ops.call.fn_from,
696 129516 : expr1->ops.call.fn_from))
697 : return false;
698 :
699 128892 : if (! expr0->ops.call.pure)
700 : return false;
701 :
702 128892 : if (expr0->ops.call.nargs != expr1->ops.call.nargs)
703 : return false;
704 :
705 371602 : for (i = 0; i < expr0->ops.call.nargs; i++)
706 242750 : if (! operand_equal_p (expr0->ops.call.args[i],
707 242750 : expr1->ops.call.args[i], 0))
708 : return false;
709 :
710 128852 : if (stmt_could_throw_p (cfun, expr0->ops.call.fn_from))
711 : {
712 22 : int lp0 = lookup_stmt_eh_lp (expr0->ops.call.fn_from);
713 22 : int lp1 = lookup_stmt_eh_lp (expr1->ops.call.fn_from);
714 22 : if ((lp0 > 0 || lp1 > 0) && lp0 != lp1)
715 : return false;
716 : }
717 :
718 : return true;
719 : }
720 :
721 23298 : case EXPR_PHI:
722 23298 : {
723 23298 : size_t i;
724 :
725 23298 : if (expr0->ops.phi.nargs != expr1->ops.phi.nargs)
726 : return false;
727 :
728 58860 : for (i = 0; i < expr0->ops.phi.nargs; i++)
729 35628 : if (! operand_equal_p (expr0->ops.phi.args[i],
730 35628 : expr1->ops.phi.args[i], 0))
731 : return false;
732 :
733 : return true;
734 : }
735 :
736 0 : default:
737 0 : gcc_unreachable ();
738 : }
739 : }
740 :
741 : /* Given a statement STMT, construct a hash table element. */
742 :
743 121346596 : expr_hash_elt::expr_hash_elt (gimple *stmt, tree orig_lhs)
744 : {
745 121346596 : enum gimple_code code = gimple_code (stmt);
746 121346596 : struct hashable_expr *expr = this->expr ();
747 :
748 121346596 : if (code == GIMPLE_ASSIGN)
749 : {
750 90185913 : enum tree_code subcode = gimple_assign_rhs_code (stmt);
751 :
752 90185913 : switch (get_gimple_rhs_class (subcode))
753 : {
754 61539416 : case GIMPLE_SINGLE_RHS:
755 61539416 : expr->kind = EXPR_SINGLE;
756 61539416 : expr->type = TREE_TYPE (gimple_assign_rhs1 (stmt));
757 61539416 : expr->ops.single.rhs = gimple_assign_rhs1 (stmt);
758 61539416 : break;
759 8036045 : case GIMPLE_UNARY_RHS:
760 8036045 : expr->kind = EXPR_UNARY;
761 8036045 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
762 8036045 : if (CONVERT_EXPR_CODE_P (subcode))
763 7199665 : subcode = NOP_EXPR;
764 8036045 : expr->ops.unary.op = subcode;
765 8036045 : expr->ops.unary.opnd = gimple_assign_rhs1 (stmt);
766 8036045 : break;
767 20379666 : case GIMPLE_BINARY_RHS:
768 20379666 : expr->kind = EXPR_BINARY;
769 20379666 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
770 20379666 : expr->ops.binary.op = subcode;
771 20379666 : expr->ops.binary.opnd0 = gimple_assign_rhs1 (stmt);
772 20379666 : expr->ops.binary.opnd1 = gimple_assign_rhs2 (stmt);
773 20379666 : break;
774 230786 : case GIMPLE_TERNARY_RHS:
775 230786 : expr->kind = EXPR_TERNARY;
776 230786 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
777 230786 : expr->ops.ternary.op = subcode;
778 230786 : expr->ops.ternary.opnd0 = gimple_assign_rhs1 (stmt);
779 230786 : expr->ops.ternary.opnd1 = gimple_assign_rhs2 (stmt);
780 230786 : expr->ops.ternary.opnd2 = gimple_assign_rhs3 (stmt);
781 230786 : break;
782 0 : default:
783 0 : gcc_unreachable ();
784 : }
785 : }
786 : else if (code == GIMPLE_COND)
787 : {
788 19366836 : expr->type = boolean_type_node;
789 19366836 : expr->kind = EXPR_BINARY;
790 19366836 : expr->ops.binary.op = gimple_cond_code (stmt);
791 19366836 : expr->ops.binary.opnd0 = gimple_cond_lhs (stmt);
792 19366836 : expr->ops.binary.opnd1 = gimple_cond_rhs (stmt);
793 : }
794 3001923 : else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
795 : {
796 3001923 : size_t nargs = gimple_call_num_args (call_stmt);
797 3001923 : size_t i;
798 :
799 3001923 : gcc_assert (gimple_call_lhs (call_stmt));
800 :
801 3001923 : expr->type = TREE_TYPE (gimple_call_lhs (call_stmt));
802 3001923 : expr->kind = EXPR_CALL;
803 3001923 : expr->ops.call.fn_from = call_stmt;
804 :
805 3001923 : if (gimple_call_flags (call_stmt) & (ECF_CONST | ECF_PURE))
806 1548903 : expr->ops.call.pure = true;
807 : else
808 1453020 : expr->ops.call.pure = false;
809 :
810 3001923 : expr->ops.call.nargs = nargs;
811 3001923 : expr->ops.call.args = XCNEWVEC (tree, nargs);
812 8869050 : for (i = 0; i < nargs; i++)
813 5867127 : expr->ops.call.args[i] = gimple_call_arg (call_stmt, i);
814 : }
815 62700 : else if (gswitch *swtch_stmt = dyn_cast <gswitch *> (stmt))
816 : {
817 62700 : expr->type = TREE_TYPE (gimple_switch_index (swtch_stmt));
818 62700 : expr->kind = EXPR_SINGLE;
819 62700 : expr->ops.single.rhs = gimple_switch_index (swtch_stmt);
820 : }
821 : else if (code == GIMPLE_GOTO)
822 : {
823 229 : expr->type = TREE_TYPE (gimple_goto_dest (stmt));
824 229 : expr->kind = EXPR_SINGLE;
825 229 : expr->ops.single.rhs = gimple_goto_dest (stmt);
826 : }
827 : else if (code == GIMPLE_PHI)
828 : {
829 8728995 : size_t nargs = gimple_phi_num_args (stmt);
830 8728995 : size_t i;
831 :
832 8728995 : expr->type = TREE_TYPE (gimple_phi_result (stmt));
833 8728995 : expr->kind = EXPR_PHI;
834 8728995 : expr->ops.phi.nargs = nargs;
835 8728995 : expr->ops.phi.args = XCNEWVEC (tree, nargs);
836 31247060 : for (i = 0; i < nargs; i++)
837 22518065 : expr->ops.phi.args[i] = gimple_phi_arg_def (stmt, i);
838 : }
839 : else
840 0 : gcc_unreachable ();
841 :
842 121346596 : m_lhs = orig_lhs;
843 121346596 : m_vop = gimple_vuse (stmt);
844 121346596 : m_hash = avail_expr_hash (this);
845 121346596 : m_stamp = this;
846 121346596 : }
847 :
848 : /* Given a hashable_expr expression ORIG and an ORIG_LHS,
849 : construct a hash table element. */
850 :
851 70399142 : expr_hash_elt::expr_hash_elt (struct hashable_expr *orig, tree orig_lhs)
852 : {
853 70399142 : m_expr = *orig;
854 70399142 : m_lhs = orig_lhs;
855 70399142 : m_vop = NULL_TREE;
856 70399142 : m_hash = avail_expr_hash (this);
857 70399142 : m_stamp = this;
858 70399142 : }
859 :
860 : /* Copy constructor for a hash table element. */
861 :
862 96113439 : expr_hash_elt::expr_hash_elt (class expr_hash_elt &old_elt)
863 : {
864 96113439 : m_expr = old_elt.m_expr;
865 96113439 : m_lhs = old_elt.m_lhs;
866 96113439 : m_vop = old_elt.m_vop;
867 96113439 : m_hash = old_elt.m_hash;
868 96113439 : m_stamp = this;
869 :
870 : /* Now deep copy the malloc'd space for CALL and PHI args. */
871 96113439 : if (old_elt.m_expr.kind == EXPR_CALL)
872 : {
873 2286385 : size_t nargs = old_elt.m_expr.ops.call.nargs;
874 2286385 : size_t i;
875 :
876 2286385 : m_expr.ops.call.args = XCNEWVEC (tree, nargs);
877 7286015 : for (i = 0; i < nargs; i++)
878 4999630 : m_expr.ops.call.args[i] = old_elt.m_expr.ops.call.args[i];
879 : }
880 93827054 : else if (old_elt.m_expr.kind == EXPR_PHI)
881 : {
882 17399358 : size_t nargs = old_elt.m_expr.ops.phi.nargs;
883 17399358 : size_t i;
884 :
885 17399358 : m_expr.ops.phi.args = XCNEWVEC (tree, nargs);
886 62322176 : for (i = 0; i < nargs; i++)
887 44922818 : m_expr.ops.phi.args[i] = old_elt.m_expr.ops.phi.args[i];
888 : }
889 96113439 : }
890 :
891 : /* Calls and PHIs have a variable number of arguments that are allocated
892 : on the heap. Thus we have to have a special dtor to release them. */
893 :
894 287859177 : expr_hash_elt::~expr_hash_elt ()
895 : {
896 287859177 : if (m_expr.kind == EXPR_CALL)
897 5288308 : free (m_expr.ops.call.args);
898 282570869 : else if (m_expr.kind == EXPR_PHI)
899 26128353 : free (m_expr.ops.phi.args);
900 287859177 : }
901 :
902 : /* Print a diagnostic dump of an expression hash table entry. */
903 :
904 : void
905 9509 : expr_hash_elt::print (FILE *stream)
906 : {
907 9509 : fprintf (stream, "STMT ");
908 :
909 9509 : if (m_lhs)
910 : {
911 8945 : print_generic_expr (stream, m_lhs);
912 8945 : fprintf (stream, " = ");
913 : }
914 :
915 9509 : switch (m_expr.kind)
916 : {
917 2609 : case EXPR_SINGLE:
918 2609 : print_generic_expr (stream, m_expr.ops.single.rhs);
919 2609 : break;
920 :
921 266 : case EXPR_UNARY:
922 266 : fprintf (stream, "%s ", get_tree_code_name (m_expr.ops.unary.op));
923 266 : print_generic_expr (stream, m_expr.ops.unary.opnd);
924 266 : break;
925 :
926 5946 : case EXPR_BINARY:
927 5946 : print_generic_expr (stream, m_expr.ops.binary.opnd0);
928 5946 : fprintf (stream, " %s ", get_tree_code_name (m_expr.ops.binary.op));
929 5946 : print_generic_expr (stream, m_expr.ops.binary.opnd1);
930 5946 : break;
931 :
932 0 : case EXPR_TERNARY:
933 0 : fprintf (stream, " %s <", get_tree_code_name (m_expr.ops.ternary.op));
934 0 : print_generic_expr (stream, m_expr.ops.ternary.opnd0);
935 0 : fputs (", ", stream);
936 0 : print_generic_expr (stream, m_expr.ops.ternary.opnd1);
937 0 : fputs (", ", stream);
938 0 : print_generic_expr (stream, m_expr.ops.ternary.opnd2);
939 0 : fputs (">", stream);
940 0 : break;
941 :
942 6 : case EXPR_CALL:
943 6 : {
944 6 : size_t i;
945 6 : size_t nargs = m_expr.ops.call.nargs;
946 6 : gcall *fn_from;
947 :
948 6 : fn_from = m_expr.ops.call.fn_from;
949 6 : if (gimple_call_internal_p (fn_from))
950 0 : fprintf (stream, ".%s",
951 : internal_fn_name (gimple_call_internal_fn (fn_from)));
952 : else
953 6 : print_generic_expr (stream, gimple_call_fn (fn_from));
954 6 : fprintf (stream, " (");
955 24 : for (i = 0; i < nargs; i++)
956 : {
957 12 : print_generic_expr (stream, m_expr.ops.call.args[i]);
958 12 : if (i + 1 < nargs)
959 6 : fprintf (stream, ", ");
960 : }
961 6 : fprintf (stream, ")");
962 : }
963 6 : break;
964 :
965 682 : case EXPR_PHI:
966 682 : {
967 682 : size_t i;
968 682 : size_t nargs = m_expr.ops.phi.nargs;
969 :
970 682 : fprintf (stream, "PHI <");
971 2920 : for (i = 0; i < nargs; i++)
972 : {
973 1556 : print_generic_expr (stream, m_expr.ops.phi.args[i]);
974 1556 : if (i + 1 < nargs)
975 874 : fprintf (stream, ", ");
976 : }
977 682 : fprintf (stream, ">");
978 : }
979 682 : break;
980 : }
981 :
982 9509 : if (m_vop)
983 : {
984 2371 : fprintf (stream, " with ");
985 2371 : print_generic_expr (stream, m_vop);
986 : }
987 :
988 9509 : fprintf (stream, "\n");
989 9509 : }
990 :
991 : /* Pop entries off the stack until we hit the NULL marker.
992 : For each entry popped, use the SRC/DEST pair to restore
993 : SRC to its prior value. */
994 :
995 : void
996 53830819 : const_and_copies::pop_to_marker (void)
997 : {
998 91855819 : while (m_stack.length () > 0)
999 : {
1000 91855819 : tree prev_value, dest;
1001 :
1002 91855819 : dest = m_stack.pop ();
1003 :
1004 : /* A NULL value indicates we should stop unwinding, otherwise
1005 : pop off the next entry as they're recorded in pairs. */
1006 91855819 : if (dest == NULL)
1007 : break;
1008 :
1009 38025000 : if (dump_file && (dump_flags & TDF_DETAILS))
1010 : {
1011 1196 : fprintf (dump_file, "<<<< COPY ");
1012 1196 : print_generic_expr (dump_file, dest);
1013 1196 : fprintf (dump_file, " = ");
1014 1196 : print_generic_expr (dump_file, SSA_NAME_VALUE (dest));
1015 1196 : fprintf (dump_file, "\n");
1016 : }
1017 :
1018 38025000 : prev_value = m_stack.pop ();
1019 38025000 : set_ssa_name_value (dest, prev_value);
1020 : }
1021 53830819 : }
1022 :
1023 : /* Record that X has the value Y and that X's previous value is PREV_X.
1024 :
1025 : This variant does not follow the value chain for Y. */
1026 :
1027 : void
1028 38025000 : const_and_copies::record_const_or_copy_raw (tree x, tree y, tree prev_x)
1029 : {
1030 38025000 : if (dump_file && (dump_flags & TDF_DETAILS))
1031 : {
1032 1196 : fprintf (dump_file, "0>>> COPY ");
1033 1196 : print_generic_expr (dump_file, x);
1034 1196 : fprintf (dump_file, " = ");
1035 1196 : print_generic_expr (dump_file, y);
1036 1196 : fprintf (dump_file, "\n");
1037 : }
1038 :
1039 38025000 : set_ssa_name_value (x, y);
1040 38025000 : m_stack.reserve (2);
1041 38025000 : m_stack.quick_push (prev_x);
1042 38025000 : m_stack.quick_push (x);
1043 38025000 : }
1044 :
1045 : /* Record that X has the value Y. */
1046 :
1047 : void
1048 24507220 : const_and_copies::record_const_or_copy (tree x, tree y)
1049 : {
1050 24507220 : record_const_or_copy (x, y, SSA_NAME_VALUE (x));
1051 24507220 : }
1052 :
1053 : /* Record that X has the value Y and that X's previous value is PREV_X.
1054 :
1055 : This variant follow's Y value chain. */
1056 :
1057 : void
1058 38025000 : const_and_copies::record_const_or_copy (tree x, tree y, tree prev_x)
1059 : {
1060 : /* Y may be NULL if we are invalidating entries in the table. */
1061 38025000 : if (y && TREE_CODE (y) == SSA_NAME)
1062 : {
1063 16662090 : tree tmp = SSA_NAME_VALUE (y);
1064 15089134 : y = tmp ? tmp : y;
1065 : }
1066 :
1067 38025000 : record_const_or_copy_raw (x, y, prev_x);
1068 38025000 : }
1069 :
1070 : bool
1071 259916637 : expr_elt_hasher::equal (const value_type &p1, const compare_type &p2)
1072 : {
1073 259916637 : const struct hashable_expr *expr1 = p1->expr ();
1074 259916637 : const class expr_hash_elt *stamp1 = p1->stamp ();
1075 259916637 : const struct hashable_expr *expr2 = p2->expr ();
1076 259916637 : const class expr_hash_elt *stamp2 = p2->stamp ();
1077 :
1078 : /* This case should apply only when removing entries from the table. */
1079 259916637 : if (stamp1 == stamp2)
1080 : return true;
1081 :
1082 142183569 : if (p1->hash () != p2->hash ())
1083 : return false;
1084 :
1085 : /* In case of a collision, both RHS have to be identical and have the
1086 : same VUSE operands. */
1087 10618332 : if (hashable_expr_equal_p (expr1, expr2)
1088 10618332 : && types_compatible_p (expr1->type, expr2->type))
1089 : return true;
1090 :
1091 : return false;
1092 : }
1093 :
1094 : /* Given a conditional expression COND as a tree, initialize
1095 : a hashable_expr expression EXPR. The conditional must be a
1096 : comparison or logical negation. A constant or a variable is
1097 : not permitted. */
1098 :
1099 : void
1100 65380490 : initialize_expr_from_cond (tree cond, struct hashable_expr *expr)
1101 : {
1102 65380490 : expr->type = boolean_type_node;
1103 :
1104 65380490 : if (COMPARISON_CLASS_P (cond))
1105 : {
1106 65173064 : expr->kind = EXPR_BINARY;
1107 65173064 : expr->ops.binary.op = TREE_CODE (cond);
1108 65173064 : expr->ops.binary.opnd0 = TREE_OPERAND (cond, 0);
1109 65173064 : expr->ops.binary.opnd1 = TREE_OPERAND (cond, 1);
1110 : }
1111 207426 : else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
1112 : {
1113 207426 : expr->kind = EXPR_UNARY;
1114 207426 : expr->ops.unary.op = TRUTH_NOT_EXPR;
1115 207426 : expr->ops.unary.opnd = TREE_OPERAND (cond, 0);
1116 : }
1117 : else
1118 0 : gcc_unreachable ();
1119 65380490 : }
1120 :
1121 : /* Build a cond_equivalence record indicating that the comparison
1122 : CODE holds between operands OP0 and OP1 and push it to **P. */
1123 :
1124 : static void
1125 37492003 : build_and_record_new_cond (enum tree_code code,
1126 : tree op0, tree op1,
1127 : vec<cond_equivalence> *p,
1128 : bool val = true)
1129 : {
1130 37492003 : cond_equivalence c;
1131 37492003 : struct hashable_expr *cond = &c.cond;
1132 :
1133 37492003 : gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
1134 :
1135 37492003 : cond->type = boolean_type_node;
1136 37492003 : cond->kind = EXPR_BINARY;
1137 37492003 : cond->ops.binary.op = code;
1138 37492003 : cond->ops.binary.opnd0 = op0;
1139 37492003 : cond->ops.binary.opnd1 = op1;
1140 :
1141 37492003 : c.value = val ? boolean_true_node : boolean_false_node;
1142 37492003 : p->safe_push (c);
1143 37492003 : }
1144 :
1145 : /* Record that COND is true and INVERTED is false into the edge information
1146 : structure. Also record that any conditions dominated by COND are true
1147 : as well.
1148 :
1149 : For example, if a < b is true, then a <= b must also be true. */
1150 :
1151 : void
1152 32942736 : record_conditions (vec<cond_equivalence> *p, tree cond, tree inverted)
1153 : {
1154 32942736 : tree op0, op1;
1155 32942736 : cond_equivalence c;
1156 :
1157 32942736 : if (!COMPARISON_CLASS_P (cond))
1158 252491 : return;
1159 :
1160 32690245 : op0 = TREE_OPERAND (cond, 0);
1161 32690245 : op1 = TREE_OPERAND (cond, 1);
1162 :
1163 32690245 : switch (TREE_CODE (cond))
1164 : {
1165 4310651 : case LT_EXPR:
1166 4310651 : case GT_EXPR:
1167 4310651 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1168 : {
1169 115073 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1170 115073 : build_and_record_new_cond (LTGT_EXPR, op0, op1, p);
1171 : }
1172 :
1173 7366226 : build_and_record_new_cond ((TREE_CODE (cond) == LT_EXPR
1174 : ? LE_EXPR : GE_EXPR),
1175 : op0, op1, p);
1176 4310651 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1177 4310651 : build_and_record_new_cond (EQ_EXPR, op0, op1, p, false);
1178 4310651 : break;
1179 :
1180 4392816 : case GE_EXPR:
1181 4392816 : case LE_EXPR:
1182 4392816 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1183 : {
1184 55460 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1185 : }
1186 : break;
1187 :
1188 11809558 : case EQ_EXPR:
1189 11809558 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1190 : {
1191 491232 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1192 : }
1193 11809558 : build_and_record_new_cond (LE_EXPR, op0, op1, p);
1194 11809558 : build_and_record_new_cond (GE_EXPR, op0, op1, p);
1195 11809558 : break;
1196 :
1197 21595 : case UNORDERED_EXPR:
1198 21595 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1199 21595 : build_and_record_new_cond (UNLE_EXPR, op0, op1, p);
1200 21595 : build_and_record_new_cond (UNGE_EXPR, op0, op1, p);
1201 21595 : build_and_record_new_cond (UNEQ_EXPR, op0, op1, p);
1202 21595 : build_and_record_new_cond (UNLT_EXPR, op0, op1, p);
1203 21595 : build_and_record_new_cond (UNGT_EXPR, op0, op1, p);
1204 21595 : break;
1205 :
1206 16157 : case UNLT_EXPR:
1207 16157 : case UNGT_EXPR:
1208 28237 : build_and_record_new_cond ((TREE_CODE (cond) == UNLT_EXPR
1209 : ? UNLE_EXPR : UNGE_EXPR),
1210 : op0, op1, p);
1211 16157 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1212 16157 : break;
1213 :
1214 1094 : case UNEQ_EXPR:
1215 1094 : build_and_record_new_cond (UNLE_EXPR, op0, op1, p);
1216 1094 : build_and_record_new_cond (UNGE_EXPR, op0, op1, p);
1217 1094 : break;
1218 :
1219 12 : case LTGT_EXPR:
1220 12 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1221 12 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1222 12 : break;
1223 :
1224 : default:
1225 : break;
1226 : }
1227 :
1228 : /* Now store the original true and false conditions into the first
1229 : two slots. */
1230 32690245 : initialize_expr_from_cond (cond, &c.cond);
1231 32690245 : c.value = boolean_true_node;
1232 32690245 : p->safe_push (c);
1233 :
1234 : /* It is possible for INVERTED to be the negation of a comparison,
1235 : and not a valid RHS or GIMPLE_COND condition. This happens because
1236 : invert_truthvalue may return such an expression when asked to invert
1237 : a floating-point comparison. These comparisons are not assumed to
1238 : obey the trichotomy law. */
1239 32690245 : initialize_expr_from_cond (inverted, &c.cond);
1240 32690245 : c.value = boolean_false_node;
1241 32690245 : p->safe_push (c);
1242 : }
|
