1 /* Conditional constant propagation pass for the GNU compiler.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
5 Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 GCC is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Conditional constant propagation (CCP) is based on the SSA
24 propagation engine (tree-ssa-propagate.c). Constant assignments of
25 the form VAR = CST are propagated from the assignments into uses of
26 VAR, which in turn may generate new constants. The simulation uses
27 a four level lattice to keep track of constant values associated
28 with SSA names. Given an SSA name V_i, it may take one of the
31 UNINITIALIZED -> the initial state of the value. This value
32 is replaced with a correct initial value
33 the first time the value is used, so the
34 rest of the pass does not need to care about
35 it. Using this value simplifies initialization
36 of the pass, and prevents us from needlessly
37 scanning statements that are never reached.
39 UNDEFINED -> V_i is a local variable whose definition
40 has not been processed yet. Therefore we
41 don't yet know if its value is a constant
44 CONSTANT -> V_i has been found to hold a constant
47 VARYING -> V_i cannot take a constant value, or if it
48 does, it is not possible to determine it
51 The core of SSA-CCP is in ccp_visit_stmt and ccp_visit_phi_node:
53 1- In ccp_visit_stmt, we are interested in assignments whose RHS
54 evaluates into a constant and conditional jumps whose predicate
55 evaluates into a boolean true or false. When an assignment of
56 the form V_i = CONST is found, V_i's lattice value is set to
57 CONSTANT and CONST is associated with it. This causes the
58 propagation engine to add all the SSA edges coming out the
59 assignment into the worklists, so that statements that use V_i
62 If the statement is a conditional with a constant predicate, we
63 mark the outgoing edges as executable or not executable
64 depending on the predicate's value. This is then used when
65 visiting PHI nodes to know when a PHI argument can be ignored.
68 2- In ccp_visit_phi_node, if all the PHI arguments evaluate to the
69 same constant C, then the LHS of the PHI is set to C. This
70 evaluation is known as the "meet operation". Since one of the
71 goals of this evaluation is to optimistically return constant
72 values as often as possible, it uses two main short cuts:
74 - If an argument is flowing in through a non-executable edge, it
75 is ignored. This is useful in cases like this:
81 a_11 = PHI (a_9, a_10)
83 If PRED is known to always evaluate to false, then we can
84 assume that a_11 will always take its value from a_10, meaning
85 that instead of consider it VARYING (a_9 and a_10 have
86 different values), we can consider it CONSTANT 100.
88 - If an argument has an UNDEFINED value, then it does not affect
89 the outcome of the meet operation. If a variable V_i has an
90 UNDEFINED value, it means that either its defining statement
91 hasn't been visited yet or V_i has no defining statement, in
92 which case the original symbol 'V' is being used
93 uninitialized. Since 'V' is a local variable, the compiler
94 may assume any initial value for it.
97 After propagation, every variable V_i that ends up with a lattice
98 value of CONSTANT will have the associated constant value in the
99 array CONST_VAL[i].VALUE. That is fed into substitute_and_fold for
100 final substitution and folding.
103 Constant propagation in stores and loads (STORE-CCP)
104 ----------------------------------------------------
106 While CCP has all the logic to propagate constants in GIMPLE
107 registers, it is missing the ability to associate constants with
108 stores and loads (i.e., pointer dereferences, structures and
109 global/aliased variables). We don't keep loads and stores in
110 SSA, but we do build a factored use-def web for them (in the
113 For instance, consider the following code fragment:
132 We should be able to deduce that the predicate 'a.a != B' is always
133 false. To achieve this, we associate constant values to the SSA
134 names in the VDEF operands for each store. Additionally,
135 since we also glob partial loads/stores with the base symbol, we
136 also keep track of the memory reference where the constant value
137 was stored (in the MEM_REF field of PROP_VALUE_T). For instance,
145 In the example above, CCP will associate value '2' with 'a_5', but
146 it would be wrong to replace the load from 'a.b' with '2', because
147 '2' had been stored into a.a.
149 Note that the initial value of virtual operands is VARYING, not
150 UNDEFINED. Consider, for instance global variables:
158 # A_5 = PHI (A_4, A_2);
166 The value of A_2 cannot be assumed to be UNDEFINED, as it may have
167 been defined outside of foo. If we were to assume it UNDEFINED, we
168 would erroneously optimize the above into 'return 3;'.
170 Though STORE-CCP is not too expensive, it does have to do more work
171 than regular CCP, so it is only enabled at -O2. Both regular CCP
172 and STORE-CCP use the exact same algorithm. The only distinction
173 is that when doing STORE-CCP, the boolean variable DO_STORE_CCP is
174 set to true. This affects the evaluation of statements and PHI
179 Constant propagation with conditional branches,
180 Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
182 Building an Optimizing Compiler,
183 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
185 Advanced Compiler Design and Implementation,
186 Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
190 #include "coretypes.h"
197 #include "basic-block.h"
200 #include "function.h"
201 #include "diagnostic.h"
203 #include "tree-dump.h"
204 #include "tree-flow.h"
205 #include "tree-pass.h"
206 #include "tree-ssa-propagate.h"
207 #include "value-prof.h"
208 #include "langhooks.h"
214 /* Possible lattice values. */
223 /* Array of propagated constant values. After propagation,
224 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
225 the constant is held in an SSA name representing a memory store
226 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
227 memory reference used to store (i.e., the LHS of the assignment
229 static prop_value_t *const_val;
231 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
234 dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val)
236 switch (val.lattice_val)
239 fprintf (outf, "%sUNINITIALIZED", prefix);
242 fprintf (outf, "%sUNDEFINED", prefix);
245 fprintf (outf, "%sVARYING", prefix);
248 fprintf (outf, "%sCONSTANT ", prefix);
249 print_generic_expr (outf, val.value, dump_flags);
257 /* Print lattice value VAL to stderr. */
259 void debug_lattice_value (prop_value_t val);
262 debug_lattice_value (prop_value_t val)
264 dump_lattice_value (stderr, "", val);
265 fprintf (stderr, "\n");
270 /* If SYM is a constant variable with known value, return the value.
271 NULL_TREE is returned otherwise. */
274 get_symbol_constant_value (tree sym)
276 if (TREE_STATIC (sym)
277 && TREE_READONLY (sym))
279 tree val = DECL_INITIAL (sym);
282 STRIP_USELESS_TYPE_CONVERSION (val);
283 if (is_gimple_min_invariant (val))
286 /* Variables declared 'const' without an initializer
287 have zero as the initializer if they may not be
288 overridden at link or run time. */
290 && !DECL_EXTERNAL (sym)
291 && targetm.binds_local_p (sym)
292 && (INTEGRAL_TYPE_P (TREE_TYPE (sym))
293 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (sym))))
294 return fold_convert (TREE_TYPE (sym), integer_zero_node);
300 /* Compute a default value for variable VAR and store it in the
301 CONST_VAL array. The following rules are used to get default
304 1- Global and static variables that are declared constant are
307 2- Any other value is considered UNDEFINED. This is useful when
308 considering PHI nodes. PHI arguments that are undefined do not
309 change the constant value of the PHI node, which allows for more
310 constants to be propagated.
312 3- Variables defined by statements other than assignments and PHI
313 nodes are considered VARYING.
315 4- Initial values of variables that are not GIMPLE registers are
316 considered VARYING. */
319 get_default_value (tree var)
321 tree sym = SSA_NAME_VAR (var);
322 prop_value_t val = { UNINITIALIZED, NULL_TREE };
325 stmt = SSA_NAME_DEF_STMT (var);
327 if (gimple_nop_p (stmt))
329 /* Variables defined by an empty statement are those used
330 before being initialized. If VAR is a local variable, we
331 can assume initially that it is UNDEFINED, otherwise we must
332 consider it VARYING. */
333 if (is_gimple_reg (sym) && TREE_CODE (sym) != PARM_DECL)
334 val.lattice_val = UNDEFINED;
336 val.lattice_val = VARYING;
338 else if (is_gimple_assign (stmt)
339 /* Value-returning GIMPLE_CALL statements assign to
340 a variable, and are treated similarly to GIMPLE_ASSIGN. */
341 || (is_gimple_call (stmt)
342 && gimple_call_lhs (stmt) != NULL_TREE)
343 || gimple_code (stmt) == GIMPLE_PHI)
346 if (gimple_assign_single_p (stmt)
347 && DECL_P (gimple_assign_rhs1 (stmt))
348 && (cst = get_symbol_constant_value (gimple_assign_rhs1 (stmt))))
350 val.lattice_val = CONSTANT;
354 /* Any other variable defined by an assignment or a PHI node
355 is considered UNDEFINED. */
356 val.lattice_val = UNDEFINED;
360 /* Otherwise, VAR will never take on a constant value. */
361 val.lattice_val = VARYING;
368 /* Get the constant value associated with variable VAR. */
370 static inline prop_value_t *
375 if (const_val == NULL)
378 val = &const_val[SSA_NAME_VERSION (var)];
379 if (val->lattice_val == UNINITIALIZED)
380 *val = get_default_value (var);
385 /* Sets the value associated with VAR to VARYING. */
388 set_value_varying (tree var)
390 prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
392 val->lattice_val = VARYING;
393 val->value = NULL_TREE;
396 /* For float types, modify the value of VAL to make ccp work correctly
397 for non-standard values (-0, NaN):
399 If HONOR_SIGNED_ZEROS is false, and VAL = -0, we canonicalize it to 0.
400 If HONOR_NANS is false, and VAL is NaN, we canonicalize it to UNDEFINED.
401 This is to fix the following problem (see PR 29921): Suppose we have
405 and we set value of y to NaN. This causes value of x to be set to NaN.
406 When we later determine that y is in fact VARYING, fold uses the fact
407 that HONOR_NANS is false, and we try to change the value of x to 0,
408 causing an ICE. With HONOR_NANS being false, the real appearance of
409 NaN would cause undefined behavior, though, so claiming that y (and x)
410 are UNDEFINED initially is correct. */
413 canonicalize_float_value (prop_value_t *val)
415 enum machine_mode mode;
419 if (val->lattice_val != CONSTANT
420 || TREE_CODE (val->value) != REAL_CST)
423 d = TREE_REAL_CST (val->value);
424 type = TREE_TYPE (val->value);
425 mode = TYPE_MODE (type);
427 if (!HONOR_SIGNED_ZEROS (mode)
428 && REAL_VALUE_MINUS_ZERO (d))
430 val->value = build_real (type, dconst0);
434 if (!HONOR_NANS (mode)
435 && REAL_VALUE_ISNAN (d))
437 val->lattice_val = UNDEFINED;
443 /* Set the value for variable VAR to NEW_VAL. Return true if the new
444 value is different from VAR's previous value. */
447 set_lattice_value (tree var, prop_value_t new_val)
449 prop_value_t *old_val = get_value (var);
451 canonicalize_float_value (&new_val);
453 /* Lattice transitions must always be monotonically increasing in
454 value. If *OLD_VAL and NEW_VAL are the same, return false to
455 inform the caller that this was a non-transition. */
457 gcc_assert (old_val->lattice_val < new_val.lattice_val
458 || (old_val->lattice_val == new_val.lattice_val
459 && ((!old_val->value && !new_val.value)
460 || operand_equal_p (old_val->value, new_val.value, 0))));
462 if (old_val->lattice_val != new_val.lattice_val)
464 if (dump_file && (dump_flags & TDF_DETAILS))
466 dump_lattice_value (dump_file, "Lattice value changed to ", new_val);
467 fprintf (dump_file, ". Adding SSA edges to worklist.\n");
472 gcc_assert (new_val.lattice_val != UNDEFINED);
480 /* Return the likely CCP lattice value for STMT.
482 If STMT has no operands, then return CONSTANT.
484 Else if undefinedness of operands of STMT cause its value to be
485 undefined, then return UNDEFINED.
487 Else if any operands of STMT are constants, then return CONSTANT.
489 Else return VARYING. */
492 likely_value (gimple stmt)
494 bool has_constant_operand, has_undefined_operand, all_undefined_operands;
499 enum gimple_code code = gimple_code (stmt);
501 /* This function appears to be called only for assignments, calls,
502 conditionals, and switches, due to the logic in visit_stmt. */
503 gcc_assert (code == GIMPLE_ASSIGN
504 || code == GIMPLE_CALL
505 || code == GIMPLE_COND
506 || code == GIMPLE_SWITCH);
508 /* If the statement has volatile operands, it won't fold to a
510 if (gimple_has_volatile_ops (stmt))
513 /* Arrive here for more complex cases. */
514 has_constant_operand = false;
515 has_undefined_operand = false;
516 all_undefined_operands = true;
517 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
519 prop_value_t *val = get_value (use);
521 if (val->lattice_val == UNDEFINED)
522 has_undefined_operand = true;
524 all_undefined_operands = false;
526 if (val->lattice_val == CONSTANT)
527 has_constant_operand = true;
530 /* There may be constants in regular rhs operands. For calls we
531 have to ignore lhs, fndecl and static chain, otherwise only
533 for (i = (is_gimple_call (stmt) ? 2 : 0) + gimple_has_lhs (stmt);
534 i < gimple_num_ops (stmt); ++i)
536 tree op = gimple_op (stmt, i);
537 if (!op || TREE_CODE (op) == SSA_NAME)
539 if (is_gimple_min_invariant (op))
540 has_constant_operand = true;
543 /* If the operation combines operands like COMPLEX_EXPR make sure to
544 not mark the result UNDEFINED if only one part of the result is
546 if (has_undefined_operand && all_undefined_operands)
548 else if (code == GIMPLE_ASSIGN && has_undefined_operand)
550 switch (gimple_assign_rhs_code (stmt))
552 /* Unary operators are handled with all_undefined_operands. */
555 case POINTER_PLUS_EXPR:
556 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
557 Not bitwise operators, one VARYING operand may specify the
558 result completely. Not logical operators for the same reason.
559 Not COMPLEX_EXPR as one VARYING operand makes the result partly
560 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
561 the undefined operand may be promoted. */
568 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
569 fall back to VARYING even if there were CONSTANT operands. */
570 if (has_undefined_operand)
573 /* We do not consider virtual operands here -- load from read-only
574 memory may have only VARYING virtual operands, but still be
576 if (has_constant_operand
577 || gimple_references_memory_p (stmt))
583 /* Returns true if STMT cannot be constant. */
586 surely_varying_stmt_p (gimple stmt)
588 /* If the statement has operands that we cannot handle, it cannot be
590 if (gimple_has_volatile_ops (stmt))
593 /* If it is a call and does not return a value or is not a
594 builtin and not an indirect call, it is varying. */
595 if (is_gimple_call (stmt))
598 if (!gimple_call_lhs (stmt)
599 || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
600 && !DECL_BUILT_IN (fndecl)))
604 /* Any other store operation is not interesting. */
605 else if (gimple_vdef (stmt))
608 /* Anything other than assignments and conditional jumps are not
609 interesting for CCP. */
610 if (gimple_code (stmt) != GIMPLE_ASSIGN
611 && gimple_code (stmt) != GIMPLE_COND
612 && gimple_code (stmt) != GIMPLE_SWITCH
613 && gimple_code (stmt) != GIMPLE_CALL)
619 /* Initialize local data structures for CCP. */
622 ccp_initialize (void)
626 const_val = XCNEWVEC (prop_value_t, num_ssa_names);
628 /* Initialize simulation flags for PHI nodes and statements. */
631 gimple_stmt_iterator i;
633 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
635 gimple stmt = gsi_stmt (i);
636 bool is_varying = surely_varying_stmt_p (stmt);
643 /* If the statement will not produce a constant, mark
644 all its outputs VARYING. */
645 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
646 set_value_varying (def);
648 prop_set_simulate_again (stmt, !is_varying);
652 /* Now process PHI nodes. We never clear the simulate_again flag on
653 phi nodes, since we do not know which edges are executable yet,
654 except for phi nodes for virtual operands when we do not do store ccp. */
657 gimple_stmt_iterator i;
659 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
661 gimple phi = gsi_stmt (i);
663 if (!is_gimple_reg (gimple_phi_result (phi)))
664 prop_set_simulate_again (phi, false);
666 prop_set_simulate_again (phi, true);
671 /* Debug count support. Reset the values of ssa names
672 VARYING when the total number ssa names analyzed is
673 beyond the debug count specified. */
679 for (i = 0; i < num_ssa_names; i++)
683 const_val[i].lattice_val = VARYING;
684 const_val[i].value = NULL_TREE;
690 /* Do final substitution of propagated values, cleanup the flowgraph and
691 free allocated storage.
693 Return TRUE when something was optimized. */
698 bool something_changed;
701 /* Perform substitutions based on the known constant values. */
702 something_changed = substitute_and_fold (const_val, false);
706 return something_changed;;
710 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
713 any M UNDEFINED = any
714 any M VARYING = VARYING
715 Ci M Cj = Ci if (i == j)
716 Ci M Cj = VARYING if (i != j)
720 ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
722 if (val1->lattice_val == UNDEFINED)
724 /* UNDEFINED M any = any */
727 else if (val2->lattice_val == UNDEFINED)
729 /* any M UNDEFINED = any
730 Nothing to do. VAL1 already contains the value we want. */
733 else if (val1->lattice_val == VARYING
734 || val2->lattice_val == VARYING)
736 /* any M VARYING = VARYING. */
737 val1->lattice_val = VARYING;
738 val1->value = NULL_TREE;
740 else if (val1->lattice_val == CONSTANT
741 && val2->lattice_val == CONSTANT
742 && simple_cst_equal (val1->value, val2->value) == 1)
744 /* Ci M Cj = Ci if (i == j)
745 Ci M Cj = VARYING if (i != j)
747 If these two values come from memory stores, make sure that
748 they come from the same memory reference. */
749 val1->lattice_val = CONSTANT;
750 val1->value = val1->value;
754 /* Any other combination is VARYING. */
755 val1->lattice_val = VARYING;
756 val1->value = NULL_TREE;
761 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
762 lattice values to determine PHI_NODE's lattice value. The value of a
763 PHI node is determined calling ccp_lattice_meet with all the arguments
764 of the PHI node that are incoming via executable edges. */
766 static enum ssa_prop_result
767 ccp_visit_phi_node (gimple phi)
770 prop_value_t *old_val, new_val;
772 if (dump_file && (dump_flags & TDF_DETAILS))
774 fprintf (dump_file, "\nVisiting PHI node: ");
775 print_gimple_stmt (dump_file, phi, 0, dump_flags);
778 old_val = get_value (gimple_phi_result (phi));
779 switch (old_val->lattice_val)
782 return SSA_PROP_VARYING;
789 new_val.lattice_val = UNDEFINED;
790 new_val.value = NULL_TREE;
797 for (i = 0; i < gimple_phi_num_args (phi); i++)
799 /* Compute the meet operator over all the PHI arguments flowing
800 through executable edges. */
801 edge e = gimple_phi_arg_edge (phi, i);
803 if (dump_file && (dump_flags & TDF_DETAILS))
806 "\n Argument #%d (%d -> %d %sexecutable)\n",
807 i, e->src->index, e->dest->index,
808 (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
811 /* If the incoming edge is executable, Compute the meet operator for
812 the existing value of the PHI node and the current PHI argument. */
813 if (e->flags & EDGE_EXECUTABLE)
815 tree arg = gimple_phi_arg (phi, i)->def;
816 prop_value_t arg_val;
818 if (is_gimple_min_invariant (arg))
820 arg_val.lattice_val = CONSTANT;
824 arg_val = *(get_value (arg));
826 ccp_lattice_meet (&new_val, &arg_val);
828 if (dump_file && (dump_flags & TDF_DETAILS))
830 fprintf (dump_file, "\t");
831 print_generic_expr (dump_file, arg, dump_flags);
832 dump_lattice_value (dump_file, "\tValue: ", arg_val);
833 fprintf (dump_file, "\n");
836 if (new_val.lattice_val == VARYING)
841 if (dump_file && (dump_flags & TDF_DETAILS))
843 dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
844 fprintf (dump_file, "\n\n");
847 /* Make the transition to the new value. */
848 if (set_lattice_value (gimple_phi_result (phi), new_val))
850 if (new_val.lattice_val == VARYING)
851 return SSA_PROP_VARYING;
853 return SSA_PROP_INTERESTING;
856 return SSA_PROP_NOT_INTERESTING;
859 /* Return true if we may propagate the address expression ADDR into the
860 dereference DEREF and cancel them. */
863 may_propagate_address_into_dereference (tree addr, tree deref)
865 gcc_assert (INDIRECT_REF_P (deref)
866 && TREE_CODE (addr) == ADDR_EXPR);
868 /* Don't propagate if ADDR's operand has incomplete type. */
869 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_OPERAND (addr, 0))))
872 /* If the address is invariant then we do not need to preserve restrict
873 qualifications. But we do need to preserve volatile qualifiers until
874 we can annotate the folded dereference itself properly. */
875 if (is_gimple_min_invariant (addr)
876 && (!TREE_THIS_VOLATILE (deref)
877 || TYPE_VOLATILE (TREE_TYPE (addr))))
878 return useless_type_conversion_p (TREE_TYPE (deref),
879 TREE_TYPE (TREE_OPERAND (addr, 0)));
881 /* Else both the address substitution and the folding must result in
882 a valid useless type conversion sequence. */
883 return (useless_type_conversion_p (TREE_TYPE (TREE_OPERAND (deref, 0)),
885 && useless_type_conversion_p (TREE_TYPE (deref),
886 TREE_TYPE (TREE_OPERAND (addr, 0))));
889 /* CCP specific front-end to the non-destructive constant folding
892 Attempt to simplify the RHS of STMT knowing that one or more
893 operands are constants.
895 If simplification is possible, return the simplified RHS,
896 otherwise return the original RHS or NULL_TREE. */
899 ccp_fold (gimple stmt)
901 switch (gimple_code (stmt))
905 enum tree_code subcode = gimple_assign_rhs_code (stmt);
907 switch (get_gimple_rhs_class (subcode))
909 case GIMPLE_SINGLE_RHS:
911 tree rhs = gimple_assign_rhs1 (stmt);
912 enum tree_code_class kind = TREE_CODE_CLASS (subcode);
914 if (TREE_CODE (rhs) == SSA_NAME)
916 /* If the RHS is an SSA_NAME, return its known constant value,
918 return get_value (rhs)->value;
920 /* Handle propagating invariant addresses into address operations.
921 The folding we do here matches that in tree-ssa-forwprop.c. */
922 else if (TREE_CODE (rhs) == ADDR_EXPR)
925 base = &TREE_OPERAND (rhs, 0);
926 while (handled_component_p (*base))
927 base = &TREE_OPERAND (*base, 0);
928 if (TREE_CODE (*base) == INDIRECT_REF
929 && TREE_CODE (TREE_OPERAND (*base, 0)) == SSA_NAME)
931 prop_value_t *val = get_value (TREE_OPERAND (*base, 0));
932 if (val->lattice_val == CONSTANT
933 && TREE_CODE (val->value) == ADDR_EXPR
934 && may_propagate_address_into_dereference
937 /* We need to return a new tree, not modify the IL
938 or share parts of it. So play some tricks to
939 avoid manually building it. */
940 tree ret, save = *base;
941 *base = TREE_OPERAND (val->value, 0);
942 ret = unshare_expr (rhs);
943 recompute_tree_invariant_for_addr_expr (ret);
950 if (kind == tcc_reference)
952 if ((TREE_CODE (rhs) == VIEW_CONVERT_EXPR
953 || TREE_CODE (rhs) == REALPART_EXPR
954 || TREE_CODE (rhs) == IMAGPART_EXPR)
955 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
957 prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
958 if (val->lattice_val == CONSTANT)
959 return fold_unary (TREE_CODE (rhs),
960 TREE_TYPE (rhs), val->value);
962 else if (TREE_CODE (rhs) == INDIRECT_REF
963 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
965 prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
966 if (val->lattice_val == CONSTANT
967 && TREE_CODE (val->value) == ADDR_EXPR
968 && useless_type_conversion_p (TREE_TYPE (rhs),
969 TREE_TYPE (TREE_TYPE (val->value))))
970 rhs = TREE_OPERAND (val->value, 0);
972 return fold_const_aggregate_ref (rhs);
974 else if (kind == tcc_declaration)
975 return get_symbol_constant_value (rhs);
979 case GIMPLE_UNARY_RHS:
981 /* Handle unary operators that can appear in GIMPLE form.
982 Note that we know the single operand must be a constant,
983 so this should almost always return a simplified RHS. */
984 tree lhs = gimple_assign_lhs (stmt);
985 tree op0 = gimple_assign_rhs1 (stmt);
987 /* Simplify the operand down to a constant. */
988 if (TREE_CODE (op0) == SSA_NAME)
990 prop_value_t *val = get_value (op0);
991 if (val->lattice_val == CONSTANT)
992 op0 = get_value (op0)->value;
995 /* Conversions are useless for CCP purposes if they are
996 value-preserving. Thus the restrictions that
997 useless_type_conversion_p places for pointer type conversions
998 do not apply here. Substitution later will only substitute to
1000 if (CONVERT_EXPR_CODE_P (subcode)
1001 && POINTER_TYPE_P (TREE_TYPE (lhs))
1002 && POINTER_TYPE_P (TREE_TYPE (op0))
1003 /* Do not allow differences in volatile qualification
1004 as this might get us confused as to whether a
1005 propagation destination statement is volatile
1006 or not. See PR36988. */
1007 && (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (lhs)))
1008 == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op0)))))
1011 /* Still try to generate a constant of correct type. */
1012 if (!useless_type_conversion_p (TREE_TYPE (lhs),
1014 && ((tem = maybe_fold_offset_to_address
1015 (op0, integer_zero_node, TREE_TYPE (lhs)))
1021 return fold_unary_ignore_overflow (subcode,
1022 gimple_expr_type (stmt), op0);
1025 case GIMPLE_BINARY_RHS:
1027 /* Handle binary operators that can appear in GIMPLE form. */
1028 tree op0 = gimple_assign_rhs1 (stmt);
1029 tree op1 = gimple_assign_rhs2 (stmt);
1031 /* Simplify the operands down to constants when appropriate. */
1032 if (TREE_CODE (op0) == SSA_NAME)
1034 prop_value_t *val = get_value (op0);
1035 if (val->lattice_val == CONSTANT)
1039 if (TREE_CODE (op1) == SSA_NAME)
1041 prop_value_t *val = get_value (op1);
1042 if (val->lattice_val == CONSTANT)
1046 /* Fold &foo + CST into an invariant reference if possible. */
1047 if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
1048 && TREE_CODE (op0) == ADDR_EXPR
1049 && TREE_CODE (op1) == INTEGER_CST)
1051 tree lhs = gimple_assign_lhs (stmt);
1052 tree tem = maybe_fold_offset_to_address (op0, op1,
1054 if (tem != NULL_TREE)
1058 return fold_binary (subcode, gimple_expr_type (stmt), op0, op1);
1069 tree fn = gimple_call_fn (stmt);
1072 if (TREE_CODE (fn) == SSA_NAME)
1074 val = get_value (fn);
1075 if (val->lattice_val == CONSTANT)
1078 if (TREE_CODE (fn) == ADDR_EXPR
1079 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
1080 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
1082 tree *args = XALLOCAVEC (tree, gimple_call_num_args (stmt));
1085 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1087 args[i] = gimple_call_arg (stmt, i);
1088 if (TREE_CODE (args[i]) == SSA_NAME)
1090 val = get_value (args[i]);
1091 if (val->lattice_val == CONSTANT)
1092 args[i] = val->value;
1095 call = build_call_array (gimple_call_return_type (stmt),
1096 fn, gimple_call_num_args (stmt), args);
1097 retval = fold_call_expr (call, false);
1099 /* fold_call_expr wraps the result inside a NOP_EXPR. */
1100 STRIP_NOPS (retval);
1108 /* Handle comparison operators that can appear in GIMPLE form. */
1109 tree op0 = gimple_cond_lhs (stmt);
1110 tree op1 = gimple_cond_rhs (stmt);
1111 enum tree_code code = gimple_cond_code (stmt);
1113 /* Simplify the operands down to constants when appropriate. */
1114 if (TREE_CODE (op0) == SSA_NAME)
1116 prop_value_t *val = get_value (op0);
1117 if (val->lattice_val == CONSTANT)
1121 if (TREE_CODE (op1) == SSA_NAME)
1123 prop_value_t *val = get_value (op1);
1124 if (val->lattice_val == CONSTANT)
1128 return fold_binary (code, boolean_type_node, op0, op1);
1133 tree rhs = gimple_switch_index (stmt);
1135 if (TREE_CODE (rhs) == SSA_NAME)
1137 /* If the RHS is an SSA_NAME, return its known constant value,
1139 return get_value (rhs)->value;
1151 /* Return the tree representing the element referenced by T if T is an
1152 ARRAY_REF or COMPONENT_REF into constant aggregates. Return
1153 NULL_TREE otherwise. */
1156 fold_const_aggregate_ref (tree t)
1158 prop_value_t *value;
1159 tree base, ctor, idx, field;
1160 unsigned HOST_WIDE_INT cnt;
1163 if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
1164 return get_symbol_constant_value (t);
1166 switch (TREE_CODE (t))
1169 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1170 DECL_INITIAL. If BASE is a nested reference into another
1171 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1172 the inner reference. */
1173 base = TREE_OPERAND (t, 0);
1174 switch (TREE_CODE (base))
1177 if (!TREE_READONLY (base)
1178 || TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE
1179 || !targetm.binds_local_p (base))
1182 ctor = DECL_INITIAL (base);
1187 ctor = fold_const_aggregate_ref (base);
1199 if (ctor == NULL_TREE
1200 || (TREE_CODE (ctor) != CONSTRUCTOR
1201 && TREE_CODE (ctor) != STRING_CST)
1202 || !TREE_STATIC (ctor))
1205 /* Get the index. If we have an SSA_NAME, try to resolve it
1206 with the current lattice value for the SSA_NAME. */
1207 idx = TREE_OPERAND (t, 1);
1208 switch (TREE_CODE (idx))
1211 if ((value = get_value (idx))
1212 && value->lattice_val == CONSTANT
1213 && TREE_CODE (value->value) == INTEGER_CST)
1226 /* Fold read from constant string. */
1227 if (TREE_CODE (ctor) == STRING_CST)
1229 if ((TYPE_MODE (TREE_TYPE (t))
1230 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1231 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1233 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor)))) == 1
1234 && compare_tree_int (idx, TREE_STRING_LENGTH (ctor)) < 0)
1235 return build_int_cst_type (TREE_TYPE (t),
1236 (TREE_STRING_POINTER (ctor)
1237 [TREE_INT_CST_LOW (idx)]));
1241 /* Whoo-hoo! I'll fold ya baby. Yeah! */
1242 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
1243 if (tree_int_cst_equal (cfield, idx))
1245 STRIP_USELESS_TYPE_CONVERSION (cval);
1251 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1252 DECL_INITIAL. If BASE is a nested reference into another
1253 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1254 the inner reference. */
1255 base = TREE_OPERAND (t, 0);
1256 switch (TREE_CODE (base))
1259 if (!TREE_READONLY (base)
1260 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
1261 || !targetm.binds_local_p (base))
1264 ctor = DECL_INITIAL (base);
1269 ctor = fold_const_aggregate_ref (base);
1276 if (ctor == NULL_TREE
1277 || TREE_CODE (ctor) != CONSTRUCTOR
1278 || !TREE_STATIC (ctor))
1281 field = TREE_OPERAND (t, 1);
1283 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
1285 /* FIXME: Handle bit-fields. */
1286 && ! DECL_BIT_FIELD (cfield))
1288 STRIP_USELESS_TYPE_CONVERSION (cval);
1296 tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
1297 if (c && TREE_CODE (c) == COMPLEX_CST)
1298 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), c);
1304 tree base = TREE_OPERAND (t, 0);
1305 if (TREE_CODE (base) == SSA_NAME
1306 && (value = get_value (base))
1307 && value->lattice_val == CONSTANT
1308 && TREE_CODE (value->value) == ADDR_EXPR)
1309 return fold_const_aggregate_ref (TREE_OPERAND (value->value, 0));
1320 /* Evaluate statement STMT.
1321 Valid only for assignments, calls, conditionals, and switches. */
1324 evaluate_stmt (gimple stmt)
1327 tree simplified = NULL_TREE;
1328 ccp_lattice_t likelyvalue = likely_value (stmt);
1331 fold_defer_overflow_warnings ();
1333 /* If the statement is likely to have a CONSTANT result, then try
1334 to fold the statement to determine the constant value. */
1335 /* FIXME. This is the only place that we call ccp_fold.
1336 Since likely_value never returns CONSTANT for calls, we will
1337 not attempt to fold them, including builtins that may profit. */
1338 if (likelyvalue == CONSTANT)
1339 simplified = ccp_fold (stmt);
1340 /* If the statement is likely to have a VARYING result, then do not
1341 bother folding the statement. */
1342 else if (likelyvalue == VARYING)
1344 enum gimple_code code = gimple_code (stmt);
1345 if (code == GIMPLE_ASSIGN)
1347 enum tree_code subcode = gimple_assign_rhs_code (stmt);
1349 /* Other cases cannot satisfy is_gimple_min_invariant
1351 if (get_gimple_rhs_class (subcode) == GIMPLE_SINGLE_RHS)
1352 simplified = gimple_assign_rhs1 (stmt);
1354 else if (code == GIMPLE_SWITCH)
1355 simplified = gimple_switch_index (stmt);
1357 /* These cannot satisfy is_gimple_min_invariant without folding. */
1358 gcc_assert (code == GIMPLE_CALL || code == GIMPLE_COND);
1361 is_constant = simplified && is_gimple_min_invariant (simplified);
1363 fold_undefer_overflow_warnings (is_constant, stmt, 0);
1365 if (dump_file && (dump_flags & TDF_DETAILS))
1367 fprintf (dump_file, "which is likely ");
1368 switch (likelyvalue)
1371 fprintf (dump_file, "CONSTANT");
1374 fprintf (dump_file, "UNDEFINED");
1377 fprintf (dump_file, "VARYING");
1381 fprintf (dump_file, "\n");
1386 /* The statement produced a constant value. */
1387 val.lattice_val = CONSTANT;
1388 val.value = simplified;
1392 /* The statement produced a nonconstant value. If the statement
1393 had UNDEFINED operands, then the result of the statement
1394 should be UNDEFINED. Otherwise, the statement is VARYING. */
1395 if (likelyvalue == UNDEFINED)
1396 val.lattice_val = likelyvalue;
1398 val.lattice_val = VARYING;
1400 val.value = NULL_TREE;
1406 /* Visit the assignment statement STMT. Set the value of its LHS to the
1407 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
1408 creates virtual definitions, set the value of each new name to that
1409 of the RHS (if we can derive a constant out of the RHS).
1410 Value-returning call statements also perform an assignment, and
1411 are handled here. */
1413 static enum ssa_prop_result
1414 visit_assignment (gimple stmt, tree *output_p)
1417 enum ssa_prop_result retval;
1419 tree lhs = gimple_get_lhs (stmt);
1421 gcc_assert (gimple_code (stmt) != GIMPLE_CALL
1422 || gimple_call_lhs (stmt) != NULL_TREE);
1424 if (gimple_assign_copy_p (stmt))
1426 tree rhs = gimple_assign_rhs1 (stmt);
1428 if (TREE_CODE (rhs) == SSA_NAME)
1430 /* For a simple copy operation, we copy the lattice values. */
1431 prop_value_t *nval = get_value (rhs);
1435 val = evaluate_stmt (stmt);
1438 /* Evaluate the statement, which could be
1439 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1440 val = evaluate_stmt (stmt);
1442 retval = SSA_PROP_NOT_INTERESTING;
1444 /* Set the lattice value of the statement's output. */
1445 if (TREE_CODE (lhs) == SSA_NAME)
1447 /* If STMT is an assignment to an SSA_NAME, we only have one
1449 if (set_lattice_value (lhs, val))
1452 if (val.lattice_val == VARYING)
1453 retval = SSA_PROP_VARYING;
1455 retval = SSA_PROP_INTERESTING;
1463 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
1464 if it can determine which edge will be taken. Otherwise, return
1465 SSA_PROP_VARYING. */
1467 static enum ssa_prop_result
1468 visit_cond_stmt (gimple stmt, edge *taken_edge_p)
1473 block = gimple_bb (stmt);
1474 val = evaluate_stmt (stmt);
1476 /* Find which edge out of the conditional block will be taken and add it
1477 to the worklist. If no single edge can be determined statically,
1478 return SSA_PROP_VARYING to feed all the outgoing edges to the
1479 propagation engine. */
1480 *taken_edge_p = val.value ? find_taken_edge (block, val.value) : 0;
1482 return SSA_PROP_INTERESTING;
1484 return SSA_PROP_VARYING;
1488 /* Evaluate statement STMT. If the statement produces an output value and
1489 its evaluation changes the lattice value of its output, return
1490 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
1493 If STMT is a conditional branch and we can determine its truth
1494 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
1495 value, return SSA_PROP_VARYING. */
1497 static enum ssa_prop_result
1498 ccp_visit_stmt (gimple stmt, edge *taken_edge_p, tree *output_p)
1503 if (dump_file && (dump_flags & TDF_DETAILS))
1505 fprintf (dump_file, "\nVisiting statement:\n");
1506 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
1509 switch (gimple_code (stmt))
1512 /* If the statement is an assignment that produces a single
1513 output value, evaluate its RHS to see if the lattice value of
1514 its output has changed. */
1515 return visit_assignment (stmt, output_p);
1518 /* A value-returning call also performs an assignment. */
1519 if (gimple_call_lhs (stmt) != NULL_TREE)
1520 return visit_assignment (stmt, output_p);
1525 /* If STMT is a conditional branch, see if we can determine
1526 which branch will be taken. */
1527 /* FIXME. It appears that we should be able to optimize
1528 computed GOTOs here as well. */
1529 return visit_cond_stmt (stmt, taken_edge_p);
1535 /* Any other kind of statement is not interesting for constant
1536 propagation and, therefore, not worth simulating. */
1537 if (dump_file && (dump_flags & TDF_DETAILS))
1538 fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
1540 /* Definitions made by statements other than assignments to
1541 SSA_NAMEs represent unknown modifications to their outputs.
1542 Mark them VARYING. */
1543 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
1545 prop_value_t v = { VARYING, NULL_TREE };
1546 set_lattice_value (def, v);
1549 return SSA_PROP_VARYING;
1553 /* Main entry point for SSA Conditional Constant Propagation. */
1559 ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
1560 if (ccp_finalize ())
1561 return (TODO_cleanup_cfg | TODO_update_ssa | TODO_remove_unused_locals);
1570 return flag_tree_ccp != 0;
1574 struct gimple_opt_pass pass_ccp =
1579 gate_ccp, /* gate */
1580 do_ssa_ccp, /* execute */
1583 0, /* static_pass_number */
1584 TV_TREE_CCP, /* tv_id */
1585 PROP_cfg | PROP_ssa, /* properties_required */
1586 0, /* properties_provided */
1587 0, /* properties_destroyed */
1588 0, /* todo_flags_start */
1589 TODO_dump_func | TODO_verify_ssa
1590 | TODO_verify_stmts | TODO_ggc_collect/* todo_flags_finish */
1595 /* A subroutine of fold_stmt_r. Attempts to fold *(A+O) to A[X].
1596 BASE is an array type. OFFSET is a byte displacement. ORIG_TYPE
1597 is the desired result type. */
1600 maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type,
1601 bool allow_negative_idx)
1603 tree min_idx, idx, idx_type, elt_offset = integer_zero_node;
1604 tree array_type, elt_type, elt_size;
1607 /* If BASE is an ARRAY_REF, we can pick up another offset (this time
1608 measured in units of the size of elements type) from that ARRAY_REF).
1609 We can't do anything if either is variable.
1611 The case we handle here is *(&A[N]+O). */
1612 if (TREE_CODE (base) == ARRAY_REF)
1614 tree low_bound = array_ref_low_bound (base);
1616 elt_offset = TREE_OPERAND (base, 1);
1617 if (TREE_CODE (low_bound) != INTEGER_CST
1618 || TREE_CODE (elt_offset) != INTEGER_CST)
1621 elt_offset = int_const_binop (MINUS_EXPR, elt_offset, low_bound, 0);
1622 base = TREE_OPERAND (base, 0);
1625 /* Ignore stupid user tricks of indexing non-array variables. */
1626 array_type = TREE_TYPE (base);
1627 if (TREE_CODE (array_type) != ARRAY_TYPE)
1629 elt_type = TREE_TYPE (array_type);
1630 if (!useless_type_conversion_p (orig_type, elt_type))
1633 /* Use signed size type for intermediate computation on the index. */
1634 idx_type = signed_type_for (size_type_node);
1636 /* If OFFSET and ELT_OFFSET are zero, we don't care about the size of the
1637 element type (so we can use the alignment if it's not constant).
1638 Otherwise, compute the offset as an index by using a division. If the
1639 division isn't exact, then don't do anything. */
1640 elt_size = TYPE_SIZE_UNIT (elt_type);
1643 if (integer_zerop (offset))
1645 if (TREE_CODE (elt_size) != INTEGER_CST)
1646 elt_size = size_int (TYPE_ALIGN (elt_type));
1648 idx = build_int_cst (idx_type, 0);
1652 unsigned HOST_WIDE_INT lquo, lrem;
1653 HOST_WIDE_INT hquo, hrem;
1656 /* The final array offset should be signed, so we need
1657 to sign-extend the (possibly pointer) offset here
1658 and use signed division. */
1659 soffset = double_int_sext (tree_to_double_int (offset),
1660 TYPE_PRECISION (TREE_TYPE (offset)));
1661 if (TREE_CODE (elt_size) != INTEGER_CST
1662 || div_and_round_double (TRUNC_DIV_EXPR, 0,
1663 soffset.low, soffset.high,
1664 TREE_INT_CST_LOW (elt_size),
1665 TREE_INT_CST_HIGH (elt_size),
1666 &lquo, &hquo, &lrem, &hrem)
1670 idx = build_int_cst_wide (idx_type, lquo, hquo);
1673 /* Assume the low bound is zero. If there is a domain type, get the
1674 low bound, if any, convert the index into that type, and add the
1676 min_idx = build_int_cst (idx_type, 0);
1677 domain_type = TYPE_DOMAIN (array_type);
1680 idx_type = domain_type;
1681 if (TYPE_MIN_VALUE (idx_type))
1682 min_idx = TYPE_MIN_VALUE (idx_type);
1684 min_idx = fold_convert (idx_type, min_idx);
1686 if (TREE_CODE (min_idx) != INTEGER_CST)
1689 elt_offset = fold_convert (idx_type, elt_offset);
1692 if (!integer_zerop (min_idx))
1693 idx = int_const_binop (PLUS_EXPR, idx, min_idx, 0);
1694 if (!integer_zerop (elt_offset))
1695 idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
1697 /* Make sure to possibly truncate late after offsetting. */
1698 idx = fold_convert (idx_type, idx);
1700 /* We don't want to construct access past array bounds. For example
1703 should not be simplified into (*c)[14] or tree-vrp will
1704 give false warnings. The same is true for
1705 struct A { long x; char d[0]; } *a;
1707 which should be not folded to &a->d[-8]. */
1709 && TYPE_MAX_VALUE (domain_type)
1710 && TREE_CODE (TYPE_MAX_VALUE (domain_type)) == INTEGER_CST)
1712 tree up_bound = TYPE_MAX_VALUE (domain_type);
1714 if (tree_int_cst_lt (up_bound, idx)
1715 /* Accesses after the end of arrays of size 0 (gcc
1716 extension) and 1 are likely intentional ("struct
1718 && compare_tree_int (up_bound, 1) > 0)
1722 && TYPE_MIN_VALUE (domain_type))
1724 if (!allow_negative_idx
1725 && TREE_CODE (TYPE_MIN_VALUE (domain_type)) == INTEGER_CST
1726 && tree_int_cst_lt (idx, TYPE_MIN_VALUE (domain_type)))
1729 else if (!allow_negative_idx
1730 && compare_tree_int (idx, 0) < 0)
1733 return build4 (ARRAY_REF, elt_type, base, idx, NULL_TREE, NULL_TREE);
1737 /* Attempt to fold *(S+O) to S.X.
1738 BASE is a record type. OFFSET is a byte displacement. ORIG_TYPE
1739 is the desired result type. */
1742 maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
1743 tree orig_type, bool base_is_ptr)
1745 tree f, t, field_type, tail_array_field, field_offset;
1749 if (TREE_CODE (record_type) != RECORD_TYPE
1750 && TREE_CODE (record_type) != UNION_TYPE
1751 && TREE_CODE (record_type) != QUAL_UNION_TYPE)
1754 /* Short-circuit silly cases. */
1755 if (useless_type_conversion_p (record_type, orig_type))
1758 tail_array_field = NULL_TREE;
1759 for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
1763 if (TREE_CODE (f) != FIELD_DECL)
1765 if (DECL_BIT_FIELD (f))
1768 if (!DECL_FIELD_OFFSET (f))
1770 field_offset = byte_position (f);
1771 if (TREE_CODE (field_offset) != INTEGER_CST)
1774 /* ??? Java creates "interesting" fields for representing base classes.
1775 They have no name, and have no context. With no context, we get into
1776 trouble with nonoverlapping_component_refs_p. Skip them. */
1777 if (!DECL_FIELD_CONTEXT (f))
1780 /* The previous array field isn't at the end. */
1781 tail_array_field = NULL_TREE;
1783 /* Check to see if this offset overlaps with the field. */
1784 cmp = tree_int_cst_compare (field_offset, offset);
1788 field_type = TREE_TYPE (f);
1790 /* Here we exactly match the offset being checked. If the types match,
1791 then we can return that field. */
1793 && useless_type_conversion_p (orig_type, field_type))
1796 base = build1 (INDIRECT_REF, record_type, base);
1797 t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
1801 /* Don't care about offsets into the middle of scalars. */
1802 if (!AGGREGATE_TYPE_P (field_type))
1805 /* Check for array at the end of the struct. This is often
1806 used as for flexible array members. We should be able to
1807 turn this into an array access anyway. */
1808 if (TREE_CODE (field_type) == ARRAY_TYPE)
1809 tail_array_field = f;
1811 /* Check the end of the field against the offset. */
1812 if (!DECL_SIZE_UNIT (f)
1813 || TREE_CODE (DECL_SIZE_UNIT (f)) != INTEGER_CST)
1815 t = int_const_binop (MINUS_EXPR, offset, field_offset, 1);
1816 if (!tree_int_cst_lt (t, DECL_SIZE_UNIT (f)))
1819 /* If we matched, then set offset to the displacement into
1822 new_base = build1 (INDIRECT_REF, record_type, base);
1825 new_base = build3 (COMPONENT_REF, field_type, new_base, f, NULL_TREE);
1827 /* Recurse to possibly find the match. */
1828 ret = maybe_fold_offset_to_array_ref (new_base, t, orig_type,
1829 f == TYPE_FIELDS (record_type));
1832 ret = maybe_fold_offset_to_component_ref (field_type, new_base, t,
1838 if (!tail_array_field)
1841 f = tail_array_field;
1842 field_type = TREE_TYPE (f);
1843 offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
1845 /* If we get here, we've got an aggregate field, and a possibly
1846 nonzero offset into them. Recurse and hope for a valid match. */
1848 base = build1 (INDIRECT_REF, record_type, base);
1849 base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
1851 t = maybe_fold_offset_to_array_ref (base, offset, orig_type,
1852 f == TYPE_FIELDS (record_type));
1855 return maybe_fold_offset_to_component_ref (field_type, base, offset,
1859 /* Attempt to express (ORIG_TYPE)BASE+OFFSET as BASE->field_of_orig_type
1860 or BASE[index] or by combination of those.
1862 Before attempting the conversion strip off existing ADDR_EXPRs and
1863 handled component refs. */
1866 maybe_fold_offset_to_reference (tree base, tree offset, tree orig_type)
1870 bool base_is_ptr = true;
1873 if (TREE_CODE (base) == ADDR_EXPR)
1875 base_is_ptr = false;
1877 base = TREE_OPERAND (base, 0);
1879 /* Handle case where existing COMPONENT_REF pick e.g. wrong field of union,
1880 so it needs to be removed and new COMPONENT_REF constructed.
1881 The wrong COMPONENT_REF are often constructed by folding the
1882 (type *)&object within the expression (type *)&object+offset */
1883 if (handled_component_p (base))
1885 HOST_WIDE_INT sub_offset, size, maxsize;
1887 newbase = get_ref_base_and_extent (base, &sub_offset,
1889 gcc_assert (newbase);
1892 && !(sub_offset & (BITS_PER_UNIT - 1)))
1896 offset = int_const_binop (PLUS_EXPR, offset,
1897 build_int_cst (TREE_TYPE (offset),
1898 sub_offset / BITS_PER_UNIT), 1);
1901 if (useless_type_conversion_p (orig_type, TREE_TYPE (base))
1902 && integer_zerop (offset))
1904 type = TREE_TYPE (base);
1909 if (!POINTER_TYPE_P (TREE_TYPE (base)))
1911 type = TREE_TYPE (TREE_TYPE (base));
1913 ret = maybe_fold_offset_to_component_ref (type, base, offset,
1914 orig_type, base_is_ptr);
1918 base = build1 (INDIRECT_REF, type, base);
1919 ret = maybe_fold_offset_to_array_ref (base, offset, orig_type, true);
1924 /* Attempt to express (ORIG_TYPE)&BASE+OFFSET as &BASE->field_of_orig_type
1925 or &BASE[index] or by combination of those.
1927 Before attempting the conversion strip off existing component refs. */
1930 maybe_fold_offset_to_address (tree addr, tree offset, tree orig_type)
1934 gcc_assert (POINTER_TYPE_P (TREE_TYPE (addr))
1935 && POINTER_TYPE_P (orig_type));
1937 t = maybe_fold_offset_to_reference (addr, offset, TREE_TYPE (orig_type));
1943 /* For __builtin_object_size to function correctly we need to
1944 make sure not to fold address arithmetic so that we change
1945 reference from one array to another. This would happen for
1948 struct X { char s1[10]; char s2[10] } s;
1949 char *foo (void) { return &s.s2[-4]; }
1951 where we need to avoid generating &s.s1[6]. As the C and
1952 C++ frontends create different initial trees
1953 (char *) &s.s1 + -4 vs. &s.s1[-4] we have to do some
1954 sophisticated comparisons here. Note that checking for the
1955 condition after the fact is easier than trying to avoid doing
1958 if (TREE_CODE (orig) == ADDR_EXPR)
1959 orig = TREE_OPERAND (orig, 0);
1960 if ((TREE_CODE (orig) == ARRAY_REF
1961 || (TREE_CODE (orig) == COMPONENT_REF
1962 && TREE_CODE (TREE_TYPE (TREE_OPERAND (orig, 1))) == ARRAY_TYPE))
1963 && (TREE_CODE (t) == ARRAY_REF
1964 || TREE_CODE (t) == COMPONENT_REF)
1965 && !operand_equal_p (TREE_CODE (orig) == ARRAY_REF
1966 ? TREE_OPERAND (orig, 0) : orig,
1967 TREE_CODE (t) == ARRAY_REF
1968 ? TREE_OPERAND (t, 0) : t, 0))
1971 ptr_type = build_pointer_type (TREE_TYPE (t));
1972 if (!useless_type_conversion_p (orig_type, ptr_type))
1974 return build_fold_addr_expr_with_type (t, ptr_type);
1980 /* A subroutine of fold_stmt_r. Attempt to simplify *(BASE+OFFSET).
1981 Return the simplified expression, or NULL if nothing could be done. */
1984 maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
1987 bool volatile_p = TREE_THIS_VOLATILE (expr);
1989 /* We may well have constructed a double-nested PLUS_EXPR via multiple
1990 substitutions. Fold that down to one. Remove NON_LVALUE_EXPRs that
1991 are sometimes added. */
1993 STRIP_TYPE_NOPS (base);
1994 TREE_OPERAND (expr, 0) = base;
1996 /* One possibility is that the address reduces to a string constant. */
1997 t = fold_read_from_constant_string (expr);
2001 /* Add in any offset from a POINTER_PLUS_EXPR. */
2002 if (TREE_CODE (base) == POINTER_PLUS_EXPR)
2006 offset2 = TREE_OPERAND (base, 1);
2007 if (TREE_CODE (offset2) != INTEGER_CST)
2009 base = TREE_OPERAND (base, 0);
2011 offset = fold_convert (sizetype,
2012 int_const_binop (PLUS_EXPR, offset, offset2, 1));
2015 if (TREE_CODE (base) == ADDR_EXPR)
2017 tree base_addr = base;
2019 /* Strip the ADDR_EXPR. */
2020 base = TREE_OPERAND (base, 0);
2022 /* Fold away CONST_DECL to its value, if the type is scalar. */
2023 if (TREE_CODE (base) == CONST_DECL
2024 && is_gimple_min_invariant (DECL_INITIAL (base)))
2025 return DECL_INITIAL (base);
2027 /* Try folding *(&B+O) to B.X. */
2028 t = maybe_fold_offset_to_reference (base_addr, offset,
2032 /* Preserve volatileness of the original expression.
2033 We can end up with a plain decl here which is shared
2034 and we shouldn't mess with its flags. */
2036 TREE_THIS_VOLATILE (t) = volatile_p;
2042 /* We can get here for out-of-range string constant accesses,
2043 such as "_"[3]. Bail out of the entire substitution search
2044 and arrange for the entire statement to be replaced by a
2045 call to __builtin_trap. In all likelihood this will all be
2046 constant-folded away, but in the meantime we can't leave with
2047 something that get_expr_operands can't understand. */
2051 if (TREE_CODE (t) == ADDR_EXPR
2052 && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
2054 /* FIXME: Except that this causes problems elsewhere with dead
2055 code not being deleted, and we die in the rtl expanders
2056 because we failed to remove some ssa_name. In the meantime,
2057 just return zero. */
2058 /* FIXME2: This condition should be signaled by
2059 fold_read_from_constant_string directly, rather than
2060 re-checking for it here. */
2061 return integer_zero_node;
2064 /* Try folding *(B+O) to B->X. Still an improvement. */
2065 if (POINTER_TYPE_P (TREE_TYPE (base)))
2067 t = maybe_fold_offset_to_reference (base, offset,
2074 /* Otherwise we had an offset that we could not simplify. */
2079 /* A quaint feature extant in our address arithmetic is that there
2080 can be hidden type changes here. The type of the result need
2081 not be the same as the type of the input pointer.
2083 What we're after here is an expression of the form
2084 (T *)(&array + const)
2085 where array is OP0, const is OP1, RES_TYPE is T and
2086 the cast doesn't actually exist, but is implicit in the
2087 type of the POINTER_PLUS_EXPR. We'd like to turn this into
2089 which may be able to propagate further. */
2092 maybe_fold_stmt_addition (tree res_type, tree op0, tree op1)
2097 /* It had better be a constant. */
2098 if (TREE_CODE (op1) != INTEGER_CST)
2100 /* The first operand should be an ADDR_EXPR. */
2101 if (TREE_CODE (op0) != ADDR_EXPR)
2103 op0 = TREE_OPERAND (op0, 0);
2105 /* If the first operand is an ARRAY_REF, expand it so that we can fold
2106 the offset into it. */
2107 while (TREE_CODE (op0) == ARRAY_REF)
2109 tree array_obj = TREE_OPERAND (op0, 0);
2110 tree array_idx = TREE_OPERAND (op0, 1);
2111 tree elt_type = TREE_TYPE (op0);
2112 tree elt_size = TYPE_SIZE_UNIT (elt_type);
2115 if (TREE_CODE (array_idx) != INTEGER_CST)
2117 if (TREE_CODE (elt_size) != INTEGER_CST)
2120 /* Un-bias the index by the min index of the array type. */
2121 min_idx = TYPE_DOMAIN (TREE_TYPE (array_obj));
2124 min_idx = TYPE_MIN_VALUE (min_idx);
2127 if (TREE_CODE (min_idx) != INTEGER_CST)
2130 array_idx = fold_convert (TREE_TYPE (min_idx), array_idx);
2131 if (!integer_zerop (min_idx))
2132 array_idx = int_const_binop (MINUS_EXPR, array_idx,
2137 /* Convert the index to a byte offset. */
2138 array_idx = fold_convert (sizetype, array_idx);
2139 array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
2141 /* Update the operands for the next round, or for folding. */
2142 op1 = int_const_binop (PLUS_EXPR,
2147 ptd_type = TREE_TYPE (res_type);
2148 /* If we want a pointer to void, reconstruct the reference from the
2149 array element type. A pointer to that can be trivially converted
2150 to void *. This happens as we fold (void *)(ptr p+ off). */
2151 if (VOID_TYPE_P (ptd_type)
2152 && TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE)
2153 ptd_type = TREE_TYPE (TREE_TYPE (op0));
2155 /* At which point we can try some of the same things as for indirects. */
2156 t = maybe_fold_offset_to_array_ref (op0, op1, ptd_type, true);
2158 t = maybe_fold_offset_to_component_ref (TREE_TYPE (op0), op0, op1,
2161 t = build1 (ADDR_EXPR, res_type, t);
2166 /* For passing state through walk_tree into fold_stmt_r and its
2169 struct fold_stmt_r_data
2173 bool *inside_addr_expr_p;
2176 /* Subroutine of fold_stmt called via walk_tree. We perform several
2177 simplifications of EXPR_P, mostly having to do with pointer arithmetic. */
2180 fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data)
2182 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
2183 struct fold_stmt_r_data *fold_stmt_r_data;
2184 bool *inside_addr_expr_p;
2186 tree expr = *expr_p, t;
2187 bool volatile_p = TREE_THIS_VOLATILE (expr);
2189 fold_stmt_r_data = (struct fold_stmt_r_data *) wi->info;
2190 inside_addr_expr_p = fold_stmt_r_data->inside_addr_expr_p;
2191 changed_p = fold_stmt_r_data->changed_p;
2193 /* ??? It'd be nice if walk_tree had a pre-order option. */
2194 switch (TREE_CODE (expr))
2197 t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
2202 t = maybe_fold_stmt_indirect (expr, TREE_OPERAND (expr, 0),
2204 /* Avoid folding *"abc" = 5 into 'a' = 5. */
2205 if (wi->is_lhs && t && TREE_CODE (t) == INTEGER_CST)
2208 && TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
2209 /* If we had a good reason for propagating the address here,
2210 make sure we end up with valid gimple. See PR34989. */
2211 t = TREE_OPERAND (TREE_OPERAND (expr, 0), 0);
2215 t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
2220 if (POINTER_TYPE_P (TREE_TYPE (expr))
2221 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (expr)))
2222 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0)))
2223 && (t = maybe_fold_offset_to_address (TREE_OPERAND (expr, 0),
2225 TREE_TYPE (TREE_TYPE (expr)))))
2229 /* ??? Could handle more ARRAY_REFs here, as a variant of INDIRECT_REF.
2230 We'd only want to bother decomposing an existing ARRAY_REF if
2231 the base array is found to have another offset contained within.
2232 Otherwise we'd be wasting time. */
2234 /* If we are not processing expressions found within an
2235 ADDR_EXPR, then we can fold constant array references.
2236 Don't fold on LHS either, to avoid folding "abc"[0] = 5
2238 if (!*inside_addr_expr_p && !wi->is_lhs)
2239 t = fold_read_from_constant_string (expr);
2245 *inside_addr_expr_p = true;
2246 t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
2247 *inside_addr_expr_p = false;
2252 /* Make sure the value is properly considered constant, and so gets
2253 propagated as expected. */
2255 recompute_tree_invariant_for_addr_expr (expr);
2259 t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
2264 /* Make sure the FIELD_DECL is actually a field in the type on the lhs.
2265 We've already checked that the records are compatible, so we should
2266 come up with a set of compatible fields. */
2268 tree expr_record = TREE_TYPE (TREE_OPERAND (expr, 0));
2269 tree expr_field = TREE_OPERAND (expr, 1);
2271 if (DECL_FIELD_CONTEXT (expr_field) != TYPE_MAIN_VARIANT (expr_record))
2273 expr_field = find_compatible_field (expr_record, expr_field);
2274 TREE_OPERAND (expr, 1) = expr_field;
2279 case TARGET_MEM_REF:
2280 t = maybe_fold_tmr (expr);
2283 case POINTER_PLUS_EXPR:
2284 t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
2287 t = walk_tree (&TREE_OPERAND (expr, 1), fold_stmt_r, data, NULL);
2292 t = maybe_fold_stmt_addition (TREE_TYPE (expr),
2293 TREE_OPERAND (expr, 0),
2294 TREE_OPERAND (expr, 1));
2298 if (COMPARISON_CLASS_P (TREE_OPERAND (expr, 0)))
2300 tree op0 = TREE_OPERAND (expr, 0);
2304 fold_defer_overflow_warnings ();
2305 tem = fold_binary (TREE_CODE (op0), TREE_TYPE (op0),
2306 TREE_OPERAND (op0, 0),
2307 TREE_OPERAND (op0, 1));
2308 /* This is actually a conditional expression, not a GIMPLE
2309 conditional statement, however, the valid_gimple_rhs_p
2310 test still applies. */
2311 set = tem && is_gimple_condexpr (tem) && valid_gimple_rhs_p (tem);
2312 fold_undefer_overflow_warnings (set, fold_stmt_r_data->stmt, 0);
2315 COND_EXPR_COND (expr) = tem;
2328 /* Preserve volatileness of the original expression.
2329 We can end up with a plain decl here which is shared
2330 and we shouldn't mess with its flags. */
2332 TREE_THIS_VOLATILE (t) = volatile_p;
2340 /* Return the string length, maximum string length or maximum value of
2342 If ARG is an SSA name variable, follow its use-def chains. If LENGTH
2343 is not NULL and, for TYPE == 0, its value is not equal to the length
2344 we determine or if we are unable to determine the length or value,
2345 return false. VISITED is a bitmap of visited variables.
2346 TYPE is 0 if string length should be returned, 1 for maximum string
2347 length and 2 for maximum value ARG can have. */
2350 get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
2355 if (TREE_CODE (arg) != SSA_NAME)
2357 if (TREE_CODE (arg) == COND_EXPR)
2358 return get_maxval_strlen (COND_EXPR_THEN (arg), length, visited, type)
2359 && get_maxval_strlen (COND_EXPR_ELSE (arg), length, visited, type);
2360 /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
2361 else if (TREE_CODE (arg) == ADDR_EXPR
2362 && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF
2363 && integer_zerop (TREE_OPERAND (TREE_OPERAND (arg, 0), 1)))
2365 tree aop0 = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
2366 if (TREE_CODE (aop0) == INDIRECT_REF
2367 && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
2368 return get_maxval_strlen (TREE_OPERAND (aop0, 0),
2369 length, visited, type);
2375 if (TREE_CODE (val) != INTEGER_CST
2376 || tree_int_cst_sgn (val) < 0)
2380 val = c_strlen (arg, 1);
2388 if (TREE_CODE (*length) != INTEGER_CST
2389 || TREE_CODE (val) != INTEGER_CST)
2392 if (tree_int_cst_lt (*length, val))
2396 else if (simple_cst_equal (val, *length) != 1)
2404 /* If we were already here, break the infinite cycle. */
2405 if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
2407 bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
2410 def_stmt = SSA_NAME_DEF_STMT (var);
2412 switch (gimple_code (def_stmt))
2415 /* The RHS of the statement defining VAR must either have a
2416 constant length or come from another SSA_NAME with a constant
2418 if (gimple_assign_single_p (def_stmt)
2419 || gimple_assign_unary_nop_p (def_stmt))
2421 tree rhs = gimple_assign_rhs1 (def_stmt);
2422 return get_maxval_strlen (rhs, length, visited, type);
2428 /* All the arguments of the PHI node must have the same constant
2432 for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
2434 tree arg = gimple_phi_arg (def_stmt, i)->def;
2436 /* If this PHI has itself as an argument, we cannot
2437 determine the string length of this argument. However,
2438 if we can find a constant string length for the other
2439 PHI args then we can still be sure that this is a
2440 constant string length. So be optimistic and just
2441 continue with the next argument. */
2442 if (arg == gimple_phi_result (def_stmt))
2445 if (!get_maxval_strlen (arg, length, visited, type))
2457 /* Fold builtin call in statement STMT. Returns a simplified tree.
2458 We may return a non-constant expression, including another call
2459 to a different function and with different arguments, e.g.,
2460 substituting memcpy for strcpy when the string length is known.
2461 Note that some builtins expand into inline code that may not
2462 be valid in GIMPLE. Callers must take care. */
2465 ccp_fold_builtin (gimple stmt)
2467 tree result, val[3];
2474 gcc_assert (is_gimple_call (stmt));
2476 ignore = (gimple_call_lhs (stmt) == NULL);
2478 /* First try the generic builtin folder. If that succeeds, return the
2480 result = fold_call_stmt (stmt, ignore);
2484 STRIP_NOPS (result);
2488 /* Ignore MD builtins. */
2489 callee = gimple_call_fndecl (stmt);
2490 if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_MD)
2493 /* If the builtin could not be folded, and it has no argument list,
2495 nargs = gimple_call_num_args (stmt);
2499 /* Limit the work only for builtins we know how to simplify. */
2500 switch (DECL_FUNCTION_CODE (callee))
2502 case BUILT_IN_STRLEN:
2503 case BUILT_IN_FPUTS:
2504 case BUILT_IN_FPUTS_UNLOCKED:
2508 case BUILT_IN_STRCPY:
2509 case BUILT_IN_STRNCPY:
2513 case BUILT_IN_MEMCPY_CHK:
2514 case BUILT_IN_MEMPCPY_CHK:
2515 case BUILT_IN_MEMMOVE_CHK:
2516 case BUILT_IN_MEMSET_CHK:
2517 case BUILT_IN_STRNCPY_CHK:
2521 case BUILT_IN_STRCPY_CHK:
2522 case BUILT_IN_STPCPY_CHK:
2526 case BUILT_IN_SNPRINTF_CHK:
2527 case BUILT_IN_VSNPRINTF_CHK:
2535 if (arg_idx >= nargs)
2538 /* Try to use the dataflow information gathered by the CCP process. */
2539 visited = BITMAP_ALLOC (NULL);
2540 bitmap_clear (visited);
2542 memset (val, 0, sizeof (val));
2543 a = gimple_call_arg (stmt, arg_idx);
2544 if (!get_maxval_strlen (a, &val[arg_idx], visited, type))
2545 val[arg_idx] = NULL_TREE;
2547 BITMAP_FREE (visited);
2550 switch (DECL_FUNCTION_CODE (callee))
2552 case BUILT_IN_STRLEN:
2553 if (val[0] && nargs == 1)
2556 fold_convert (TREE_TYPE (gimple_call_lhs (stmt)), val[0]);
2558 /* If the result is not a valid gimple value, or not a cast
2559 of a valid gimple value, then we can not use the result. */
2560 if (is_gimple_val (new_val)
2561 || (is_gimple_cast (new_val)
2562 && is_gimple_val (TREE_OPERAND (new_val, 0))))
2567 case BUILT_IN_STRCPY:
2568 if (val[1] && is_gimple_val (val[1]) && nargs == 2)
2569 result = fold_builtin_strcpy (callee,
2570 gimple_call_arg (stmt, 0),
2571 gimple_call_arg (stmt, 1),
2575 case BUILT_IN_STRNCPY:
2576 if (val[1] && is_gimple_val (val[1]) && nargs == 3)
2577 result = fold_builtin_strncpy (callee,
2578 gimple_call_arg (stmt, 0),
2579 gimple_call_arg (stmt, 1),
2580 gimple_call_arg (stmt, 2),
2584 case BUILT_IN_FPUTS:
2586 result = fold_builtin_fputs (gimple_call_arg (stmt, 0),
2587 gimple_call_arg (stmt, 1),
2588 ignore, false, val[0]);
2591 case BUILT_IN_FPUTS_UNLOCKED:
2593 result = fold_builtin_fputs (gimple_call_arg (stmt, 0),
2594 gimple_call_arg (stmt, 1),
2595 ignore, true, val[0]);
2598 case BUILT_IN_MEMCPY_CHK:
2599 case BUILT_IN_MEMPCPY_CHK:
2600 case BUILT_IN_MEMMOVE_CHK:
2601 case BUILT_IN_MEMSET_CHK:
2602 if (val[2] && is_gimple_val (val[2]) && nargs == 4)
2603 result = fold_builtin_memory_chk (callee,
2604 gimple_call_arg (stmt, 0),
2605 gimple_call_arg (stmt, 1),
2606 gimple_call_arg (stmt, 2),
2607 gimple_call_arg (stmt, 3),
2609 DECL_FUNCTION_CODE (callee));
2612 case BUILT_IN_STRCPY_CHK:
2613 case BUILT_IN_STPCPY_CHK:
2614 if (val[1] && is_gimple_val (val[1]) && nargs == 3)
2615 result = fold_builtin_stxcpy_chk (callee,
2616 gimple_call_arg (stmt, 0),
2617 gimple_call_arg (stmt, 1),
2618 gimple_call_arg (stmt, 2),
2620 DECL_FUNCTION_CODE (callee));
2623 case BUILT_IN_STRNCPY_CHK:
2624 if (val[2] && is_gimple_val (val[2]) && nargs == 4)
2625 result = fold_builtin_strncpy_chk (gimple_call_arg (stmt, 0),
2626 gimple_call_arg (stmt, 1),
2627 gimple_call_arg (stmt, 2),
2628 gimple_call_arg (stmt, 3),
2632 case BUILT_IN_SNPRINTF_CHK:
2633 case BUILT_IN_VSNPRINTF_CHK:
2634 if (val[1] && is_gimple_val (val[1]))
2635 result = gimple_fold_builtin_snprintf_chk (stmt, val[1],
2636 DECL_FUNCTION_CODE (callee));
2643 if (result && ignore)
2644 result = fold_ignored_result (result);
2648 /* Attempt to fold an assignment statement pointed-to by SI. Returns a
2649 replacement rhs for the statement or NULL_TREE if no simplification
2650 could be made. It is assumed that the operands have been previously
2654 fold_gimple_assign (gimple_stmt_iterator *si)
2656 gimple stmt = gsi_stmt (*si);
2657 enum tree_code subcode = gimple_assign_rhs_code (stmt);
2661 switch (get_gimple_rhs_class (subcode))
2663 case GIMPLE_SINGLE_RHS:
2665 tree rhs = gimple_assign_rhs1 (stmt);
2667 /* Try to fold a conditional expression. */
2668 if (TREE_CODE (rhs) == COND_EXPR)
2670 tree temp = fold (COND_EXPR_COND (rhs));
2671 if (temp != COND_EXPR_COND (rhs))
2672 result = fold_build3 (COND_EXPR, TREE_TYPE (rhs), temp,
2673 COND_EXPR_THEN (rhs), COND_EXPR_ELSE (rhs));
2676 /* If we couldn't fold the RHS, hand over to the generic
2678 if (result == NULL_TREE)
2679 result = fold (rhs);
2681 /* Strip away useless type conversions. Both the NON_LVALUE_EXPR
2682 that may have been added by fold, and "useless" type
2683 conversions that might now be apparent due to propagation. */
2684 STRIP_USELESS_TYPE_CONVERSION (result);
2686 if (result != rhs && valid_gimple_rhs_p (result))
2689 /* It is possible that fold_stmt_r simplified the RHS.
2690 Make sure that the subcode of this statement still
2691 reflects the principal operator of the rhs operand. */
2696 case GIMPLE_UNARY_RHS:
2698 tree rhs = gimple_assign_rhs1 (stmt);
2700 result = fold_unary (subcode, gimple_expr_type (stmt), rhs);
2703 /* If the operation was a conversion do _not_ mark a
2704 resulting constant with TREE_OVERFLOW if the original
2705 constant was not. These conversions have implementation
2706 defined behavior and retaining the TREE_OVERFLOW flag
2707 here would confuse later passes such as VRP. */
2708 if (CONVERT_EXPR_CODE_P (subcode)
2709 && TREE_CODE (result) == INTEGER_CST
2710 && TREE_CODE (rhs) == INTEGER_CST)
2711 TREE_OVERFLOW (result) = TREE_OVERFLOW (rhs);
2713 STRIP_USELESS_TYPE_CONVERSION (result);
2714 if (valid_gimple_rhs_p (result))
2717 else if (CONVERT_EXPR_CODE_P (subcode)
2718 && POINTER_TYPE_P (gimple_expr_type (stmt))
2719 && POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
2721 tree type = gimple_expr_type (stmt);
2722 tree t = maybe_fold_offset_to_address (gimple_assign_rhs1 (stmt),
2723 integer_zero_node, type);
2730 case GIMPLE_BINARY_RHS:
2731 /* Try to fold pointer addition. */
2732 if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
2734 tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
2735 if (TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
2737 type = build_pointer_type (TREE_TYPE (TREE_TYPE (type)));
2738 if (!useless_type_conversion_p
2739 (TREE_TYPE (gimple_assign_lhs (stmt)), type))
2740 type = TREE_TYPE (gimple_assign_rhs1 (stmt));
2742 result = maybe_fold_stmt_addition (type,
2743 gimple_assign_rhs1 (stmt),
2744 gimple_assign_rhs2 (stmt));
2748 result = fold_binary (subcode,
2749 TREE_TYPE (gimple_assign_lhs (stmt)),
2750 gimple_assign_rhs1 (stmt),
2751 gimple_assign_rhs2 (stmt));
2755 STRIP_USELESS_TYPE_CONVERSION (result);
2756 if (valid_gimple_rhs_p (result))
2759 /* Fold might have produced non-GIMPLE, so if we trust it blindly
2760 we lose canonicalization opportunities. Do not go again
2761 through fold here though, or the same non-GIMPLE will be
2763 if (commutative_tree_code (subcode)
2764 && tree_swap_operands_p (gimple_assign_rhs1 (stmt),
2765 gimple_assign_rhs2 (stmt), false))
2766 return build2 (subcode, TREE_TYPE (gimple_assign_lhs (stmt)),
2767 gimple_assign_rhs2 (stmt),
2768 gimple_assign_rhs1 (stmt));
2772 case GIMPLE_INVALID_RHS:
2779 /* Attempt to fold a conditional statement. Return true if any changes were
2780 made. We only attempt to fold the condition expression, and do not perform
2781 any transformation that would require alteration of the cfg. It is
2782 assumed that the operands have been previously folded. */
2785 fold_gimple_cond (gimple stmt)
2787 tree result = fold_binary (gimple_cond_code (stmt),
2789 gimple_cond_lhs (stmt),
2790 gimple_cond_rhs (stmt));
2794 STRIP_USELESS_TYPE_CONVERSION (result);
2795 if (is_gimple_condexpr (result) && valid_gimple_rhs_p (result))
2797 gimple_cond_set_condition_from_tree (stmt, result);
2806 /* Attempt to fold a call statement referenced by the statement iterator GSI.
2807 The statement may be replaced by another statement, e.g., if the call
2808 simplifies to a constant value. Return true if any changes were made.
2809 It is assumed that the operands have been previously folded. */
2812 fold_gimple_call (gimple_stmt_iterator *gsi)
2814 gimple stmt = gsi_stmt (*gsi);
2816 tree callee = gimple_call_fndecl (stmt);
2818 /* Check for builtins that CCP can handle using information not
2819 available in the generic fold routines. */
2820 if (callee && DECL_BUILT_IN (callee))
2822 tree result = ccp_fold_builtin (stmt);
2825 return update_call_from_tree (gsi, result);
2829 /* Check for resolvable OBJ_TYPE_REF. The only sorts we can resolve
2830 here are when we've propagated the address of a decl into the
2832 /* ??? Should perhaps do this in fold proper. However, doing it
2833 there requires that we create a new CALL_EXPR, and that requires
2834 copying EH region info to the new node. Easier to just do it
2835 here where we can just smash the call operand. */
2836 /* ??? Is there a good reason not to do this in fold_stmt_inplace? */
2837 callee = gimple_call_fn (stmt);
2838 if (TREE_CODE (callee) == OBJ_TYPE_REF
2839 && lang_hooks.fold_obj_type_ref
2840 && TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
2841 && DECL_P (TREE_OPERAND
2842 (OBJ_TYPE_REF_OBJECT (callee), 0)))
2846 /* ??? Caution: Broken ADDR_EXPR semantics means that
2847 looking at the type of the operand of the addr_expr
2848 can yield an array type. See silly exception in
2849 check_pointer_types_r. */
2850 t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
2851 t = lang_hooks.fold_obj_type_ref (callee, t);
2854 gimple_call_set_fn (stmt, t);
2863 /* Fold the statement pointed to by GSI. In some cases, this function may
2864 replace the whole statement with a new one. Returns true iff folding
2865 makes any changes. */
2868 fold_stmt (gimple_stmt_iterator *gsi)
2871 struct fold_stmt_r_data fold_stmt_r_data;
2872 struct walk_stmt_info wi;
2874 bool changed = false;
2875 bool inside_addr_expr = false;
2877 gimple stmt = gsi_stmt (*gsi);
2879 fold_stmt_r_data.stmt = stmt;
2880 fold_stmt_r_data.changed_p = &changed;
2881 fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
2883 memset (&wi, 0, sizeof (wi));
2884 wi.info = &fold_stmt_r_data;
2886 /* Fold the individual operands.
2887 For example, fold instances of *&VAR into VAR, etc. */
2888 res = walk_gimple_op (stmt, fold_stmt_r, &wi);
2891 /* Fold the main computation performed by the statement. */
2892 switch (gimple_code (stmt))
2896 tree new_rhs = fold_gimple_assign (gsi);
2897 if (new_rhs != NULL_TREE)
2899 gimple_assign_set_rhs_from_tree (gsi, new_rhs);
2902 stmt = gsi_stmt (*gsi);
2906 changed |= fold_gimple_cond (stmt);
2909 /* The entire statement may be replaced in this case. */
2910 changed |= fold_gimple_call (gsi);
2921 /* Perform the minimal folding on statement STMT. Only operations like
2922 *&x created by constant propagation are handled. The statement cannot
2923 be replaced with a new one. Return true if the statement was
2924 changed, false otherwise. */
2927 fold_stmt_inplace (gimple stmt)
2930 struct fold_stmt_r_data fold_stmt_r_data;
2931 struct walk_stmt_info wi;
2932 gimple_stmt_iterator si;
2934 bool changed = false;
2935 bool inside_addr_expr = false;
2937 fold_stmt_r_data.stmt = stmt;
2938 fold_stmt_r_data.changed_p = &changed;
2939 fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
2941 memset (&wi, 0, sizeof (wi));
2942 wi.info = &fold_stmt_r_data;
2944 /* Fold the individual operands.
2945 For example, fold instances of *&VAR into VAR, etc.
2947 It appears that, at one time, maybe_fold_stmt_indirect
2948 would cause the walk to return non-null in order to
2949 signal that the entire statement should be replaced with
2950 a call to _builtin_trap. This functionality is currently
2951 disabled, as noted in a FIXME, and cannot be supported here. */
2952 res = walk_gimple_op (stmt, fold_stmt_r, &wi);
2955 /* Fold the main computation performed by the statement. */
2956 switch (gimple_code (stmt))
2960 unsigned old_num_ops;
2962 old_num_ops = gimple_num_ops (stmt);
2963 si = gsi_for_stmt (stmt);
2964 new_rhs = fold_gimple_assign (&si);
2965 if (new_rhs != NULL_TREE
2966 && get_gimple_rhs_num_ops (TREE_CODE (new_rhs)) < old_num_ops)
2968 gimple_assign_set_rhs_from_tree (&si, new_rhs);
2971 gcc_assert (gsi_stmt (si) == stmt);
2975 changed |= fold_gimple_cond (stmt);
2985 /* Try to optimize out __builtin_stack_restore. Optimize it out
2986 if there is another __builtin_stack_restore in the same basic
2987 block and no calls or ASM_EXPRs are in between, or if this block's
2988 only outgoing edge is to EXIT_BLOCK and there are no calls or
2989 ASM_EXPRs after this __builtin_stack_restore. */
2992 optimize_stack_restore (gimple_stmt_iterator i)
2995 gimple stmt, stack_save;
2996 gimple_stmt_iterator stack_save_gsi;
2998 basic_block bb = gsi_bb (i);
2999 gimple call = gsi_stmt (i);
3001 if (gimple_code (call) != GIMPLE_CALL
3002 || gimple_call_num_args (call) != 1
3003 || TREE_CODE (gimple_call_arg (call, 0)) != SSA_NAME
3004 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call, 0))))
3007 for (gsi_next (&i); !gsi_end_p (i); gsi_next (&i))
3009 stmt = gsi_stmt (i);
3010 if (gimple_code (stmt) == GIMPLE_ASM)
3012 if (gimple_code (stmt) != GIMPLE_CALL)
3015 callee = gimple_call_fndecl (stmt);
3016 if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
3019 if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
3024 && (! single_succ_p (bb)
3025 || single_succ_edge (bb)->dest != EXIT_BLOCK_PTR))
3028 stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
3029 if (gimple_code (stack_save) != GIMPLE_CALL
3030 || gimple_call_lhs (stack_save) != gimple_call_arg (call, 0)
3031 || stmt_could_throw_p (stack_save)
3032 || !has_single_use (gimple_call_arg (call, 0)))
3035 callee = gimple_call_fndecl (stack_save);
3037 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
3038 || DECL_FUNCTION_CODE (callee) != BUILT_IN_STACK_SAVE
3039 || gimple_call_num_args (stack_save) != 0)
3042 stack_save_gsi = gsi_for_stmt (stack_save);
3043 push_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
3044 rhs = build_int_cst (TREE_TYPE (gimple_call_arg (call, 0)), 0);
3045 if (!update_call_from_tree (&stack_save_gsi, rhs))
3047 discard_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
3050 pop_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
3052 /* No effect, so the statement will be deleted. */
3053 return integer_zero_node;
3056 /* If va_list type is a simple pointer and nothing special is needed,
3057 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
3058 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
3059 pointer assignment. */
3062 optimize_stdarg_builtin (gimple call)
3064 tree callee, lhs, rhs, cfun_va_list;
3065 bool va_list_simple_ptr;
3067 if (gimple_code (call) != GIMPLE_CALL)
3070 callee = gimple_call_fndecl (call);
3072 cfun_va_list = targetm.fn_abi_va_list (callee);
3073 va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
3074 && (TREE_TYPE (cfun_va_list) == void_type_node
3075 || TREE_TYPE (cfun_va_list) == char_type_node);
3077 switch (DECL_FUNCTION_CODE (callee))
3079 case BUILT_IN_VA_START:
3080 if (!va_list_simple_ptr
3081 || targetm.expand_builtin_va_start != NULL
3082 || built_in_decls[BUILT_IN_NEXT_ARG] == NULL)
3085 if (gimple_call_num_args (call) != 2)
3088 lhs = gimple_call_arg (call, 0);
3089 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
3090 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
3091 != TYPE_MAIN_VARIANT (cfun_va_list))
3094 lhs = build_fold_indirect_ref (lhs);
3095 rhs = build_call_expr (built_in_decls[BUILT_IN_NEXT_ARG],
3096 1, integer_zero_node);
3097 rhs = fold_convert (TREE_TYPE (lhs), rhs);
3098 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
3100 case BUILT_IN_VA_COPY:
3101 if (!va_list_simple_ptr)
3104 if (gimple_call_num_args (call) != 2)
3107 lhs = gimple_call_arg (call, 0);
3108 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
3109 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
3110 != TYPE_MAIN_VARIANT (cfun_va_list))
3113 lhs = build_fold_indirect_ref (lhs);
3114 rhs = gimple_call_arg (call, 1);
3115 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs))
3116 != TYPE_MAIN_VARIANT (cfun_va_list))
3119 rhs = fold_convert (TREE_TYPE (lhs), rhs);
3120 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
3122 case BUILT_IN_VA_END:
3123 /* No effect, so the statement will be deleted. */
3124 return integer_zero_node;
3131 /* Convert EXPR into a GIMPLE value suitable for substitution on the
3132 RHS of an assignment. Insert the necessary statements before
3133 iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
3134 is replaced. If the call is expected to produces a result, then it
3135 is replaced by an assignment of the new RHS to the result variable.
3136 If the result is to be ignored, then the call is replaced by a
3140 gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
3143 tree tmp = NULL_TREE; /* Silence warning. */
3144 gimple stmt, new_stmt;
3145 gimple_stmt_iterator i;
3146 gimple_seq stmts = gimple_seq_alloc();
3147 struct gimplify_ctx gctx;
3149 stmt = gsi_stmt (*si_p);
3151 gcc_assert (is_gimple_call (stmt));
3153 lhs = gimple_call_lhs (stmt);
3155 push_gimplify_context (&gctx);
3157 if (lhs == NULL_TREE)
3158 gimplify_and_add (expr, &stmts);
3160 tmp = get_initialized_tmp_var (expr, &stmts, NULL);
3162 pop_gimplify_context (NULL);
3164 if (gimple_has_location (stmt))
3165 annotate_all_with_location (stmts, gimple_location (stmt));
3167 /* The replacement can expose previously unreferenced variables. */
3168 for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
3170 new_stmt = gsi_stmt (i);
3171 find_new_referenced_vars (new_stmt);
3172 gsi_insert_before (si_p, new_stmt, GSI_NEW_STMT);
3173 mark_symbols_for_renaming (new_stmt);
3177 if (lhs == NULL_TREE)
3179 new_stmt = gimple_build_nop ();
3180 unlink_stmt_vdef (stmt);
3181 release_defs (stmt);
3185 new_stmt = gimple_build_assign (lhs, tmp);
3186 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
3187 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
3188 move_ssa_defining_stmt_for_defs (new_stmt, stmt);
3191 gimple_set_location (new_stmt, gimple_location (stmt));
3192 gsi_replace (si_p, new_stmt, false);
3195 /* A simple pass that attempts to fold all builtin functions. This pass
3196 is run after we've propagated as many constants as we can. */
3199 execute_fold_all_builtins (void)
3201 bool cfg_changed = false;
3203 unsigned int todoflags = 0;
3207 gimple_stmt_iterator i;
3208 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
3210 gimple stmt, old_stmt;
3211 tree callee, result;
3212 enum built_in_function fcode;
3214 stmt = gsi_stmt (i);
3216 if (gimple_code (stmt) != GIMPLE_CALL)
3221 callee = gimple_call_fndecl (stmt);
3222 if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
3227 fcode = DECL_FUNCTION_CODE (callee);
3229 result = ccp_fold_builtin (stmt);
3232 gimple_remove_stmt_histograms (cfun, stmt);
3235 switch (DECL_FUNCTION_CODE (callee))
3237 case BUILT_IN_CONSTANT_P:
3238 /* Resolve __builtin_constant_p. If it hasn't been
3239 folded to integer_one_node by now, it's fairly
3240 certain that the value simply isn't constant. */
3241 result = integer_zero_node;
3244 case BUILT_IN_STACK_RESTORE:
3245 result = optimize_stack_restore (i);
3251 case BUILT_IN_VA_START:
3252 case BUILT_IN_VA_END:
3253 case BUILT_IN_VA_COPY:
3254 /* These shouldn't be folded before pass_stdarg. */
3255 result = optimize_stdarg_builtin (stmt);
3265 if (dump_file && (dump_flags & TDF_DETAILS))
3267 fprintf (dump_file, "Simplified\n ");
3268 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3272 push_stmt_changes (gsi_stmt_ptr (&i));
3274 if (!update_call_from_tree (&i, result))
3276 gimplify_and_update_call_from_tree (&i, result);
3277 todoflags |= TODO_update_address_taken;
3280 stmt = gsi_stmt (i);
3281 pop_stmt_changes (gsi_stmt_ptr (&i));
3283 if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt)
3284 && gimple_purge_dead_eh_edges (bb))
3287 if (dump_file && (dump_flags & TDF_DETAILS))
3289 fprintf (dump_file, "to\n ");
3290 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3291 fprintf (dump_file, "\n");
3294 /* Retry the same statement if it changed into another
3295 builtin, there might be new opportunities now. */
3296 if (gimple_code (stmt) != GIMPLE_CALL)
3301 callee = gimple_call_fndecl (stmt);
3303 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
3304 || DECL_FUNCTION_CODE (callee) == fcode)
3309 /* Delete unreachable blocks. */
3311 todoflags |= TODO_cleanup_cfg;
3317 struct gimple_opt_pass pass_fold_builtins =
3323 execute_fold_all_builtins, /* execute */
3326 0, /* static_pass_number */
3328 PROP_cfg | PROP_ssa, /* properties_required */
3329 0, /* properties_provided */
3330 0, /* properties_destroyed */
3331 0, /* todo_flags_start */
3334 | TODO_update_ssa /* todo_flags_finish */