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 64694557 : avail_exprs_stack::pop_to_marker ()
50 : {
51 : /* Remove all the expressions made available in this block. */
52 183374712 : while (m_stack.length () > 0)
53 : {
54 183374712 : std::pair<expr_hash_elt_t, expr_hash_elt_t> victim = m_stack.pop ();
55 183374712 : expr_hash_elt **slot;
56 :
57 183374712 : 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 118680155 : if (dump_file && (dump_flags & TDF_DETAILS))
64 : {
65 3320 : fprintf (dump_file, "<<<< ");
66 3320 : victim.first->print (dump_file);
67 : }
68 :
69 118680155 : slot = m_avail_exprs->find_slot (victim.first, NO_INSERT);
70 118680155 : gcc_assert (slot && *slot == victim.first);
71 118680155 : if (victim.second != NULL)
72 : {
73 4565886 : delete *slot;
74 4565886 : *slot = victim.second;
75 : }
76 : else
77 114114269 : m_avail_exprs->clear_slot (slot);
78 : }
79 64694557 : }
80 :
81 : /* Add <ELT1,ELT2> to the unwinding stack so they can be later removed
82 : from the hash table. */
83 :
84 : void
85 183374712 : avail_exprs_stack::record_expr (class expr_hash_elt *elt1,
86 : class expr_hash_elt *elt2,
87 : char type)
88 : {
89 183374712 : 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 183374712 : m_stack.safe_push (std::pair<expr_hash_elt_t, expr_hash_elt_t> (elt1, elt2));
96 183374712 : }
97 :
98 : /* Helper for walk_non_aliased_vuses. Determine if we arrived at
99 : the desired memory state. */
100 :
101 : static void *
102 19136286 : vuse_eq (ao_ref *, tree vuse1, void *data)
103 : {
104 19136286 : tree vuse2 = (tree) data;
105 19136286 : if (vuse1 == vuse2)
106 543652 : 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 46034066 : avail_exprs_stack::simplify_binary_operation (gimple *stmt,
119 : class expr_hash_elt element)
120 : {
121 46034066 : if (is_gimple_assign (stmt))
122 : {
123 36154656 : struct hashable_expr *expr = element.expr ();
124 36154656 : if (expr->kind == EXPR_BINARY)
125 : {
126 10602822 : enum tree_code code = expr->ops.binary.op;
127 :
128 10602822 : switch (code)
129 : {
130 : /* For these cases, if we know some relationships
131 : between the operands, then we can simplify. */
132 209861 : case MIN_EXPR:
133 209861 : case MAX_EXPR:
134 209861 : {
135 : /* Build a simple equality expr and query the hash table
136 : for it. */
137 209861 : struct hashable_expr expr;
138 209861 : expr.type = boolean_type_node;
139 209861 : expr.kind = EXPR_BINARY;
140 209861 : expr.ops.binary.op = LE_EXPR;
141 209861 : tree rhs1 = gimple_assign_rhs1 (stmt);
142 209861 : tree rhs2 = gimple_assign_rhs2 (stmt);
143 209861 : if (tree_swap_operands_p (rhs1, rhs2))
144 1343 : std::swap (rhs1, rhs2);
145 209861 : expr.ops.binary.opnd0 = rhs1;
146 209861 : expr.ops.binary.opnd1 = rhs2;
147 209861 : class expr_hash_elt element2 (&expr, NULL_TREE);
148 209861 : expr_hash_elt **slot
149 209861 : = 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 209861 : if (slot && *slot && integer_onep ((*slot)->lhs ()))
155 750 : return code == MIN_EXPR ? rhs1 : rhs2;
156 :
157 : /* Try again, this time with GE_EXPR. */
158 209445 : expr.ops.binary.op = GE_EXPR;
159 209445 : class expr_hash_elt element3 (&expr, NULL_TREE);
160 209445 : 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 209445 : if (slot && *slot && integer_onep ((*slot)->lhs ()))
166 503 : return code == MIN_EXPR ? rhs2 : rhs1;
167 :
168 208942 : break;
169 209861 : }
170 :
171 : /* For these cases, if we know the operands
172 : are equal, then we know the result. */
173 2084962 : case BIT_IOR_EXPR:
174 2084962 : case BIT_AND_EXPR:
175 2084962 : case BIT_XOR_EXPR:
176 2084962 : case MINUS_EXPR:
177 2084962 : case TRUNC_DIV_EXPR:
178 2084962 : case CEIL_DIV_EXPR:
179 2084962 : case FLOOR_DIV_EXPR:
180 2084962 : case ROUND_DIV_EXPR:
181 2084962 : case EXACT_DIV_EXPR:
182 2084962 : case TRUNC_MOD_EXPR:
183 2084962 : case CEIL_MOD_EXPR:
184 2084962 : case FLOOR_MOD_EXPR:
185 2084962 : case ROUND_MOD_EXPR:
186 2084962 : {
187 : /* Build a simple equality expr and query the hash table
188 : for it. */
189 2084962 : struct hashable_expr expr;
190 2084962 : expr.type = boolean_type_node;
191 2084962 : expr.kind = EXPR_BINARY;
192 2084962 : expr.ops.binary.op = EQ_EXPR;
193 2084962 : tree rhs1 = gimple_assign_rhs1 (stmt);
194 2084962 : tree rhs2 = gimple_assign_rhs2 (stmt);
195 2084962 : if (tree_swap_operands_p (rhs1, rhs2))
196 374865 : std::swap (rhs1, rhs2);
197 2084962 : expr.ops.binary.opnd0 = rhs1;
198 2084962 : expr.ops.binary.opnd1 = rhs2;
199 2084962 : class expr_hash_elt element2 (&expr, NULL_TREE);
200 2084962 : expr_hash_elt **slot
201 2084962 : = m_avail_exprs->find_slot (&element2, NO_INSERT);
202 2084962 : 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 2084962 : 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 2084798 : break;
248 2084962 : }
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 122074188 : avail_exprs_stack::lookup_avail_expr (gimple *stmt, bool insert, bool tbaa_p,
268 : expr_hash_elt **elt)
269 : {
270 122074188 : expr_hash_elt **slot;
271 122074188 : tree lhs;
272 :
273 : /* Get LHS of phi, assignment, or call; else NULL_TREE. */
274 122074188 : if (gimple_code (stmt) == GIMPLE_PHI)
275 8803115 : lhs = gimple_phi_result (stmt);
276 : else
277 113271073 : lhs = gimple_get_lhs (stmt);
278 :
279 122074188 : class expr_hash_elt element (stmt, lhs);
280 :
281 122074188 : 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 122074188 : if (element.expr()->kind == EXPR_SINGLE
291 122074188 : && (TREE_CODE (element.expr()->ops.single.rhs) == SSA_NAME
292 55406097 : || is_gimple_min_invariant (element.expr()->ops.single.rhs)))
293 13426591 : return NULL_TREE;
294 :
295 : /* Finally try to find the expression in the main expression hash table. */
296 166263561 : slot = m_avail_exprs->find_slot (&element, (insert ? INSERT : NO_INSERT));
297 108647597 : if (slot == NULL)
298 : {
299 : return NULL_TREE;
300 : }
301 55901218 : 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 46034066 : class expr_hash_elt *element2 = new expr_hash_elt (element);
314 46034066 : *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 46034066 : tree retval = avail_exprs_stack::simplify_binary_operation (stmt,
319 : element);
320 :
321 46034066 : record_expr (element2, NULL, '2');
322 46034066 : 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 19531164 : if (gimple_vuse (stmt) != (*slot)->vop ())
328 : {
329 8266110 : tree vuse1 = (*slot)->vop ();
330 8266110 : 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 8266110 : ao_ref ref;
336 8266110 : unsigned limit = param_sccvn_max_alias_queries_per_access;
337 15596783 : if (!(vuse1 && vuse2
338 8266110 : && gimple_assign_single_p (stmt)
339 8147791 : && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
340 7330673 : && (ao_ref_init (&ref, gimple_assign_rhs1 (stmt)),
341 7330673 : ref.base_alias_set = ref.ref_alias_set = tbaa_p ? -1 : 0, true)
342 7330673 : && walk_non_aliased_vuses (&ref, vuse2, true, vuse_eq, NULL, NULL,
343 : NULL, limit, vuse1) != NULL))
344 : {
345 7722458 : if (insert)
346 : {
347 4565886 : 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 4565886 : record_expr (element2, *slot, '2');
353 4565886 : *slot = element2;
354 : }
355 7722458 : 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 2144694 : lhs = (*slot)->lhs ();
362 2144694 : if (elt)
363 841329 : *elt = *slot;
364 :
365 : /* Valueize the result. */
366 2144694 : if (TREE_CODE (lhs) == SSA_NAME)
367 : {
368 1840452 : tree tem = SSA_NAME_VALUE (lhs);
369 1559892 : if (tem)
370 2144694 : lhs = tem;
371 : }
372 :
373 2144694 : 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 122074188 : }
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 68573662 : avail_exprs_stack::record_cond (cond_equivalence *p)
390 : {
391 68573662 : class expr_hash_elt *element = new expr_hash_elt (&p->cond, p->value);
392 68573662 : expr_hash_elt **slot;
393 :
394 68573662 : slot = m_avail_exprs->find_slot_with_hash (element, element->hash (), INSERT);
395 68573662 : if (*slot == NULL)
396 : {
397 68080203 : *slot = element;
398 68080203 : record_expr (element, NULL, '1');
399 : }
400 : else
401 493459 : delete element;
402 68573662 : }
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 67001023 : add_expr_commutative (const_tree t1, const_tree t2, hash &hstate)
416 : {
417 67001023 : hash one, two;
418 :
419 67001023 : inchash::add_expr (t1, one);
420 67001023 : inchash::add_expr (t2, two);
421 67001023 : hstate.add_commutative (one, two);
422 67001023 : }
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 153155821 : add_hashable_expr (const struct hashable_expr *expr, hash &hstate)
432 : {
433 153155821 : switch (expr->kind)
434 : {
435 21934395 : case EXPR_SINGLE:
436 21934395 : inchash::add_expr (expr->ops.single.rhs, hstate);
437 21934395 : break;
438 :
439 8161464 : case EXPR_UNARY:
440 8161464 : 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 8161464 : if (CONVERT_EXPR_CODE_P (expr->ops.unary.op)
447 959089 : || expr->ops.unary.op == NON_LVALUE_EXPR)
448 7202375 : hstate.add_int (TYPE_UNSIGNED (expr->type));
449 :
450 8161464 : inchash::add_expr (expr->ops.unary.opnd, hstate);
451 8161464 : break;
452 :
453 111005967 : case EXPR_BINARY:
454 111005967 : hstate.add_object (expr->ops.binary.op);
455 111005967 : if (commutative_tree_code (expr->ops.binary.op))
456 67000273 : inchash::add_expr_commutative (expr->ops.binary.opnd0,
457 67000273 : expr->ops.binary.opnd1, hstate);
458 : else
459 : {
460 44005694 : inchash::add_expr (expr->ops.binary.opnd0, hstate);
461 44005694 : inchash::add_expr (expr->ops.binary.opnd1, hstate);
462 : }
463 : break;
464 :
465 229981 : case EXPR_TERNARY:
466 229981 : hstate.add_object (expr->ops.ternary.op);
467 229981 : 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 229231 : inchash::add_expr (expr->ops.ternary.opnd0, hstate);
473 229231 : inchash::add_expr (expr->ops.ternary.opnd1, hstate);
474 : }
475 229981 : inchash::add_expr (expr->ops.ternary.opnd2, hstate);
476 229981 : break;
477 :
478 3020899 : case EXPR_CALL:
479 3020899 : {
480 3020899 : size_t i;
481 3020899 : enum tree_code code = CALL_EXPR;
482 3020899 : gcall *fn_from;
483 :
484 3020899 : hstate.add_object (code);
485 3020899 : fn_from = expr->ops.call.fn_from;
486 3020899 : if (gimple_call_internal_p (fn_from))
487 270943 : hstate.merge_hash ((hashval_t) gimple_call_internal_fn (fn_from));
488 : else
489 2749956 : inchash::add_expr (gimple_call_fn (fn_from), hstate);
490 8926313 : for (i = 0; i < expr->ops.call.nargs; i++)
491 5905414 : inchash::add_expr (expr->ops.call.args[i], hstate);
492 : }
493 3020899 : break;
494 :
495 : case EXPR_PHI:
496 : {
497 : size_t i;
498 :
499 31682024 : for (i = 0; i < expr->ops.phi.nargs; i++)
500 22878909 : inchash::add_expr (expr->ops.phi.args[i], hstate);
501 : }
502 : break;
503 :
504 0 : default:
505 0 : gcc_unreachable ();
506 : }
507 153155821 : }
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 193152118 : avail_expr_hash (class expr_hash_elt *p)
516 : {
517 193152118 : const struct hashable_expr *expr = p->expr ();
518 193152118 : inchash::hash hstate;
519 :
520 193152118 : if (expr->kind == EXPR_SINGLE)
521 : {
522 : /* T could potentially be a switch index or a goto dest. */
523 61930692 : tree t = expr->ops.single.rhs;
524 61930692 : 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 41314017 : bool reverse;
530 41314017 : poly_int64 offset, size, max_size;
531 41314017 : 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 41314017 : if (known_size_p (max_size)
536 41314017 : && known_eq (size, max_size))
537 : {
538 39996297 : enum tree_code code = MEM_REF;
539 39996297 : hstate.add_object (code);
540 39996297 : inchash::add_expr (base, hstate,
541 39996297 : TREE_CODE (base) == MEM_REF
542 : ? OEP_ADDRESS_OF : 0);
543 39996297 : hstate.add_object (offset);
544 39996297 : hstate.add_object (size);
545 39996297 : return hstate.end ();
546 : }
547 : }
548 : }
549 :
550 153155821 : inchash::add_hashable_expr (expr, hstate);
551 :
552 153155821 : 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 9097816 : equal_mem_array_ref_p (tree t0, tree t1)
563 : {
564 9097816 : if (TREE_CODE (t0) != MEM_REF && ! handled_component_p (t0))
565 : return false;
566 9231635 : if (TREE_CODE (t1) != MEM_REF && ! handled_component_p (t1))
567 : return false;
568 :
569 7826647 : if (!types_compatible_p (TREE_TYPE (t0), TREE_TYPE (t1)))
570 : return false;
571 7822657 : bool rev0;
572 7822657 : poly_int64 off0, sz0, max0;
573 7822657 : tree base0 = get_ref_base_and_extent (t0, &off0, &sz0, &max0, &rev0);
574 7822657 : if (!known_size_p (max0)
575 7822657 : || maybe_ne (sz0, max0))
576 : return false;
577 :
578 7692828 : bool rev1;
579 7692828 : poly_int64 off1, sz1, max1;
580 7692828 : tree base1 = get_ref_base_and_extent (t1, &off1, &sz1, &max1, &rev1);
581 7692828 : if (!known_size_p (max1)
582 7692828 : || maybe_ne (sz1, max1))
583 : return false;
584 :
585 7692828 : if (rev0 != rev1 || maybe_ne (sz0, sz1) || maybe_ne (off0, off1))
586 : return false;
587 :
588 7692828 : return operand_equal_p (base0, base1,
589 7692828 : (TREE_CODE (base0) == MEM_REF
590 7692828 : || TREE_CODE (base0) == TARGET_MEM_REF)
591 2724464 : && (TREE_CODE (base1) == MEM_REF
592 2724464 : || TREE_CODE (base1) == TARGET_MEM_REF)
593 7692828 : ? 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 10675815 : hashable_expr_equal_p (const struct hashable_expr *expr0,
603 : const struct hashable_expr *expr1)
604 : {
605 10675815 : tree type0 = expr0->type;
606 10675815 : tree type1 = expr1->type;
607 :
608 : /* If either type is NULL, there is nothing to check. */
609 10675815 : 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 10675815 : if (type0 != type1
615 10675815 : && (TREE_CODE (type0) == ERROR_MARK
616 1447968 : || TREE_CODE (type1) == ERROR_MARK
617 1447968 : || TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1)
618 1384412 : || element_precision (type0) != element_precision (type1)
619 1275379 : || TYPE_MODE (type0) != TYPE_MODE (type1)))
620 251197 : return false;
621 :
622 10424618 : if (expr0->kind != expr1->kind)
623 : return false;
624 :
625 10424618 : switch (expr0->kind)
626 : {
627 9097816 : case EXPR_SINGLE:
628 9097816 : return equal_mem_array_ref_p (expr0->ops.single.rhs,
629 9097816 : expr1->ops.single.rhs)
630 10505750 : || operand_equal_p (expr0->ops.single.rhs,
631 1407934 : expr1->ops.single.rhs, 0);
632 204260 : case EXPR_UNARY:
633 204260 : if (expr0->ops.unary.op != expr1->ops.unary.op)
634 : return false;
635 :
636 16232 : if ((CONVERT_EXPR_CODE_P (expr0->ops.unary.op)
637 16232 : || expr0->ops.unary.op == NON_LVALUE_EXPR)
638 204260 : && TYPE_UNSIGNED (expr0->type) != TYPE_UNSIGNED (expr1->type))
639 : return false;
640 :
641 204260 : return operand_equal_p (expr0->ops.unary.opnd,
642 204260 : expr1->ops.unary.opnd, 0);
643 :
644 966971 : case EXPR_BINARY:
645 966971 : if (expr0->ops.binary.op != expr1->ops.binary.op)
646 : return false;
647 :
648 966965 : if (operand_equal_p (expr0->ops.binary.opnd0,
649 966965 : expr1->ops.binary.opnd0, 0)
650 1918394 : && operand_equal_p (expr0->ops.binary.opnd1,
651 951429 : expr1->ops.binary.opnd1, 0))
652 : return true;
653 :
654 : /* For commutative ops, allow the other order. */
655 18794 : return (commutative_tree_code (expr0->ops.binary.op)
656 16257 : && operand_equal_p (expr0->ops.binary.opnd0,
657 16257 : expr1->ops.binary.opnd1, 0)
658 25527 : && operand_equal_p (expr0->ops.binary.opnd1,
659 6733 : 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 129655 : case EXPR_CALL:
690 129655 : {
691 129655 : size_t i;
692 :
693 : /* If the calls are to different functions, then they
694 : clearly cannot be equal. */
695 129655 : if (!gimple_call_same_target_p (expr0->ops.call.fn_from,
696 129655 : expr1->ops.call.fn_from))
697 : return false;
698 :
699 129031 : if (! expr0->ops.call.pure)
700 : return false;
701 :
702 129031 : if (expr0->ops.call.nargs != expr1->ops.call.nargs)
703 : return false;
704 :
705 371579 : for (i = 0; i < expr0->ops.call.nargs; i++)
706 242610 : if (! operand_equal_p (expr0->ops.call.args[i],
707 242610 : expr1->ops.call.args[i], 0))
708 : return false;
709 :
710 128969 : 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 24957 : case EXPR_PHI:
722 24957 : {
723 24957 : size_t i;
724 :
725 24957 : if (expr0->ops.phi.nargs != expr1->ops.phi.nargs)
726 : return false;
727 :
728 62847 : for (i = 0; i < expr0->ops.phi.nargs; i++)
729 37956 : if (! operand_equal_p (expr0->ops.phi.args[i],
730 37956 : 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 122074188 : expr_hash_elt::expr_hash_elt (gimple *stmt, tree orig_lhs)
744 : {
745 122074188 : enum gimple_code code = gimple_code (stmt);
746 122074188 : struct hashable_expr *expr = this->expr ();
747 :
748 122074188 : if (code == GIMPLE_ASSIGN)
749 : {
750 90603816 : enum tree_code subcode = gimple_assign_rhs_code (stmt);
751 :
752 90603816 : switch (get_gimple_rhs_class (subcode))
753 : {
754 61867547 : case GIMPLE_SINGLE_RHS:
755 61867547 : expr->kind = EXPR_SINGLE;
756 61867547 : expr->type = TREE_TYPE (gimple_assign_rhs1 (stmt));
757 61867547 : expr->ops.single.rhs = gimple_assign_rhs1 (stmt);
758 61867547 : break;
759 8038037 : case GIMPLE_UNARY_RHS:
760 8038037 : expr->kind = EXPR_UNARY;
761 8038037 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
762 8038037 : if (CONVERT_EXPR_CODE_P (subcode))
763 7202375 : subcode = NOP_EXPR;
764 8038037 : expr->ops.unary.op = subcode;
765 8038037 : expr->ops.unary.opnd = gimple_assign_rhs1 (stmt);
766 8038037 : break;
767 20468251 : case GIMPLE_BINARY_RHS:
768 20468251 : expr->kind = EXPR_BINARY;
769 20468251 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
770 20468251 : expr->ops.binary.op = subcode;
771 20468251 : expr->ops.binary.opnd0 = gimple_assign_rhs1 (stmt);
772 20468251 : expr->ops.binary.opnd1 = gimple_assign_rhs2 (stmt);
773 20468251 : break;
774 229981 : case GIMPLE_TERNARY_RHS:
775 229981 : expr->kind = EXPR_TERNARY;
776 229981 : expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
777 229981 : expr->ops.ternary.op = subcode;
778 229981 : expr->ops.ternary.opnd0 = gimple_assign_rhs1 (stmt);
779 229981 : expr->ops.ternary.opnd1 = gimple_assign_rhs2 (stmt);
780 229981 : expr->ops.ternary.opnd2 = gimple_assign_rhs3 (stmt);
781 229981 : break;
782 0 : default:
783 0 : gcc_unreachable ();
784 : }
785 : }
786 : else if (code == GIMPLE_COND)
787 : {
788 19583213 : expr->type = boolean_type_node;
789 19583213 : expr->kind = EXPR_BINARY;
790 19583213 : expr->ops.binary.op = gimple_cond_code (stmt);
791 19583213 : expr->ops.binary.opnd0 = gimple_cond_lhs (stmt);
792 19583213 : expr->ops.binary.opnd1 = gimple_cond_rhs (stmt);
793 : }
794 3020899 : else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
795 : {
796 3020899 : size_t nargs = gimple_call_num_args (call_stmt);
797 3020899 : size_t i;
798 :
799 3020899 : gcc_assert (gimple_call_lhs (call_stmt));
800 :
801 3020899 : expr->type = TREE_TYPE (gimple_call_lhs (call_stmt));
802 3020899 : expr->kind = EXPR_CALL;
803 3020899 : expr->ops.call.fn_from = call_stmt;
804 :
805 3020899 : if (gimple_call_flags (call_stmt) & (ECF_CONST | ECF_PURE))
806 1564388 : expr->ops.call.pure = true;
807 : else
808 1456511 : expr->ops.call.pure = false;
809 :
810 3020899 : expr->ops.call.nargs = nargs;
811 3020899 : expr->ops.call.args = XCNEWVEC (tree, nargs);
812 8926313 : for (i = 0; i < nargs; i++)
813 5905414 : expr->ops.call.args[i] = gimple_call_arg (call_stmt, i);
814 : }
815 62916 : else if (gswitch *swtch_stmt = dyn_cast <gswitch *> (stmt))
816 : {
817 62916 : expr->type = TREE_TYPE (gimple_switch_index (swtch_stmt));
818 62916 : expr->kind = EXPR_SINGLE;
819 62916 : 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 8803115 : size_t nargs = gimple_phi_num_args (stmt);
830 8803115 : size_t i;
831 :
832 8803115 : expr->type = TREE_TYPE (gimple_phi_result (stmt));
833 8803115 : expr->kind = EXPR_PHI;
834 8803115 : expr->ops.phi.nargs = nargs;
835 8803115 : expr->ops.phi.args = XCNEWVEC (tree, nargs);
836 31682024 : for (i = 0; i < nargs; i++)
837 22878909 : expr->ops.phi.args[i] = gimple_phi_arg_def (stmt, i);
838 : }
839 : else
840 0 : gcc_unreachable ();
841 :
842 122074188 : m_lhs = orig_lhs;
843 122074188 : m_vop = gimple_vuse (stmt);
844 122074188 : m_hash = avail_expr_hash (this);
845 122074188 : m_stamp = this;
846 122074188 : }
847 :
848 : /* Given a hashable_expr expression ORIG and an ORIG_LHS,
849 : construct a hash table element. */
850 :
851 71077930 : expr_hash_elt::expr_hash_elt (struct hashable_expr *orig, tree orig_lhs)
852 : {
853 71077930 : m_expr = *orig;
854 71077930 : m_lhs = orig_lhs;
855 71077930 : m_vop = NULL_TREE;
856 71077930 : m_hash = avail_expr_hash (this);
857 71077930 : m_stamp = this;
858 71077930 : }
859 :
860 : /* Copy constructor for a hash table element. */
861 :
862 96634018 : expr_hash_elt::expr_hash_elt (class expr_hash_elt &old_elt)
863 : {
864 96634018 : m_expr = old_elt.m_expr;
865 96634018 : m_lhs = old_elt.m_lhs;
866 96634018 : m_vop = old_elt.m_vop;
867 96634018 : m_hash = old_elt.m_hash;
868 96634018 : m_stamp = this;
869 :
870 : /* Now deep copy the malloc'd space for CALL and PHI args. */
871 96634018 : if (old_elt.m_expr.kind == EXPR_CALL)
872 : {
873 2303471 : size_t nargs = old_elt.m_expr.ops.call.nargs;
874 2303471 : size_t i;
875 :
876 2303471 : m_expr.ops.call.args = XCNEWVEC (tree, nargs);
877 7335503 : for (i = 0; i < nargs; i++)
878 5032032 : m_expr.ops.call.args[i] = old_elt.m_expr.ops.call.args[i];
879 : }
880 94330547 : else if (old_elt.m_expr.kind == EXPR_PHI)
881 : {
882 17544632 : size_t nargs = old_elt.m_expr.ops.phi.nargs;
883 17544632 : size_t i;
884 :
885 17544632 : m_expr.ops.phi.args = XCNEWVEC (tree, nargs);
886 63184954 : for (i = 0; i < nargs; i++)
887 45640322 : m_expr.ops.phi.args[i] = old_elt.m_expr.ops.phi.args[i];
888 : }
889 96634018 : }
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 289786136 : expr_hash_elt::~expr_hash_elt ()
895 : {
896 289786136 : if (m_expr.kind == EXPR_CALL)
897 5324370 : free (m_expr.ops.call.args);
898 284461766 : else if (m_expr.kind == EXPR_PHI)
899 26347747 : free (m_expr.ops.phi.args);
900 289786136 : }
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 259 : case EXPR_UNARY:
922 259 : fprintf (stream, "%s ", get_tree_code_name (m_expr.ops.unary.op));
923 259 : print_generic_expr (stream, m_expr.ops.unary.opnd);
924 259 : break;
925 :
926 5953 : case EXPR_BINARY:
927 5953 : print_generic_expr (stream, m_expr.ops.binary.opnd0);
928 5953 : fprintf (stream, " %s ", get_tree_code_name (m_expr.ops.binary.op));
929 5953 : print_generic_expr (stream, m_expr.ops.binary.opnd1);
930 5953 : 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 54323189 : const_and_copies::pop_to_marker (void)
997 : {
998 92572778 : while (m_stack.length () > 0)
999 : {
1000 92572778 : tree prev_value, dest;
1001 :
1002 92572778 : 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 92572778 : if (dest == NULL)
1007 : break;
1008 :
1009 38249589 : 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 38249589 : prev_value = m_stack.pop ();
1019 38249589 : set_ssa_name_value (dest, prev_value);
1020 : }
1021 54323189 : }
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 38249589 : const_and_copies::record_const_or_copy_raw (tree x, tree y, tree prev_x)
1029 : {
1030 38249589 : 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 38249589 : set_ssa_name_value (x, y);
1040 38249589 : m_stack.reserve (2);
1041 38249589 : m_stack.quick_push (prev_x);
1042 38249589 : m_stack.quick_push (x);
1043 38249589 : }
1044 :
1045 : /* Record that X has the value Y. */
1046 :
1047 : void
1048 24649297 : const_and_copies::record_const_or_copy (tree x, tree y)
1049 : {
1050 24649297 : record_const_or_copy (x, y, SSA_NAME_VALUE (x));
1051 24649297 : }
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 38249589 : 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 38249589 : if (y && TREE_CODE (y) == SSA_NAME)
1062 : {
1063 16786228 : tree tmp = SSA_NAME_VALUE (y);
1064 15200356 : y = tmp ? tmp : y;
1065 : }
1066 :
1067 38249589 : record_const_or_copy_raw (x, y, prev_x);
1068 38249589 : }
1069 :
1070 : bool
1071 263060205 : expr_elt_hasher::equal (const value_type &p1, const compare_type &p2)
1072 : {
1073 263060205 : const struct hashable_expr *expr1 = p1->expr ();
1074 263060205 : const class expr_hash_elt *stamp1 = p1->stamp ();
1075 263060205 : const struct hashable_expr *expr2 = p2->expr ();
1076 263060205 : const class expr_hash_elt *stamp2 = p2->stamp ();
1077 :
1078 : /* This case should apply only when removing entries from the table. */
1079 263060205 : if (stamp1 == stamp2)
1080 : return true;
1081 :
1082 144380050 : 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 10675815 : if (hashable_expr_equal_p (expr1, expr2)
1088 10675815 : && 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 66031682 : initialize_expr_from_cond (tree cond, struct hashable_expr *expr)
1101 : {
1102 66031682 : expr->type = boolean_type_node;
1103 :
1104 66031682 : if (COMPARISON_CLASS_P (cond))
1105 : {
1106 65823573 : expr->kind = EXPR_BINARY;
1107 65823573 : expr->ops.binary.op = TREE_CODE (cond);
1108 65823573 : expr->ops.binary.opnd0 = TREE_OPERAND (cond, 0);
1109 65823573 : expr->ops.binary.opnd1 = TREE_OPERAND (cond, 1);
1110 : }
1111 208109 : else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
1112 : {
1113 208109 : expr->kind = EXPR_UNARY;
1114 208109 : expr->ops.unary.op = TRUTH_NOT_EXPR;
1115 208109 : expr->ops.unary.opnd = TREE_OPERAND (cond, 0);
1116 : }
1117 : else
1118 0 : gcc_unreachable ();
1119 66031682 : }
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 37880968 : 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 37880968 : cond_equivalence c;
1131 37880968 : struct hashable_expr *cond = &c.cond;
1132 :
1133 37880968 : gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
1134 :
1135 37880968 : cond->type = boolean_type_node;
1136 37880968 : cond->kind = EXPR_BINARY;
1137 37880968 : cond->ops.binary.op = code;
1138 37880968 : cond->ops.binary.opnd0 = op0;
1139 37880968 : cond->ops.binary.opnd1 = op1;
1140 :
1141 37880968 : c.value = val ? boolean_true_node : boolean_false_node;
1142 37880968 : p->safe_push (c);
1143 37880968 : }
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 33269015 : record_conditions (vec<cond_equivalence> *p, tree cond, tree inverted)
1153 : {
1154 33269015 : tree op0, op1;
1155 33269015 : cond_equivalence c;
1156 :
1157 33269015 : if (!COMPARISON_CLASS_P (cond))
1158 253174 : return;
1159 :
1160 33015841 : op0 = TREE_OPERAND (cond, 0);
1161 33015841 : op1 = TREE_OPERAND (cond, 1);
1162 :
1163 33015841 : switch (TREE_CODE (cond))
1164 : {
1165 4374581 : case LT_EXPR:
1166 4374581 : case GT_EXPR:
1167 4374581 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1168 : {
1169 115684 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1170 115684 : build_and_record_new_cond (LTGT_EXPR, op0, op1, p);
1171 : }
1172 :
1173 7493363 : build_and_record_new_cond ((TREE_CODE (cond) == LT_EXPR
1174 : ? LE_EXPR : GE_EXPR),
1175 : op0, op1, p);
1176 4374581 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1177 4374581 : build_and_record_new_cond (EQ_EXPR, op0, op1, p, false);
1178 4374581 : break;
1179 :
1180 4456468 : case GE_EXPR:
1181 4456468 : case LE_EXPR:
1182 4456468 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1183 : {
1184 55409 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1185 : }
1186 : break;
1187 :
1188 11907175 : case EQ_EXPR:
1189 11907175 : if (FLOAT_TYPE_P (TREE_TYPE (op0)))
1190 : {
1191 489850 : build_and_record_new_cond (ORDERED_EXPR, op0, op1, p);
1192 : }
1193 11907175 : build_and_record_new_cond (LE_EXPR, op0, op1, p);
1194 11907175 : build_and_record_new_cond (GE_EXPR, op0, op1, p);
1195 11907175 : break;
1196 :
1197 22067 : case UNORDERED_EXPR:
1198 22067 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1199 22067 : build_and_record_new_cond (UNLE_EXPR, op0, op1, p);
1200 22067 : build_and_record_new_cond (UNGE_EXPR, op0, op1, p);
1201 22067 : build_and_record_new_cond (UNEQ_EXPR, op0, op1, p);
1202 22067 : build_and_record_new_cond (UNLT_EXPR, op0, op1, p);
1203 22067 : build_and_record_new_cond (UNGT_EXPR, op0, op1, p);
1204 22067 : break;
1205 :
1206 15817 : case UNLT_EXPR:
1207 15817 : case UNGT_EXPR:
1208 27739 : build_and_record_new_cond ((TREE_CODE (cond) == UNLT_EXPR
1209 : ? UNLE_EXPR : UNGE_EXPR),
1210 : op0, op1, p);
1211 15817 : build_and_record_new_cond (NE_EXPR, op0, op1, p);
1212 15817 : 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 33015841 : initialize_expr_from_cond (cond, &c.cond);
1231 33015841 : c.value = boolean_true_node;
1232 33015841 : 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 33015841 : initialize_expr_from_cond (inverted, &c.cond);
1240 33015841 : c.value = boolean_false_node;
1241 33015841 : p->safe_push (c);
1242 : }
|
