Skip various cmp-mem-const tests on lp64 hppa*-*-*
[official-gcc.git] / gcc / var-tracking.cc
blobfd3aafb6418374a9ae85b2e5f04b52bfdbf53a32
1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2024 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
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/>. */
20 /* This file contains the variable tracking pass. It computes where
21 variables are located (which registers or where in memory) at each position
22 in instruction stream and emits notes describing the locations.
23 Debug information (DWARF2 location lists) is finally generated from
24 these notes.
25 With this debug information, it is possible to show variables
26 even when debugging optimized code.
28 How does the variable tracking pass work?
30 First, it scans RTL code for uses, stores and clobbers (register/memory
31 references in instructions), for call insns and for stack adjustments
32 separately for each basic block and saves them to an array of micro
33 operations.
34 The micro operations of one instruction are ordered so that
35 pre-modifying stack adjustment < use < use with no var < call insn <
36 < clobber < set < post-modifying stack adjustment
38 Then, a forward dataflow analysis is performed to find out how locations
39 of variables change through code and to propagate the variable locations
40 along control flow graph.
41 The IN set for basic block BB is computed as a union of OUT sets of BB's
42 predecessors, the OUT set for BB is copied from the IN set for BB and
43 is changed according to micro operations in BB.
45 The IN and OUT sets for basic blocks consist of a current stack adjustment
46 (used for adjusting offset of variables addressed using stack pointer),
47 the table of structures describing the locations of parts of a variable
48 and for each physical register a linked list for each physical register.
49 The linked list is a list of variable parts stored in the register,
50 i.e. it is a list of triplets (reg, decl, offset) where decl is
51 REG_EXPR (reg) and offset is REG_OFFSET (reg). The linked list is used for
52 effective deleting appropriate variable parts when we set or clobber the
53 register.
55 There may be more than one variable part in a register. The linked lists
56 should be pretty short so it is a good data structure here.
57 For example in the following code, register allocator may assign same
58 register to variables A and B, and both of them are stored in the same
59 register in CODE:
61 if (cond)
62 set A;
63 else
64 set B;
65 CODE;
66 if (cond)
67 use A;
68 else
69 use B;
71 Finally, the NOTE_INSN_VAR_LOCATION notes describing the variable locations
72 are emitted to appropriate positions in RTL code. Each such a note describes
73 the location of one variable at the point in instruction stream where the
74 note is. There is no need to emit a note for each variable before each
75 instruction, we only emit these notes where the location of variable changes
76 (this means that we also emit notes for changes between the OUT set of the
77 previous block and the IN set of the current block).
79 The notes consist of two parts:
80 1. the declaration (from REG_EXPR or MEM_EXPR)
81 2. the location of a variable - it is either a simple register/memory
82 reference (for simple variables, for example int),
83 or a parallel of register/memory references (for a large variables
84 which consist of several parts, for example long long).
88 #include "config.h"
89 #include "system.h"
90 #include "coretypes.h"
91 #include "backend.h"
92 #include "target.h"
93 #include "rtl.h"
94 #include "tree.h"
95 #include "cfghooks.h"
96 #include "alloc-pool.h"
97 #include "tree-pass.h"
98 #include "memmodel.h"
99 #include "tm_p.h"
100 #include "insn-config.h"
101 #include "regs.h"
102 #include "emit-rtl.h"
103 #include "recog.h"
104 #include "diagnostic.h"
105 #include "varasm.h"
106 #include "stor-layout.h"
107 #include "cfgrtl.h"
108 #include "cfganal.h"
109 #include "reload.h"
110 #include "ira.h"
111 #include "lra.h"
112 #include "calls.h"
113 #include "tree-dfa.h"
114 #include "tree-ssa.h"
115 #include "cselib.h"
116 #include "tree-pretty-print.h"
117 #include "rtl-iter.h"
118 #include "fibonacci_heap.h"
119 #include "print-rtl.h"
120 #include "function-abi.h"
121 #include "mux-utils.h"
123 typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
125 /* var-tracking.cc assumes that tree code with the same value as VALUE rtx code
126 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
127 Currently the value is the same as IDENTIFIER_NODE, which has such
128 a property. If this compile time assertion ever fails, make sure that
129 the new tree code that equals (int) VALUE has the same property. */
130 extern char check_value_val[(int) VALUE == (int) IDENTIFIER_NODE ? 1 : -1];
132 /* Type of micro operation. */
133 enum micro_operation_type
135 MO_USE, /* Use location (REG or MEM). */
136 MO_USE_NO_VAR,/* Use location which is not associated with a variable
137 or the variable is not trackable. */
138 MO_VAL_USE, /* Use location which is associated with a value. */
139 MO_VAL_LOC, /* Use location which appears in a debug insn. */
140 MO_VAL_SET, /* Set location associated with a value. */
141 MO_SET, /* Set location. */
142 MO_COPY, /* Copy the same portion of a variable from one
143 location to another. */
144 MO_CLOBBER, /* Clobber location. */
145 MO_CALL, /* Call insn. */
146 MO_ADJUST /* Adjust stack pointer. */
150 static const char * const ATTRIBUTE_UNUSED
151 micro_operation_type_name[] = {
152 "MO_USE",
153 "MO_USE_NO_VAR",
154 "MO_VAL_USE",
155 "MO_VAL_LOC",
156 "MO_VAL_SET",
157 "MO_SET",
158 "MO_COPY",
159 "MO_CLOBBER",
160 "MO_CALL",
161 "MO_ADJUST"
164 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
165 Notes emitted as AFTER_CALL are to take effect during the call,
166 rather than after the call. */
167 enum emit_note_where
169 EMIT_NOTE_BEFORE_INSN,
170 EMIT_NOTE_AFTER_INSN,
171 EMIT_NOTE_AFTER_CALL_INSN
174 /* Structure holding information about micro operation. */
175 struct micro_operation
177 /* Type of micro operation. */
178 enum micro_operation_type type;
180 /* The instruction which the micro operation is in, for MO_USE,
181 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
182 instruction or note in the original flow (before any var-tracking
183 notes are inserted, to simplify emission of notes), for MO_SET
184 and MO_CLOBBER. */
185 rtx_insn *insn;
187 union {
188 /* Location. For MO_SET and MO_COPY, this is the SET that
189 performs the assignment, if known, otherwise it is the target
190 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
191 CONCAT of the VALUE and the LOC associated with it. For
192 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
193 associated with it. */
194 rtx loc;
196 /* Stack adjustment. */
197 HOST_WIDE_INT adjust;
198 } u;
202 /* A declaration of a variable, or an RTL value being handled like a
203 declaration by pointer_mux. */
204 typedef pointer_mux<tree_node, rtx_def> decl_or_value;
206 /* Return true if a decl_or_value DV is a DECL or NULL. */
207 static inline bool
208 dv_is_decl_p (decl_or_value dv)
210 return dv.is_first ();
213 /* Return true if a decl_or_value is a VALUE rtl. */
214 static inline bool
215 dv_is_value_p (decl_or_value dv)
217 return dv && !dv_is_decl_p (dv);
220 /* Return the decl in the decl_or_value. */
221 static inline tree
222 dv_as_decl (decl_or_value dv)
224 gcc_checking_assert (dv_is_decl_p (dv));
225 return dv.known_first ();
228 /* Return the value in the decl_or_value. */
229 static inline rtx
230 dv_as_value (decl_or_value dv)
232 gcc_checking_assert (dv_is_value_p (dv));
233 return dv.known_second ();
237 /* Description of location of a part of a variable. The content of a physical
238 register is described by a chain of these structures.
239 The chains are pretty short (usually 1 or 2 elements) and thus
240 chain is the best data structure. */
241 struct attrs
243 /* Pointer to next member of the list. */
244 attrs *next;
246 /* The rtx of register. */
247 rtx loc;
249 /* The declaration corresponding to LOC. */
250 decl_or_value dv;
252 /* Offset from start of DECL. */
253 HOST_WIDE_INT offset;
256 /* Structure for chaining the locations. */
257 struct location_chain
259 /* Next element in the chain. */
260 location_chain *next;
262 /* The location (REG, MEM or VALUE). */
263 rtx loc;
265 /* The "value" stored in this location. */
266 rtx set_src;
268 /* Initialized? */
269 enum var_init_status init;
272 /* A vector of loc_exp_dep holds the active dependencies of a one-part
273 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
274 location of DV. Each entry is also part of VALUE' s linked-list of
275 backlinks back to DV. */
276 struct loc_exp_dep
278 /* The dependent DV. */
279 decl_or_value dv;
280 /* The dependency VALUE or DECL_DEBUG. */
281 rtx value;
282 /* The next entry in VALUE's backlinks list. */
283 struct loc_exp_dep *next;
284 /* A pointer to the pointer to this entry (head or prev's next) in
285 the doubly-linked list. */
286 struct loc_exp_dep **pprev;
290 /* This data structure holds information about the depth of a variable
291 expansion. */
292 struct expand_depth
294 /* This measures the complexity of the expanded expression. It
295 grows by one for each level of expansion that adds more than one
296 operand. */
297 int complexity;
298 /* This counts the number of ENTRY_VALUE expressions in an
299 expansion. We want to minimize their use. */
300 int entryvals;
303 /* Type for dependencies actively used when expand FROM into cur_loc. */
304 typedef vec<loc_exp_dep, va_heap, vl_embed> deps_vec;
306 /* This data structure is allocated for one-part variables at the time
307 of emitting notes. */
308 struct onepart_aux
310 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
311 computation used the expansion of this variable, and that ought
312 to be notified should this variable change. If the DV's cur_loc
313 expanded to NULL, all components of the loc list are regarded as
314 active, so that any changes in them give us a chance to get a
315 location. Otherwise, only components of the loc that expanded to
316 non-NULL are regarded as active dependencies. */
317 loc_exp_dep *backlinks;
318 /* This holds the LOC that was expanded into cur_loc. We need only
319 mark a one-part variable as changed if the FROM loc is removed,
320 or if it has no known location and a loc is added, or if it gets
321 a change notification from any of its active dependencies. */
322 rtx from;
323 /* The depth of the cur_loc expression. */
324 expand_depth depth;
325 /* Dependencies actively used when expand FROM into cur_loc. */
326 deps_vec deps;
329 /* Structure describing one part of variable. */
330 struct variable_part
332 /* Chain of locations of the part. */
333 location_chain *loc_chain;
335 /* Location which was last emitted to location list. */
336 rtx cur_loc;
338 union variable_aux
340 /* The offset in the variable, if !var->onepart. */
341 HOST_WIDE_INT offset;
343 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
344 struct onepart_aux *onepaux;
345 } aux;
348 /* Maximum number of location parts. */
349 #define MAX_VAR_PARTS 16
351 /* Enumeration type used to discriminate various types of one-part
352 variables. */
353 enum onepart_enum
355 /* Not a one-part variable. */
356 NOT_ONEPART = 0,
357 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
358 ONEPART_VDECL = 1,
359 /* A DEBUG_EXPR_DECL. */
360 ONEPART_DEXPR = 2,
361 /* A VALUE. */
362 ONEPART_VALUE = 3
365 /* Structure describing where the variable is located. */
366 struct variable
368 /* The declaration of the variable, or an RTL value being handled
369 like a declaration. */
370 decl_or_value dv;
372 /* Reference count. */
373 int refcount;
375 /* Number of variable parts. */
376 char n_var_parts;
378 /* What type of DV this is, according to enum onepart_enum. */
379 ENUM_BITFIELD (onepart_enum) onepart : CHAR_BIT;
381 /* True if this variable_def struct is currently in the
382 changed_variables hash table. */
383 bool in_changed_variables;
385 /* The variable parts. */
386 variable_part var_part[1];
389 /* Pointer to the BB's information specific to variable tracking pass. */
390 #define VTI(BB) ((variable_tracking_info *) (BB)->aux)
392 /* Return MEM_OFFSET (MEM) as a HOST_WIDE_INT, or 0 if we can't. */
394 static inline HOST_WIDE_INT
395 int_mem_offset (const_rtx mem)
397 HOST_WIDE_INT offset;
398 if (MEM_OFFSET_KNOWN_P (mem) && MEM_OFFSET (mem).is_constant (&offset))
399 return offset;
400 return 0;
403 #if CHECKING_P && (GCC_VERSION >= 2007)
405 /* Access VAR's Ith part's offset, checking that it's not a one-part
406 variable. */
407 #define VAR_PART_OFFSET(var, i) __extension__ \
408 (*({ variable *const __v = (var); \
409 gcc_checking_assert (!__v->onepart); \
410 &__v->var_part[(i)].aux.offset; }))
412 /* Access VAR's one-part auxiliary data, checking that it is a
413 one-part variable. */
414 #define VAR_LOC_1PAUX(var) __extension__ \
415 (*({ variable *const __v = (var); \
416 gcc_checking_assert (__v->onepart); \
417 &__v->var_part[0].aux.onepaux; }))
419 #else
420 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
421 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
422 #endif
424 /* These are accessor macros for the one-part auxiliary data. When
425 convenient for users, they're guarded by tests that the data was
426 allocated. */
427 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
428 ? VAR_LOC_1PAUX (var)->backlinks \
429 : NULL)
430 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
431 ? &VAR_LOC_1PAUX (var)->backlinks \
432 : NULL)
433 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
434 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
435 #define VAR_LOC_DEP_VEC(var) var_loc_dep_vec (var)
437 /* Implements the VAR_LOC_DEP_VEC above as a function to work around
438 a bogus -Wnonnull (PR c/95554). */
440 static inline deps_vec*
441 var_loc_dep_vec (variable *var)
443 return VAR_LOC_1PAUX (var) ? &VAR_LOC_1PAUX (var)->deps : NULL;
447 typedef unsigned int dvuid;
449 /* Return the uid of DV. */
451 static inline dvuid
452 dv_uid (decl_or_value dv)
454 if (dv_is_value_p (dv))
455 return CSELIB_VAL_PTR (dv_as_value (dv))->uid;
456 else
457 return DECL_UID (dv_as_decl (dv));
460 /* Compute the hash from the uid. */
462 static inline hashval_t
463 dv_uid2hash (dvuid uid)
465 return uid;
468 /* The hash function for a mask table in a shared_htab chain. */
470 static inline hashval_t
471 dv_htab_hash (decl_or_value dv)
473 return dv_uid2hash (dv_uid (dv));
476 static void variable_htab_free (void *);
478 /* Variable hashtable helpers. */
480 struct variable_hasher : pointer_hash <variable>
482 typedef decl_or_value compare_type;
483 static inline hashval_t hash (const variable *);
484 static inline bool equal (const variable *, const decl_or_value);
485 static inline void remove (variable *);
488 /* The hash function for variable_htab, computes the hash value
489 from the declaration of variable X. */
491 inline hashval_t
492 variable_hasher::hash (const variable *v)
494 return dv_htab_hash (v->dv);
497 /* Compare the declaration of variable X with declaration Y. */
499 inline bool
500 variable_hasher::equal (const variable *v, const decl_or_value y)
502 return v->dv == y;
505 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
507 inline void
508 variable_hasher::remove (variable *var)
510 variable_htab_free (var);
513 typedef hash_table<variable_hasher> variable_table_type;
514 typedef variable_table_type::iterator variable_iterator_type;
516 /* Structure for passing some other parameters to function
517 emit_note_insn_var_location. */
518 struct emit_note_data
520 /* The instruction which the note will be emitted before/after. */
521 rtx_insn *insn;
523 /* Where the note will be emitted (before/after insn)? */
524 enum emit_note_where where;
526 /* The variables and values active at this point. */
527 variable_table_type *vars;
530 /* Structure holding a refcounted hash table. If refcount > 1,
531 it must be first unshared before modified. */
532 struct shared_hash
534 /* Reference count. */
535 int refcount;
537 /* Actual hash table. */
538 variable_table_type *htab;
541 /* Structure holding the IN or OUT set for a basic block. */
542 struct dataflow_set
544 /* Adjustment of stack offset. */
545 HOST_WIDE_INT stack_adjust;
547 /* Attributes for registers (lists of attrs). */
548 attrs *regs[FIRST_PSEUDO_REGISTER];
550 /* Variable locations. */
551 shared_hash *vars;
553 /* Vars that is being traversed. */
554 shared_hash *traversed_vars;
557 /* The structure (one for each basic block) containing the information
558 needed for variable tracking. */
559 struct variable_tracking_info
561 /* The vector of micro operations. */
562 vec<micro_operation> mos;
564 /* The IN and OUT set for dataflow analysis. */
565 dataflow_set in;
566 dataflow_set out;
568 /* The permanent-in dataflow set for this block. This is used to
569 hold values for which we had to compute entry values. ??? This
570 should probably be dynamically allocated, to avoid using more
571 memory in non-debug builds. */
572 dataflow_set *permp;
574 /* Has the block been visited in DFS? */
575 bool visited;
577 /* Has the block been flooded in VTA? */
578 bool flooded;
582 /* Alloc pool for struct attrs_def. */
583 object_allocator<attrs> attrs_pool ("attrs pool");
585 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
587 static pool_allocator var_pool
588 ("variable_def pool", sizeof (variable) +
589 (MAX_VAR_PARTS - 1) * sizeof (((variable *)NULL)->var_part[0]));
591 /* Alloc pool for struct variable_def with a single var_part entry. */
592 static pool_allocator valvar_pool
593 ("small variable_def pool", sizeof (variable));
595 /* Alloc pool for struct location_chain. */
596 static object_allocator<location_chain> location_chain_pool
597 ("location_chain pool");
599 /* Alloc pool for struct shared_hash. */
600 static object_allocator<shared_hash> shared_hash_pool ("shared_hash pool");
602 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
603 object_allocator<loc_exp_dep> loc_exp_dep_pool ("loc_exp_dep pool");
605 /* Changed variables, notes will be emitted for them. */
606 static variable_table_type *changed_variables;
608 /* Shall notes be emitted? */
609 static bool emit_notes;
611 /* Values whose dynamic location lists have gone empty, but whose
612 cselib location lists are still usable. Use this to hold the
613 current location, the backlinks, etc, during emit_notes. */
614 static variable_table_type *dropped_values;
616 /* Empty shared hashtable. */
617 static shared_hash *empty_shared_hash;
619 /* Scratch register bitmap used by cselib_expand_value_rtx. */
620 static bitmap scratch_regs = NULL;
622 #ifdef HAVE_window_save
623 struct GTY(()) parm_reg {
624 rtx outgoing;
625 rtx incoming;
629 /* Vector of windowed parameter registers, if any. */
630 static vec<parm_reg, va_gc> *windowed_parm_regs = NULL;
631 #endif
633 /* Variable used to tell whether cselib_process_insn called our hook. */
634 static bool cselib_hook_called;
636 /* Local function prototypes. */
637 static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,
638 HOST_WIDE_INT *);
639 static void insn_stack_adjust_offset_pre_post (rtx_insn *, HOST_WIDE_INT *,
640 HOST_WIDE_INT *);
641 static bool vt_stack_adjustments (void);
643 static void init_attrs_list_set (attrs **);
644 static void attrs_list_clear (attrs **);
645 static attrs *attrs_list_member (attrs *, decl_or_value, HOST_WIDE_INT);
646 static void attrs_list_insert (attrs **, decl_or_value, HOST_WIDE_INT, rtx);
647 static void attrs_list_copy (attrs **, attrs *);
648 static void attrs_list_union (attrs **, attrs *);
650 static variable **unshare_variable (dataflow_set *set, variable **slot,
651 variable *var, enum var_init_status);
652 static void vars_copy (variable_table_type *, variable_table_type *);
653 static tree var_debug_decl (tree);
654 static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx);
655 static void var_reg_delete_and_set (dataflow_set *, rtx, bool,
656 enum var_init_status, rtx);
657 static void var_reg_delete (dataflow_set *, rtx, bool);
658 static void var_regno_delete (dataflow_set *, int);
659 static void var_mem_set (dataflow_set *, rtx, enum var_init_status, rtx);
660 static void var_mem_delete_and_set (dataflow_set *, rtx, bool,
661 enum var_init_status, rtx);
662 static void var_mem_delete (dataflow_set *, rtx, bool);
664 static void dataflow_set_init (dataflow_set *);
665 static void dataflow_set_clear (dataflow_set *);
666 static void dataflow_set_copy (dataflow_set *, dataflow_set *);
667 static int variable_union_info_cmp_pos (const void *, const void *);
668 static void dataflow_set_union (dataflow_set *, dataflow_set *);
669 static location_chain *find_loc_in_1pdv (rtx, variable *,
670 variable_table_type *);
671 static bool canon_value_cmp (rtx, rtx);
672 static int loc_cmp (rtx, rtx);
673 static bool variable_part_different_p (variable_part *, variable_part *);
674 static bool onepart_variable_different_p (variable *, variable *);
675 static bool variable_different_p (variable *, variable *);
676 static bool dataflow_set_different (dataflow_set *, dataflow_set *);
677 static void dataflow_set_destroy (dataflow_set *);
679 static bool track_expr_p (tree, bool);
680 static void add_uses_1 (rtx *, void *);
681 static void add_stores (rtx, const_rtx, void *);
682 static bool compute_bb_dataflow (basic_block);
683 static bool vt_find_locations (void);
685 static void dump_attrs_list (attrs *);
686 static void dump_var (variable *);
687 static void dump_vars (variable_table_type *);
688 static void dump_dataflow_set (dataflow_set *);
689 static void dump_dataflow_sets (void);
691 static void set_dv_changed (decl_or_value, bool);
692 static void variable_was_changed (variable *, dataflow_set *);
693 static variable **set_slot_part (dataflow_set *, rtx, variable **,
694 decl_or_value, HOST_WIDE_INT,
695 enum var_init_status, rtx);
696 static void set_variable_part (dataflow_set *, rtx,
697 decl_or_value, HOST_WIDE_INT,
698 enum var_init_status, rtx, enum insert_option);
699 static variable **clobber_slot_part (dataflow_set *, rtx,
700 variable **, HOST_WIDE_INT, rtx);
701 static void clobber_variable_part (dataflow_set *, rtx,
702 decl_or_value, HOST_WIDE_INT, rtx);
703 static variable **delete_slot_part (dataflow_set *, rtx, variable **,
704 HOST_WIDE_INT);
705 static void delete_variable_part (dataflow_set *, rtx,
706 decl_or_value, HOST_WIDE_INT);
707 static void emit_notes_in_bb (basic_block, dataflow_set *);
708 static void vt_emit_notes (void);
710 static void vt_add_function_parameters (void);
711 static bool vt_initialize (void);
712 static void vt_finalize (void);
714 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
716 static int
717 stack_adjust_offset_pre_post_cb (rtx, rtx op, rtx dest, rtx src, rtx srcoff,
718 void *arg)
720 if (dest != stack_pointer_rtx)
721 return 0;
723 switch (GET_CODE (op))
725 case PRE_INC:
726 case PRE_DEC:
727 ((HOST_WIDE_INT *)arg)[0] -= INTVAL (srcoff);
728 return 0;
729 case POST_INC:
730 case POST_DEC:
731 ((HOST_WIDE_INT *)arg)[1] -= INTVAL (srcoff);
732 return 0;
733 case PRE_MODIFY:
734 case POST_MODIFY:
735 /* We handle only adjustments by constant amount. */
736 gcc_assert (GET_CODE (src) == PLUS
737 && CONST_INT_P (XEXP (src, 1))
738 && XEXP (src, 0) == stack_pointer_rtx);
739 ((HOST_WIDE_INT *)arg)[GET_CODE (op) == POST_MODIFY]
740 -= INTVAL (XEXP (src, 1));
741 return 0;
742 default:
743 gcc_unreachable ();
747 /* Given a SET, calculate the amount of stack adjustment it contains
748 PRE- and POST-modifying stack pointer.
749 This function is similar to stack_adjust_offset. */
751 static void
752 stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INT *pre,
753 HOST_WIDE_INT *post)
755 rtx src = SET_SRC (pattern);
756 rtx dest = SET_DEST (pattern);
757 enum rtx_code code;
759 if (dest == stack_pointer_rtx)
761 /* (set (reg sp) (plus (reg sp) (const_int))) */
762 code = GET_CODE (src);
763 if (! (code == PLUS || code == MINUS)
764 || XEXP (src, 0) != stack_pointer_rtx
765 || !CONST_INT_P (XEXP (src, 1)))
766 return;
768 if (code == MINUS)
769 *post += INTVAL (XEXP (src, 1));
770 else
771 *post -= INTVAL (XEXP (src, 1));
772 return;
774 HOST_WIDE_INT res[2] = { 0, 0 };
775 for_each_inc_dec (pattern, stack_adjust_offset_pre_post_cb, res);
776 *pre += res[0];
777 *post += res[1];
780 /* Given an INSN, calculate the amount of stack adjustment it contains
781 PRE- and POST-modifying stack pointer. */
783 static void
784 insn_stack_adjust_offset_pre_post (rtx_insn *insn, HOST_WIDE_INT *pre,
785 HOST_WIDE_INT *post)
787 rtx pattern;
789 *pre = 0;
790 *post = 0;
792 pattern = PATTERN (insn);
793 if (RTX_FRAME_RELATED_P (insn))
795 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
796 if (expr)
797 pattern = XEXP (expr, 0);
800 if (GET_CODE (pattern) == SET)
801 stack_adjust_offset_pre_post (pattern, pre, post);
802 else if (GET_CODE (pattern) == PARALLEL
803 || GET_CODE (pattern) == SEQUENCE)
805 int i;
807 /* There may be stack adjustments inside compound insns. Search
808 for them. */
809 for ( i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
810 if (GET_CODE (XVECEXP (pattern, 0, i)) == SET)
811 stack_adjust_offset_pre_post (XVECEXP (pattern, 0, i), pre, post);
815 /* Compute stack adjustments for all blocks by traversing DFS tree.
816 Return true when the adjustments on all incoming edges are consistent.
817 Heavily borrowed from pre_and_rev_post_order_compute. */
819 static bool
820 vt_stack_adjustments (void)
822 edge_iterator *stack;
823 int sp;
825 /* Initialize entry block. */
826 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->visited = true;
827 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->in.stack_adjust
828 = INCOMING_FRAME_SP_OFFSET;
829 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out.stack_adjust
830 = INCOMING_FRAME_SP_OFFSET;
832 /* Allocate stack for back-tracking up CFG. */
833 stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
834 sp = 0;
836 /* Push the first edge on to the stack. */
837 stack[sp++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
839 while (sp)
841 edge_iterator ei;
842 basic_block src;
843 basic_block dest;
845 /* Look at the edge on the top of the stack. */
846 ei = stack[sp - 1];
847 src = ei_edge (ei)->src;
848 dest = ei_edge (ei)->dest;
850 /* Check if the edge destination has been visited yet. */
851 if (!VTI (dest)->visited)
853 rtx_insn *insn;
854 HOST_WIDE_INT pre, post, offset;
855 VTI (dest)->visited = true;
856 VTI (dest)->in.stack_adjust = offset = VTI (src)->out.stack_adjust;
858 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
859 for (insn = BB_HEAD (dest);
860 insn != NEXT_INSN (BB_END (dest));
861 insn = NEXT_INSN (insn))
862 if (INSN_P (insn))
864 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
865 offset += pre + post;
868 VTI (dest)->out.stack_adjust = offset;
870 if (EDGE_COUNT (dest->succs) > 0)
871 /* Since the DEST node has been visited for the first
872 time, check its successors. */
873 stack[sp++] = ei_start (dest->succs);
875 else
877 /* We can end up with different stack adjustments for the exit block
878 of a shrink-wrapped function if stack_adjust_offset_pre_post
879 doesn't understand the rtx pattern used to restore the stack
880 pointer in the epilogue. For example, on s390(x), the stack
881 pointer is often restored via a load-multiple instruction
882 and so no stack_adjust offset is recorded for it. This means
883 that the stack offset at the end of the epilogue block is the
884 same as the offset before the epilogue, whereas other paths
885 to the exit block will have the correct stack_adjust.
887 It is safe to ignore these differences because (a) we never
888 use the stack_adjust for the exit block in this pass and
889 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
890 function are correct.
892 We must check whether the adjustments on other edges are
893 the same though. */
894 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
895 && VTI (dest)->in.stack_adjust != VTI (src)->out.stack_adjust)
897 free (stack);
898 return false;
901 if (! ei_one_before_end_p (ei))
902 /* Go to the next edge. */
903 ei_next (&stack[sp - 1]);
904 else
905 /* Return to previous level if there are no more edges. */
906 sp--;
910 free (stack);
911 return true;
914 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
915 hard_frame_pointer_rtx is being mapped to it and offset for it. */
916 static rtx cfa_base_rtx;
917 static HOST_WIDE_INT cfa_base_offset;
919 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
920 or hard_frame_pointer_rtx. */
922 static inline rtx
923 compute_cfa_pointer (poly_int64 adjustment)
925 return plus_constant (Pmode, cfa_base_rtx, adjustment + cfa_base_offset);
928 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
929 or -1 if the replacement shouldn't be done. */
930 static poly_int64 hard_frame_pointer_adjustment = -1;
932 /* Data for adjust_mems callback. */
934 class adjust_mem_data
936 public:
937 bool store;
938 machine_mode mem_mode;
939 HOST_WIDE_INT stack_adjust;
940 auto_vec<rtx> side_effects;
943 /* Helper for adjust_mems. Return true if X is suitable for
944 transformation of wider mode arithmetics to narrower mode. */
946 static bool
947 use_narrower_mode_test (rtx x, const_rtx subreg)
949 subrtx_var_iterator::array_type array;
950 FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST)
952 rtx x = *iter;
953 if (CONSTANT_P (x))
954 iter.skip_subrtxes ();
955 else
956 switch (GET_CODE (x))
958 case REG:
959 if (cselib_lookup (x, GET_MODE (SUBREG_REG (subreg)), 0, VOIDmode))
960 return false;
961 if (!validate_subreg (GET_MODE (subreg), GET_MODE (x), x,
962 subreg_lowpart_offset (GET_MODE (subreg),
963 GET_MODE (x))))
964 return false;
965 break;
966 case PLUS:
967 case MINUS:
968 case MULT:
969 break;
970 case ASHIFT:
971 if (GET_MODE (XEXP (x, 1)) != VOIDmode)
973 enum machine_mode mode = GET_MODE (subreg);
974 rtx op1 = XEXP (x, 1);
975 enum machine_mode op1_mode = GET_MODE (op1);
976 if (GET_MODE_PRECISION (as_a <scalar_int_mode> (mode))
977 < GET_MODE_PRECISION (as_a <scalar_int_mode> (op1_mode)))
979 poly_uint64 byte = subreg_lowpart_offset (mode, op1_mode);
980 if (GET_CODE (op1) == SUBREG || GET_CODE (op1) == CONCAT)
982 if (!simplify_subreg (mode, op1, op1_mode, byte))
983 return false;
985 else if (!validate_subreg (mode, op1_mode, op1, byte))
986 return false;
989 iter.substitute (XEXP (x, 0));
990 break;
991 default:
992 return false;
995 return true;
998 /* Transform X into narrower mode MODE from wider mode WMODE. */
1000 static rtx
1001 use_narrower_mode (rtx x, scalar_int_mode mode, scalar_int_mode wmode)
1003 rtx op0, op1;
1004 if (CONSTANT_P (x))
1005 return lowpart_subreg (mode, x, wmode);
1006 switch (GET_CODE (x))
1008 case REG:
1009 return lowpart_subreg (mode, x, wmode);
1010 case PLUS:
1011 case MINUS:
1012 case MULT:
1013 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
1014 op1 = use_narrower_mode (XEXP (x, 1), mode, wmode);
1015 return simplify_gen_binary (GET_CODE (x), mode, op0, op1);
1016 case ASHIFT:
1017 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
1018 op1 = XEXP (x, 1);
1019 /* Ensure shift amount is not wider than mode. */
1020 if (GET_MODE (op1) == VOIDmode)
1021 op1 = lowpart_subreg (mode, op1, wmode);
1022 else if (GET_MODE_PRECISION (mode)
1023 < GET_MODE_PRECISION (as_a <scalar_int_mode> (GET_MODE (op1))))
1024 op1 = lowpart_subreg (mode, op1, GET_MODE (op1));
1025 return simplify_gen_binary (ASHIFT, mode, op0, op1);
1026 default:
1027 gcc_unreachable ();
1031 /* Helper function for adjusting used MEMs. */
1033 static rtx
1034 adjust_mems (rtx loc, const_rtx old_rtx, void *data)
1036 class adjust_mem_data *amd = (class adjust_mem_data *) data;
1037 rtx mem, addr = loc, tem;
1038 machine_mode mem_mode_save;
1039 bool store_save;
1040 scalar_int_mode tem_mode, tem_subreg_mode;
1041 poly_int64 size;
1042 switch (GET_CODE (loc))
1044 case REG:
1045 /* Don't do any sp or fp replacements outside of MEM addresses
1046 on the LHS. */
1047 if (amd->mem_mode == VOIDmode && amd->store)
1048 return loc;
1049 if (loc == stack_pointer_rtx
1050 && !frame_pointer_needed
1051 && cfa_base_rtx)
1052 return compute_cfa_pointer (amd->stack_adjust);
1053 else if (loc == hard_frame_pointer_rtx
1054 && frame_pointer_needed
1055 && maybe_ne (hard_frame_pointer_adjustment, -1)
1056 && cfa_base_rtx)
1057 return compute_cfa_pointer (hard_frame_pointer_adjustment);
1058 gcc_checking_assert (loc != virtual_incoming_args_rtx);
1059 return loc;
1060 case MEM:
1061 mem = loc;
1062 if (!amd->store)
1064 mem = targetm.delegitimize_address (mem);
1065 if (mem != loc && !MEM_P (mem))
1066 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
1069 addr = XEXP (mem, 0);
1070 mem_mode_save = amd->mem_mode;
1071 amd->mem_mode = GET_MODE (mem);
1072 store_save = amd->store;
1073 amd->store = false;
1074 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1075 amd->store = store_save;
1076 amd->mem_mode = mem_mode_save;
1077 if (mem == loc)
1078 addr = targetm.delegitimize_address (addr);
1079 if (addr != XEXP (mem, 0))
1080 mem = replace_equiv_address_nv (mem, addr);
1081 if (!amd->store)
1082 mem = avoid_constant_pool_reference (mem);
1083 return mem;
1084 case PRE_INC:
1085 case PRE_DEC:
1086 size = GET_MODE_SIZE (amd->mem_mode);
1087 addr = plus_constant (GET_MODE (loc), XEXP (loc, 0),
1088 GET_CODE (loc) == PRE_INC ? size : -size);
1089 /* FALLTHRU */
1090 case POST_INC:
1091 case POST_DEC:
1092 if (addr == loc)
1093 addr = XEXP (loc, 0);
1094 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
1095 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1096 size = GET_MODE_SIZE (amd->mem_mode);
1097 tem = plus_constant (GET_MODE (loc), XEXP (loc, 0),
1098 (GET_CODE (loc) == PRE_INC
1099 || GET_CODE (loc) == POST_INC) ? size : -size);
1100 store_save = amd->store;
1101 amd->store = false;
1102 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
1103 amd->store = store_save;
1104 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1105 return addr;
1106 case PRE_MODIFY:
1107 addr = XEXP (loc, 1);
1108 /* FALLTHRU */
1109 case POST_MODIFY:
1110 if (addr == loc)
1111 addr = XEXP (loc, 0);
1112 gcc_assert (amd->mem_mode != VOIDmode);
1113 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1114 store_save = amd->store;
1115 amd->store = false;
1116 tem = simplify_replace_fn_rtx (XEXP (loc, 1), old_rtx,
1117 adjust_mems, data);
1118 amd->store = store_save;
1119 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1120 return addr;
1121 case SUBREG:
1122 /* First try without delegitimization of whole MEMs and
1123 avoid_constant_pool_reference, which is more likely to succeed. */
1124 store_save = amd->store;
1125 amd->store = true;
1126 addr = simplify_replace_fn_rtx (SUBREG_REG (loc), old_rtx, adjust_mems,
1127 data);
1128 amd->store = store_save;
1129 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1130 if (mem == SUBREG_REG (loc))
1132 tem = loc;
1133 goto finish_subreg;
1135 tem = simplify_gen_subreg (GET_MODE (loc), mem,
1136 GET_MODE (SUBREG_REG (loc)),
1137 SUBREG_BYTE (loc));
1138 if (tem)
1139 goto finish_subreg;
1140 tem = simplify_gen_subreg (GET_MODE (loc), addr,
1141 GET_MODE (SUBREG_REG (loc)),
1142 SUBREG_BYTE (loc));
1143 if (tem == NULL_RTX)
1144 tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
1145 finish_subreg:
1146 if (MAY_HAVE_DEBUG_BIND_INSNS
1147 && GET_CODE (tem) == SUBREG
1148 && (GET_CODE (SUBREG_REG (tem)) == PLUS
1149 || GET_CODE (SUBREG_REG (tem)) == MINUS
1150 || GET_CODE (SUBREG_REG (tem)) == MULT
1151 || GET_CODE (SUBREG_REG (tem)) == ASHIFT)
1152 && is_a <scalar_int_mode> (GET_MODE (tem), &tem_mode)
1153 && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (tem)),
1154 &tem_subreg_mode)
1155 && (GET_MODE_PRECISION (tem_mode)
1156 < GET_MODE_PRECISION (tem_subreg_mode))
1157 && subreg_lowpart_p (tem)
1158 && use_narrower_mode_test (SUBREG_REG (tem), tem))
1159 return use_narrower_mode (SUBREG_REG (tem), tem_mode, tem_subreg_mode);
1160 return tem;
1161 case ASM_OPERANDS:
1162 /* Don't do any replacements in second and following
1163 ASM_OPERANDS of inline-asm with multiple sets.
1164 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1165 and ASM_OPERANDS_LABEL_VEC need to be equal between
1166 all the ASM_OPERANDs in the insn and adjust_insn will
1167 fix this up. */
1168 if (ASM_OPERANDS_OUTPUT_IDX (loc) != 0)
1169 return loc;
1170 break;
1171 default:
1172 break;
1174 return NULL_RTX;
1177 /* Helper function for replacement of uses. */
1179 static void
1180 adjust_mem_uses (rtx *x, void *data)
1182 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX, adjust_mems, data);
1183 if (new_x != *x)
1184 validate_change (NULL_RTX, x, new_x, true);
1187 /* Helper function for replacement of stores. */
1189 static void
1190 adjust_mem_stores (rtx loc, const_rtx expr, void *data)
1192 if (MEM_P (loc))
1194 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr), NULL_RTX,
1195 adjust_mems, data);
1196 if (new_dest != SET_DEST (expr))
1198 rtx xexpr = CONST_CAST_RTX (expr);
1199 validate_change (NULL_RTX, &SET_DEST (xexpr), new_dest, true);
1204 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1205 replace them with their value in the insn and add the side-effects
1206 as other sets to the insn. */
1208 static void
1209 adjust_insn (basic_block bb, rtx_insn *insn)
1211 rtx set;
1213 #ifdef HAVE_window_save
1214 /* If the target machine has an explicit window save instruction, the
1215 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1216 if (RTX_FRAME_RELATED_P (insn)
1217 && find_reg_note (insn, REG_CFA_WINDOW_SAVE, NULL_RTX))
1219 unsigned int i, nregs = vec_safe_length (windowed_parm_regs);
1220 rtx rtl = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs * 2));
1221 parm_reg *p;
1223 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)
1225 XVECEXP (rtl, 0, i * 2)
1226 = gen_rtx_SET (p->incoming, p->outgoing);
1227 /* Do not clobber the attached DECL, but only the REG. */
1228 XVECEXP (rtl, 0, i * 2 + 1)
1229 = gen_rtx_CLOBBER (GET_MODE (p->outgoing),
1230 gen_raw_REG (GET_MODE (p->outgoing),
1231 REGNO (p->outgoing)));
1234 validate_change (NULL_RTX, &PATTERN (insn), rtl, true);
1235 return;
1237 #endif
1239 adjust_mem_data amd;
1240 amd.mem_mode = VOIDmode;
1241 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
1243 amd.store = true;
1244 note_stores (insn, adjust_mem_stores, &amd);
1246 amd.store = false;
1247 if (GET_CODE (PATTERN (insn)) == PARALLEL
1248 && asm_noperands (PATTERN (insn)) > 0
1249 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1251 rtx body, set0;
1252 int i;
1254 /* inline-asm with multiple sets is tiny bit more complicated,
1255 because the 3 vectors in ASM_OPERANDS need to be shared between
1256 all ASM_OPERANDS in the instruction. adjust_mems will
1257 not touch ASM_OPERANDS other than the first one, asm_noperands
1258 test above needs to be called before that (otherwise it would fail)
1259 and afterwards this code fixes it up. */
1260 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1261 body = PATTERN (insn);
1262 set0 = XVECEXP (body, 0, 0);
1263 gcc_checking_assert (GET_CODE (set0) == SET
1264 && GET_CODE (SET_SRC (set0)) == ASM_OPERANDS
1265 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0)) == 0);
1266 for (i = 1; i < XVECLEN (body, 0); i++)
1267 if (GET_CODE (XVECEXP (body, 0, i)) != SET)
1268 break;
1269 else
1271 set = XVECEXP (body, 0, i);
1272 gcc_checking_assert (GET_CODE (SET_SRC (set)) == ASM_OPERANDS
1273 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set))
1274 == i);
1275 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set))
1276 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))
1277 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set))
1278 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))
1279 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set))
1280 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0)))
1282 rtx newsrc = shallow_copy_rtx (SET_SRC (set));
1283 ASM_OPERANDS_INPUT_VEC (newsrc)
1284 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0));
1285 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc)
1286 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0));
1287 ASM_OPERANDS_LABEL_VEC (newsrc)
1288 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0));
1289 validate_change (NULL_RTX, &SET_SRC (set), newsrc, true);
1293 else
1294 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1296 /* For read-only MEMs containing some constant, prefer those
1297 constants. */
1298 set = single_set (insn);
1299 if (set && MEM_P (SET_SRC (set)) && MEM_READONLY_P (SET_SRC (set)))
1301 rtx note = find_reg_equal_equiv_note (insn);
1303 if (note && CONSTANT_P (XEXP (note, 0)))
1304 validate_change (NULL_RTX, &SET_SRC (set), XEXP (note, 0), true);
1307 if (!amd.side_effects.is_empty ())
1309 rtx *pat, new_pat;
1310 int i, oldn;
1312 pat = &PATTERN (insn);
1313 if (GET_CODE (*pat) == COND_EXEC)
1314 pat = &COND_EXEC_CODE (*pat);
1315 if (GET_CODE (*pat) == PARALLEL)
1316 oldn = XVECLEN (*pat, 0);
1317 else
1318 oldn = 1;
1319 unsigned int newn = amd.side_effects.length ();
1320 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn));
1321 if (GET_CODE (*pat) == PARALLEL)
1322 for (i = 0; i < oldn; i++)
1323 XVECEXP (new_pat, 0, i) = XVECEXP (*pat, 0, i);
1324 else
1325 XVECEXP (new_pat, 0, 0) = *pat;
1327 rtx effect;
1328 unsigned int j;
1329 FOR_EACH_VEC_ELT_REVERSE (amd.side_effects, j, effect)
1330 XVECEXP (new_pat, 0, j + oldn) = effect;
1331 validate_change (NULL_RTX, pat, new_pat, true);
1335 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1336 static inline rtx
1337 dv_as_rtx (decl_or_value dv)
1339 tree decl;
1341 if (dv_is_value_p (dv))
1342 return dv_as_value (dv);
1344 decl = dv_as_decl (dv);
1346 gcc_checking_assert (TREE_CODE (decl) == DEBUG_EXPR_DECL);
1347 return DECL_RTL_KNOWN_SET (decl);
1350 /* Return nonzero if a decl_or_value must not have more than one
1351 variable part. The returned value discriminates among various
1352 kinds of one-part DVs ccording to enum onepart_enum. */
1353 static inline onepart_enum
1354 dv_onepart_p (decl_or_value dv)
1356 tree decl;
1358 if (!MAY_HAVE_DEBUG_BIND_INSNS)
1359 return NOT_ONEPART;
1361 if (dv_is_value_p (dv))
1362 return ONEPART_VALUE;
1364 decl = dv_as_decl (dv);
1366 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
1367 return ONEPART_DEXPR;
1369 if (target_for_debug_bind (decl) != NULL_TREE)
1370 return ONEPART_VDECL;
1372 return NOT_ONEPART;
1375 /* Return the variable pool to be used for a dv of type ONEPART. */
1376 static inline pool_allocator &
1377 onepart_pool (onepart_enum onepart)
1379 return onepart ? valvar_pool : var_pool;
1382 /* Allocate a variable_def from the corresponding variable pool. */
1383 static inline variable *
1384 onepart_pool_allocate (onepart_enum onepart)
1386 return (variable*) onepart_pool (onepart).allocate ();
1389 /* Build a decl_or_value out of a decl. */
1390 static inline decl_or_value
1391 dv_from_decl (tree decl)
1393 decl_or_value dv = decl;
1394 gcc_checking_assert (dv_is_decl_p (dv));
1395 return dv;
1398 /* Build a decl_or_value out of a value. */
1399 static inline decl_or_value
1400 dv_from_value (rtx value)
1402 decl_or_value dv = value;
1403 gcc_checking_assert (dv_is_value_p (dv));
1404 return dv;
1407 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1408 static inline decl_or_value
1409 dv_from_rtx (rtx x)
1411 decl_or_value dv;
1413 switch (GET_CODE (x))
1415 case DEBUG_EXPR:
1416 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x));
1417 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x)) == x);
1418 break;
1420 case VALUE:
1421 dv = dv_from_value (x);
1422 break;
1424 default:
1425 gcc_unreachable ();
1428 return dv;
1431 extern void debug_dv (decl_or_value dv);
1433 DEBUG_FUNCTION void
1434 debug_dv (decl_or_value dv)
1436 if (dv_is_value_p (dv))
1437 debug_rtx (dv_as_value (dv));
1438 else
1439 debug_generic_stmt (dv_as_decl (dv));
1442 static void loc_exp_dep_clear (variable *var);
1444 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1446 static void
1447 variable_htab_free (void *elem)
1449 int i;
1450 variable *var = (variable *) elem;
1451 location_chain *node, *next;
1453 gcc_checking_assert (var->refcount > 0);
1455 var->refcount--;
1456 if (var->refcount > 0)
1457 return;
1459 for (i = 0; i < var->n_var_parts; i++)
1461 for (node = var->var_part[i].loc_chain; node; node = next)
1463 next = node->next;
1464 delete node;
1466 var->var_part[i].loc_chain = NULL;
1468 if (var->onepart && VAR_LOC_1PAUX (var))
1470 loc_exp_dep_clear (var);
1471 if (VAR_LOC_DEP_LST (var))
1472 VAR_LOC_DEP_LST (var)->pprev = NULL;
1473 XDELETE (VAR_LOC_1PAUX (var));
1474 /* These may be reused across functions, so reset
1475 e.g. NO_LOC_P. */
1476 if (var->onepart == ONEPART_DEXPR)
1477 set_dv_changed (var->dv, true);
1479 onepart_pool (var->onepart).remove (var);
1482 /* Initialize the set (array) SET of attrs to empty lists. */
1484 static void
1485 init_attrs_list_set (attrs **set)
1487 int i;
1489 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1490 set[i] = NULL;
1493 /* Make the list *LISTP empty. */
1495 static void
1496 attrs_list_clear (attrs **listp)
1498 attrs *list, *next;
1500 for (list = *listp; list; list = next)
1502 next = list->next;
1503 delete list;
1505 *listp = NULL;
1508 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1510 static attrs *
1511 attrs_list_member (attrs *list, decl_or_value dv, HOST_WIDE_INT offset)
1513 for (; list; list = list->next)
1514 if (list->dv == dv && list->offset == offset)
1515 return list;
1516 return NULL;
1519 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1521 static void
1522 attrs_list_insert (attrs **listp, decl_or_value dv,
1523 HOST_WIDE_INT offset, rtx loc)
1525 attrs *list = new attrs;
1526 list->loc = loc;
1527 list->dv = dv;
1528 list->offset = offset;
1529 list->next = *listp;
1530 *listp = list;
1533 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1535 static void
1536 attrs_list_copy (attrs **dstp, attrs *src)
1538 attrs_list_clear (dstp);
1539 for (; src; src = src->next)
1541 attrs *n = new attrs;
1542 n->loc = src->loc;
1543 n->dv = src->dv;
1544 n->offset = src->offset;
1545 n->next = *dstp;
1546 *dstp = n;
1550 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1552 static void
1553 attrs_list_union (attrs **dstp, attrs *src)
1555 for (; src; src = src->next)
1557 if (!attrs_list_member (*dstp, src->dv, src->offset))
1558 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1562 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1563 *DSTP. */
1565 static void
1566 attrs_list_mpdv_union (attrs **dstp, attrs *src, attrs *src2)
1568 gcc_assert (!*dstp);
1569 for (; src; src = src->next)
1571 if (!dv_onepart_p (src->dv))
1572 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1574 for (src = src2; src; src = src->next)
1576 if (!dv_onepart_p (src->dv)
1577 && !attrs_list_member (*dstp, src->dv, src->offset))
1578 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1582 /* Shared hashtable support. */
1584 /* Return true if VARS is shared. */
1586 static inline bool
1587 shared_hash_shared (shared_hash *vars)
1589 return vars->refcount > 1;
1592 /* Return the hash table for VARS. */
1594 static inline variable_table_type *
1595 shared_hash_htab (shared_hash *vars)
1597 return vars->htab;
1600 /* Return true if VAR is shared, or maybe because VARS is shared. */
1602 static inline bool
1603 shared_var_p (variable *var, shared_hash *vars)
1605 /* Don't count an entry in the changed_variables table as a duplicate. */
1606 return ((var->refcount > 1 + (int) var->in_changed_variables)
1607 || shared_hash_shared (vars));
1610 /* Copy variables into a new hash table. */
1612 static shared_hash *
1613 shared_hash_unshare (shared_hash *vars)
1615 shared_hash *new_vars = new shared_hash;
1616 gcc_assert (vars->refcount > 1);
1617 new_vars->refcount = 1;
1618 new_vars->htab = new variable_table_type (vars->htab->elements () + 3);
1619 vars_copy (new_vars->htab, vars->htab);
1620 vars->refcount--;
1621 return new_vars;
1624 /* Increment reference counter on VARS and return it. */
1626 static inline shared_hash *
1627 shared_hash_copy (shared_hash *vars)
1629 vars->refcount++;
1630 return vars;
1633 /* Decrement reference counter and destroy hash table if not shared
1634 anymore. */
1636 static void
1637 shared_hash_destroy (shared_hash *vars)
1639 gcc_checking_assert (vars->refcount > 0);
1640 if (--vars->refcount == 0)
1642 delete vars->htab;
1643 delete vars;
1647 /* Unshare *PVARS if shared and return slot for DV. If INS is
1648 INSERT, insert it if not already present. */
1650 static inline variable **
1651 shared_hash_find_slot_unshare_1 (shared_hash **pvars, decl_or_value dv,
1652 hashval_t dvhash, enum insert_option ins)
1654 if (shared_hash_shared (*pvars))
1655 *pvars = shared_hash_unshare (*pvars);
1656 return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins);
1659 static inline variable **
1660 shared_hash_find_slot_unshare (shared_hash **pvars, decl_or_value dv,
1661 enum insert_option ins)
1663 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1666 /* Return slot for DV, if it is already present in the hash table.
1667 If it is not present, insert it only VARS is not shared, otherwise
1668 return NULL. */
1670 static inline variable **
1671 shared_hash_find_slot_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1673 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash,
1674 shared_hash_shared (vars)
1675 ? NO_INSERT : INSERT);
1678 static inline variable **
1679 shared_hash_find_slot (shared_hash *vars, decl_or_value dv)
1681 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1684 /* Return slot for DV only if it is already present in the hash table. */
1686 static inline variable **
1687 shared_hash_find_slot_noinsert_1 (shared_hash *vars, decl_or_value dv,
1688 hashval_t dvhash)
1690 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT);
1693 static inline variable **
1694 shared_hash_find_slot_noinsert (shared_hash *vars, decl_or_value dv)
1696 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1699 /* Return variable for DV or NULL if not already present in the hash
1700 table. */
1702 static inline variable *
1703 shared_hash_find_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1705 return shared_hash_htab (vars)->find_with_hash (dv, dvhash);
1708 static inline variable *
1709 shared_hash_find (shared_hash *vars, decl_or_value dv)
1711 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1714 /* Return true if TVAL is better than CVAL as a canonival value. We
1715 choose lowest-numbered VALUEs, using the RTX address as a
1716 tie-breaker. The idea is to arrange them into a star topology,
1717 such that all of them are at most one step away from the canonical
1718 value, and the canonical value has backlinks to all of them, in
1719 addition to all the actual locations. We don't enforce this
1720 topology throughout the entire dataflow analysis, though.
1723 static inline bool
1724 canon_value_cmp (rtx tval, rtx cval)
1726 return !cval
1727 || CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
1730 static bool dst_can_be_shared;
1732 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1734 static variable **
1735 unshare_variable (dataflow_set *set, variable **slot, variable *var,
1736 enum var_init_status initialized)
1738 variable *new_var;
1739 int i;
1741 new_var = onepart_pool_allocate (var->onepart);
1742 new_var->dv = var->dv;
1743 new_var->refcount = 1;
1744 var->refcount--;
1745 new_var->n_var_parts = var->n_var_parts;
1746 new_var->onepart = var->onepart;
1747 new_var->in_changed_variables = false;
1749 if (! flag_var_tracking_uninit)
1750 initialized = VAR_INIT_STATUS_INITIALIZED;
1752 for (i = 0; i < var->n_var_parts; i++)
1754 location_chain *node;
1755 location_chain **nextp;
1757 if (i == 0 && var->onepart)
1759 /* One-part auxiliary data is only used while emitting
1760 notes, so propagate it to the new variable in the active
1761 dataflow set. If we're not emitting notes, this will be
1762 a no-op. */
1763 gcc_checking_assert (!VAR_LOC_1PAUX (var) || emit_notes);
1764 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (var);
1765 VAR_LOC_1PAUX (var) = NULL;
1767 else
1768 VAR_PART_OFFSET (new_var, i) = VAR_PART_OFFSET (var, i);
1769 nextp = &new_var->var_part[i].loc_chain;
1770 for (node = var->var_part[i].loc_chain; node; node = node->next)
1772 location_chain *new_lc;
1774 new_lc = new location_chain;
1775 new_lc->next = NULL;
1776 if (node->init > initialized)
1777 new_lc->init = node->init;
1778 else
1779 new_lc->init = initialized;
1780 if (node->set_src && !(MEM_P (node->set_src)))
1781 new_lc->set_src = node->set_src;
1782 else
1783 new_lc->set_src = NULL;
1784 new_lc->loc = node->loc;
1786 *nextp = new_lc;
1787 nextp = &new_lc->next;
1790 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1793 dst_can_be_shared = false;
1794 if (shared_hash_shared (set->vars))
1795 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1796 else if (set->traversed_vars && set->vars != set->traversed_vars)
1797 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1798 *slot = new_var;
1799 if (var->in_changed_variables)
1801 variable **cslot
1802 = changed_variables->find_slot_with_hash (var->dv,
1803 dv_htab_hash (var->dv),
1804 NO_INSERT);
1805 gcc_assert (*cslot == (void *) var);
1806 var->in_changed_variables = false;
1807 variable_htab_free (var);
1808 *cslot = new_var;
1809 new_var->in_changed_variables = true;
1811 return slot;
1814 /* Copy all variables from hash table SRC to hash table DST. */
1816 static void
1817 vars_copy (variable_table_type *dst, variable_table_type *src)
1819 variable_iterator_type hi;
1820 variable *var;
1822 FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi)
1824 variable **dstp;
1825 var->refcount++;
1826 dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv), INSERT);
1827 *dstp = var;
1831 /* Map a decl to its main debug decl. */
1833 static inline tree
1834 var_debug_decl (tree decl)
1836 if (decl && VAR_P (decl) && DECL_HAS_DEBUG_EXPR_P (decl))
1838 tree debugdecl = DECL_DEBUG_EXPR (decl);
1839 if (DECL_P (debugdecl))
1840 decl = debugdecl;
1843 return decl;
1846 /* Set the register LOC to contain DV, OFFSET. */
1848 static void
1849 var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1850 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1851 enum insert_option iopt)
1853 attrs *node;
1854 bool decl_p = dv_is_decl_p (dv);
1856 if (decl_p)
1857 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1859 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1860 if (node->dv == dv && node->offset == offset)
1861 break;
1862 if (!node)
1863 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
1864 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1867 /* Return true if we should track a location that is OFFSET bytes from
1868 a variable. Store the constant offset in *OFFSET_OUT if so. */
1870 static bool
1871 track_offset_p (poly_int64 offset, HOST_WIDE_INT *offset_out)
1873 HOST_WIDE_INT const_offset;
1874 if (!offset.is_constant (&const_offset)
1875 || !IN_RANGE (const_offset, 0, MAX_VAR_PARTS - 1))
1876 return false;
1877 *offset_out = const_offset;
1878 return true;
1881 /* Return the offset of a register that track_offset_p says we
1882 should track. */
1884 static HOST_WIDE_INT
1885 get_tracked_reg_offset (rtx loc)
1887 HOST_WIDE_INT offset;
1888 if (!track_offset_p (REG_OFFSET (loc), &offset))
1889 gcc_unreachable ();
1890 return offset;
1893 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1895 static void
1896 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1897 rtx set_src)
1899 tree decl = REG_EXPR (loc);
1900 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1902 var_reg_decl_set (set, loc, initialized,
1903 dv_from_decl (decl), offset, set_src, INSERT);
1906 static enum var_init_status
1907 get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1909 variable *var;
1910 int i;
1911 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1913 if (! flag_var_tracking_uninit)
1914 return VAR_INIT_STATUS_INITIALIZED;
1916 var = shared_hash_find (set->vars, dv);
1917 if (var)
1919 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1921 location_chain *nextp;
1922 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1923 if (rtx_equal_p (nextp->loc, loc))
1925 ret_val = nextp->init;
1926 break;
1931 return ret_val;
1934 /* Delete current content of register LOC in dataflow set SET and set
1935 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1936 MODIFY is true, any other live copies of the same variable part are
1937 also deleted from the dataflow set, otherwise the variable part is
1938 assumed to be copied from another location holding the same
1939 part. */
1941 static void
1942 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1943 enum var_init_status initialized, rtx set_src)
1945 tree decl = REG_EXPR (loc);
1946 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1947 attrs *node, *next;
1948 attrs **nextp;
1950 decl = var_debug_decl (decl);
1952 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1953 initialized = get_init_value (set, loc, dv_from_decl (decl));
1955 nextp = &set->regs[REGNO (loc)];
1956 for (node = *nextp; node; node = next)
1958 next = node->next;
1959 if (node->dv != decl || node->offset != offset)
1961 delete_variable_part (set, node->loc, node->dv, node->offset);
1962 delete node;
1963 *nextp = next;
1965 else
1967 node->loc = loc;
1968 nextp = &node->next;
1971 if (modify)
1972 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1973 var_reg_set (set, loc, initialized, set_src);
1976 /* Delete the association of register LOC in dataflow set SET with any
1977 variables that aren't onepart. If CLOBBER is true, also delete any
1978 other live copies of the same variable part, and delete the
1979 association with onepart dvs too. */
1981 static void
1982 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1984 attrs **nextp = &set->regs[REGNO (loc)];
1985 attrs *node, *next;
1987 HOST_WIDE_INT offset;
1988 if (clobber && track_offset_p (REG_OFFSET (loc), &offset))
1990 tree decl = REG_EXPR (loc);
1992 decl = var_debug_decl (decl);
1994 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1997 for (node = *nextp; node; node = next)
1999 next = node->next;
2000 if (clobber || !dv_onepart_p (node->dv))
2002 delete_variable_part (set, node->loc, node->dv, node->offset);
2003 delete node;
2004 *nextp = next;
2006 else
2007 nextp = &node->next;
2011 /* Delete content of register with number REGNO in dataflow set SET. */
2013 static void
2014 var_regno_delete (dataflow_set *set, int regno)
2016 attrs **reg = &set->regs[regno];
2017 attrs *node, *next;
2019 for (node = *reg; node; node = next)
2021 next = node->next;
2022 delete_variable_part (set, node->loc, node->dv, node->offset);
2023 delete node;
2025 *reg = NULL;
2028 /* Return true if I is the negated value of a power of two. */
2029 static bool
2030 negative_power_of_two_p (HOST_WIDE_INT i)
2032 unsigned HOST_WIDE_INT x = -(unsigned HOST_WIDE_INT)i;
2033 return pow2_or_zerop (x);
2036 /* Strip constant offsets and alignments off of LOC. Return the base
2037 expression. */
2039 static rtx
2040 vt_get_canonicalize_base (rtx loc)
2042 while ((GET_CODE (loc) == PLUS
2043 || GET_CODE (loc) == AND)
2044 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2045 && (GET_CODE (loc) != AND
2046 || negative_power_of_two_p (INTVAL (XEXP (loc, 1)))))
2047 loc = XEXP (loc, 0);
2049 return loc;
2052 /* This caches canonicalized addresses for VALUEs, computed using
2053 information in the global cselib table. */
2054 static hash_map<rtx, rtx> *global_get_addr_cache;
2056 /* This caches canonicalized addresses for VALUEs, computed using
2057 information from the global cache and information pertaining to a
2058 basic block being analyzed. */
2059 static hash_map<rtx, rtx> *local_get_addr_cache;
2061 static rtx vt_canonicalize_addr (dataflow_set *, rtx);
2063 /* Return the canonical address for LOC, that must be a VALUE, using a
2064 cached global equivalence or computing it and storing it in the
2065 global cache. */
2067 static rtx
2068 get_addr_from_global_cache (rtx const loc)
2070 rtx x;
2072 gcc_checking_assert (GET_CODE (loc) == VALUE);
2074 bool existed;
2075 rtx *slot = &global_get_addr_cache->get_or_insert (loc, &existed);
2076 if (existed)
2077 return *slot;
2079 x = canon_rtx (get_addr (loc));
2081 /* Tentative, avoiding infinite recursion. */
2082 *slot = x;
2084 if (x != loc)
2086 rtx nx = vt_canonicalize_addr (NULL, x);
2087 if (nx != x)
2089 /* The table may have moved during recursion, recompute
2090 SLOT. */
2091 *global_get_addr_cache->get (loc) = x = nx;
2095 return x;
2098 /* Return the canonical address for LOC, that must be a VALUE, using a
2099 cached local equivalence or computing it and storing it in the
2100 local cache. */
2102 static rtx
2103 get_addr_from_local_cache (dataflow_set *set, rtx const loc)
2105 rtx x;
2106 decl_or_value dv;
2107 variable *var;
2108 location_chain *l;
2110 gcc_checking_assert (GET_CODE (loc) == VALUE);
2112 bool existed;
2113 rtx *slot = &local_get_addr_cache->get_or_insert (loc, &existed);
2114 if (existed)
2115 return *slot;
2117 x = get_addr_from_global_cache (loc);
2119 /* Tentative, avoiding infinite recursion. */
2120 *slot = x;
2122 /* Recurse to cache local expansion of X, or if we need to search
2123 for a VALUE in the expansion. */
2124 if (x != loc)
2126 rtx nx = vt_canonicalize_addr (set, x);
2127 if (nx != x)
2129 slot = local_get_addr_cache->get (loc);
2130 *slot = x = nx;
2132 return x;
2135 dv = dv_from_rtx (x);
2136 var = shared_hash_find (set->vars, dv);
2137 if (!var)
2138 return x;
2140 /* Look for an improved equivalent expression. */
2141 for (l = var->var_part[0].loc_chain; l; l = l->next)
2143 rtx base = vt_get_canonicalize_base (l->loc);
2144 if (GET_CODE (base) == VALUE
2145 && canon_value_cmp (base, loc))
2147 rtx nx = vt_canonicalize_addr (set, l->loc);
2148 if (x != nx)
2150 slot = local_get_addr_cache->get (loc);
2151 *slot = x = nx;
2153 break;
2157 return x;
2160 /* Canonicalize LOC using equivalences from SET in addition to those
2161 in the cselib static table. It expects a VALUE-based expression,
2162 and it will only substitute VALUEs with other VALUEs or
2163 function-global equivalences, so that, if two addresses have base
2164 VALUEs that are locally or globally related in ways that
2165 memrefs_conflict_p cares about, they will both canonicalize to
2166 expressions that have the same base VALUE.
2168 The use of VALUEs as canonical base addresses enables the canonical
2169 RTXs to remain unchanged globally, if they resolve to a constant,
2170 or throughout a basic block otherwise, so that they can be cached
2171 and the cache needs not be invalidated when REGs, MEMs or such
2172 change. */
2174 static rtx
2175 vt_canonicalize_addr (dataflow_set *set, rtx oloc)
2177 poly_int64 ofst = 0, term;
2178 machine_mode mode = GET_MODE (oloc);
2179 rtx loc = oloc;
2180 rtx x;
2181 bool retry = true;
2183 while (retry)
2185 while (GET_CODE (loc) == PLUS
2186 && poly_int_rtx_p (XEXP (loc, 1), &term))
2188 ofst += term;
2189 loc = XEXP (loc, 0);
2192 /* Alignment operations can't normally be combined, so just
2193 canonicalize the base and we're done. We'll normally have
2194 only one stack alignment anyway. */
2195 if (GET_CODE (loc) == AND
2196 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2197 && negative_power_of_two_p (INTVAL (XEXP (loc, 1))))
2199 x = vt_canonicalize_addr (set, XEXP (loc, 0));
2200 if (x != XEXP (loc, 0))
2201 loc = gen_rtx_AND (mode, x, XEXP (loc, 1));
2202 retry = false;
2205 if (GET_CODE (loc) == VALUE)
2207 if (set)
2208 loc = get_addr_from_local_cache (set, loc);
2209 else
2210 loc = get_addr_from_global_cache (loc);
2212 /* Consolidate plus_constants. */
2213 while (maybe_ne (ofst, 0)
2214 && GET_CODE (loc) == PLUS
2215 && poly_int_rtx_p (XEXP (loc, 1), &term))
2217 ofst += term;
2218 loc = XEXP (loc, 0);
2221 retry = false;
2223 else
2225 x = canon_rtx (loc);
2226 if (retry)
2227 retry = (x != loc);
2228 loc = x;
2232 /* Add OFST back in. */
2233 if (maybe_ne (ofst, 0))
2235 /* Don't build new RTL if we can help it. */
2236 if (strip_offset (oloc, &term) == loc && known_eq (term, ofst))
2237 return oloc;
2239 loc = plus_constant (mode, loc, ofst);
2242 return loc;
2245 /* Return true iff there's a true dependence between MLOC and LOC.
2246 MADDR must be a canonicalized version of MLOC's address. */
2248 static inline bool
2249 vt_canon_true_dep (dataflow_set *set, rtx mloc, rtx maddr, rtx loc)
2251 if (GET_CODE (loc) != MEM)
2252 return false;
2254 rtx addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2255 if (!canon_true_dependence (mloc, GET_MODE (mloc), maddr, loc, addr))
2256 return false;
2258 return true;
2261 /* Hold parameters for the hashtab traversal function
2262 drop_overlapping_mem_locs, see below. */
2264 struct overlapping_mems
2266 dataflow_set *set;
2267 rtx loc, addr;
2270 /* Remove all MEMs that overlap with COMS->LOC from the location list
2271 of a hash table entry for a onepart variable. COMS->ADDR must be a
2272 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2273 canonicalized itself. */
2276 drop_overlapping_mem_locs (variable **slot, overlapping_mems *coms)
2278 dataflow_set *set = coms->set;
2279 rtx mloc = coms->loc, addr = coms->addr;
2280 variable *var = *slot;
2282 if (var->onepart != NOT_ONEPART)
2284 location_chain *loc, **locp;
2285 bool changed = false;
2286 rtx cur_loc;
2288 gcc_assert (var->n_var_parts == 1);
2290 if (shared_var_p (var, set->vars))
2292 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
2293 if (vt_canon_true_dep (set, mloc, addr, loc->loc))
2294 break;
2296 if (!loc)
2297 return 1;
2299 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
2300 var = *slot;
2301 gcc_assert (var->n_var_parts == 1);
2304 if (VAR_LOC_1PAUX (var))
2305 cur_loc = VAR_LOC_FROM (var);
2306 else
2307 cur_loc = var->var_part[0].cur_loc;
2309 for (locp = &var->var_part[0].loc_chain, loc = *locp;
2310 loc; loc = *locp)
2312 if (!vt_canon_true_dep (set, mloc, addr, loc->loc))
2314 locp = &loc->next;
2315 continue;
2318 *locp = loc->next;
2319 /* If we have deleted the location which was last emitted
2320 we have to emit new location so add the variable to set
2321 of changed variables. */
2322 if (cur_loc == loc->loc)
2324 changed = true;
2325 var->var_part[0].cur_loc = NULL;
2326 if (VAR_LOC_1PAUX (var))
2327 VAR_LOC_FROM (var) = NULL;
2329 delete loc;
2332 if (!var->var_part[0].loc_chain)
2334 var->n_var_parts--;
2335 changed = true;
2337 if (changed)
2338 variable_was_changed (var, set);
2341 return 1;
2344 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2346 static void
2347 clobber_overlapping_mems (dataflow_set *set, rtx loc)
2349 struct overlapping_mems coms;
2351 gcc_checking_assert (GET_CODE (loc) == MEM);
2353 coms.set = set;
2354 coms.loc = canon_rtx (loc);
2355 coms.addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2357 set->traversed_vars = set->vars;
2358 shared_hash_htab (set->vars)
2359 ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms);
2360 set->traversed_vars = NULL;
2363 /* Set the location of DV, OFFSET as the MEM LOC. */
2365 static void
2366 var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2367 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
2368 enum insert_option iopt)
2370 if (dv_is_decl_p (dv))
2371 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
2373 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
2376 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2377 SET to LOC.
2378 Adjust the address first if it is stack pointer based. */
2380 static void
2381 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2382 rtx set_src)
2384 tree decl = MEM_EXPR (loc);
2385 HOST_WIDE_INT offset = int_mem_offset (loc);
2387 var_mem_decl_set (set, loc, initialized,
2388 dv_from_decl (decl), offset, set_src, INSERT);
2391 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2392 dataflow set SET to LOC. If MODIFY is true, any other live copies
2393 of the same variable part are also deleted from the dataflow set,
2394 otherwise the variable part is assumed to be copied from another
2395 location holding the same part.
2396 Adjust the address first if it is stack pointer based. */
2398 static void
2399 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
2400 enum var_init_status initialized, rtx set_src)
2402 tree decl = MEM_EXPR (loc);
2403 HOST_WIDE_INT offset = int_mem_offset (loc);
2405 clobber_overlapping_mems (set, loc);
2406 decl = var_debug_decl (decl);
2408 if (initialized == VAR_INIT_STATUS_UNKNOWN)
2409 initialized = get_init_value (set, loc, dv_from_decl (decl));
2411 if (modify)
2412 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, set_src);
2413 var_mem_set (set, loc, initialized, set_src);
2416 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2417 true, also delete any other live copies of the same variable part.
2418 Adjust the address first if it is stack pointer based. */
2420 static void
2421 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
2423 tree decl = MEM_EXPR (loc);
2424 HOST_WIDE_INT offset = int_mem_offset (loc);
2426 clobber_overlapping_mems (set, loc);
2427 decl = var_debug_decl (decl);
2428 if (clobber)
2429 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
2430 delete_variable_part (set, loc, dv_from_decl (decl), offset);
2433 /* Return true if LOC should not be expanded for location expressions,
2434 or used in them. */
2436 static inline bool
2437 unsuitable_loc (rtx loc)
2439 switch (GET_CODE (loc))
2441 case PC:
2442 case SCRATCH:
2443 case ASM_INPUT:
2444 case ASM_OPERANDS:
2445 return true;
2447 default:
2448 return false;
2452 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2453 bound to it. */
2455 static inline void
2456 val_bind (dataflow_set *set, rtx val, rtx loc, bool modified)
2458 if (REG_P (loc))
2460 if (modified)
2461 var_regno_delete (set, REGNO (loc));
2462 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2463 dv_from_value (val), 0, NULL_RTX, INSERT);
2465 else if (MEM_P (loc))
2467 struct elt_loc_list *l = CSELIB_VAL_PTR (val)->locs;
2469 if (modified)
2470 clobber_overlapping_mems (set, loc);
2472 if (l && GET_CODE (l->loc) == VALUE)
2473 l = canonical_cselib_val (CSELIB_VAL_PTR (l->loc))->locs;
2475 /* If this MEM is a global constant, we don't need it in the
2476 dynamic tables. ??? We should test this before emitting the
2477 micro-op in the first place. */
2478 while (l)
2479 if (GET_CODE (l->loc) == MEM && XEXP (l->loc, 0) == XEXP (loc, 0))
2480 break;
2481 else
2482 l = l->next;
2484 if (!l)
2485 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2486 dv_from_value (val), 0, NULL_RTX, INSERT);
2488 else
2490 /* Other kinds of equivalences are necessarily static, at least
2491 so long as we do not perform substitutions while merging
2492 expressions. */
2493 gcc_unreachable ();
2494 set_variable_part (set, loc, dv_from_value (val), 0,
2495 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2499 /* Bind a value to a location it was just stored in. If MODIFIED
2500 holds, assume the location was modified, detaching it from any
2501 values bound to it. */
2503 static void
2504 val_store (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn,
2505 bool modified)
2507 cselib_val *v = CSELIB_VAL_PTR (val);
2509 gcc_assert (cselib_preserved_value_p (v));
2511 if (dump_file)
2513 fprintf (dump_file, "%i: ", insn ? INSN_UID (insn) : 0);
2514 print_inline_rtx (dump_file, loc, 0);
2515 fprintf (dump_file, " evaluates to ");
2516 print_inline_rtx (dump_file, val, 0);
2517 if (v->locs)
2519 struct elt_loc_list *l;
2520 for (l = v->locs; l; l = l->next)
2522 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
2523 print_inline_rtx (dump_file, l->loc, 0);
2526 fprintf (dump_file, "\n");
2529 gcc_checking_assert (!unsuitable_loc (loc));
2531 val_bind (set, val, loc, modified);
2534 /* Clear (canonical address) slots that reference X. */
2536 bool
2537 local_get_addr_clear_given_value (rtx const &, rtx *slot, rtx x)
2539 if (vt_get_canonicalize_base (*slot) == x)
2540 *slot = NULL;
2541 return true;
2544 /* Reset this node, detaching all its equivalences. Return the slot
2545 in the variable hash table that holds dv, if there is one. */
2547 static void
2548 val_reset (dataflow_set *set, decl_or_value dv)
2550 variable *var = shared_hash_find (set->vars, dv) ;
2551 location_chain *node;
2552 rtx cval;
2554 if (!var || !var->n_var_parts)
2555 return;
2557 gcc_assert (var->n_var_parts == 1);
2559 if (var->onepart == ONEPART_VALUE)
2561 rtx x = dv_as_value (dv);
2563 /* Relationships in the global cache don't change, so reset the
2564 local cache entry only. */
2565 rtx *slot = local_get_addr_cache->get (x);
2566 if (slot)
2568 /* If the value resolved back to itself, odds are that other
2569 values may have cached it too. These entries now refer
2570 to the old X, so detach them too. Entries that used the
2571 old X but resolved to something else remain ok as long as
2572 that something else isn't also reset. */
2573 if (*slot == x)
2574 local_get_addr_cache
2575 ->traverse<rtx, local_get_addr_clear_given_value> (x);
2576 *slot = NULL;
2580 cval = NULL;
2581 for (node = var->var_part[0].loc_chain; node; node = node->next)
2582 if (GET_CODE (node->loc) == VALUE
2583 && canon_value_cmp (node->loc, cval))
2584 cval = node->loc;
2586 for (node = var->var_part[0].loc_chain; node; node = node->next)
2587 if (GET_CODE (node->loc) == VALUE && cval != node->loc)
2589 /* Redirect the equivalence link to the new canonical
2590 value, or simply remove it if it would point at
2591 itself. */
2592 if (cval)
2593 set_variable_part (set, cval, dv_from_value (node->loc),
2594 0, node->init, node->set_src, NO_INSERT);
2595 delete_variable_part (set, dv_as_value (dv),
2596 dv_from_value (node->loc), 0);
2599 if (cval)
2601 decl_or_value cdv = dv_from_value (cval);
2603 /* Keep the remaining values connected, accumulating links
2604 in the canonical value. */
2605 for (node = var->var_part[0].loc_chain; node; node = node->next)
2607 if (node->loc == cval)
2608 continue;
2609 else if (GET_CODE (node->loc) == REG)
2610 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
2611 node->set_src, NO_INSERT);
2612 else if (GET_CODE (node->loc) == MEM)
2613 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
2614 node->set_src, NO_INSERT);
2615 else
2616 set_variable_part (set, node->loc, cdv, 0,
2617 node->init, node->set_src, NO_INSERT);
2621 /* We remove this last, to make sure that the canonical value is not
2622 removed to the point of requiring reinsertion. */
2623 if (cval)
2624 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
2626 clobber_variable_part (set, NULL, dv, 0, NULL);
2629 /* Find the values in a given location and map the val to another
2630 value, if it is unique, or add the location as one holding the
2631 value. */
2633 static void
2634 val_resolve (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn)
2636 decl_or_value dv = dv_from_value (val);
2638 if (dump_file && (dump_flags & TDF_DETAILS))
2640 if (insn)
2641 fprintf (dump_file, "%i: ", INSN_UID (insn));
2642 else
2643 fprintf (dump_file, "head: ");
2644 print_inline_rtx (dump_file, val, 0);
2645 fputs (" is at ", dump_file);
2646 print_inline_rtx (dump_file, loc, 0);
2647 fputc ('\n', dump_file);
2650 val_reset (set, dv);
2652 gcc_checking_assert (!unsuitable_loc (loc));
2654 if (REG_P (loc))
2656 attrs *node, *found = NULL;
2658 for (node = set->regs[REGNO (loc)]; node; node = node->next)
2659 if (dv_is_value_p (node->dv)
2660 && GET_MODE (dv_as_value (node->dv)) == GET_MODE (loc))
2662 found = node;
2664 /* Map incoming equivalences. ??? Wouldn't it be nice if
2665 we just started sharing the location lists? Maybe a
2666 circular list ending at the value itself or some
2667 such. */
2668 set_variable_part (set, dv_as_value (node->dv),
2669 dv_from_value (val), node->offset,
2670 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2671 set_variable_part (set, val, node->dv, node->offset,
2672 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2675 /* If we didn't find any equivalence, we need to remember that
2676 this value is held in the named register. */
2677 if (found)
2678 return;
2680 /* ??? Attempt to find and merge equivalent MEMs or other
2681 expressions too. */
2683 val_bind (set, val, loc, false);
2686 /* Initialize dataflow set SET to be empty.
2687 VARS_SIZE is the initial size of hash table VARS. */
2689 static void
2690 dataflow_set_init (dataflow_set *set)
2692 init_attrs_list_set (set->regs);
2693 set->vars = shared_hash_copy (empty_shared_hash);
2694 set->stack_adjust = 0;
2695 set->traversed_vars = NULL;
2698 /* Delete the contents of dataflow set SET. */
2700 static void
2701 dataflow_set_clear (dataflow_set *set)
2703 int i;
2705 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2706 attrs_list_clear (&set->regs[i]);
2708 shared_hash_destroy (set->vars);
2709 set->vars = shared_hash_copy (empty_shared_hash);
2712 /* Copy the contents of dataflow set SRC to DST. */
2714 static void
2715 dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
2717 int i;
2719 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2720 attrs_list_copy (&dst->regs[i], src->regs[i]);
2722 shared_hash_destroy (dst->vars);
2723 dst->vars = shared_hash_copy (src->vars);
2724 dst->stack_adjust = src->stack_adjust;
2727 /* Information for merging lists of locations for a given offset of variable.
2729 struct variable_union_info
2731 /* Node of the location chain. */
2732 location_chain *lc;
2734 /* The sum of positions in the input chains. */
2735 int pos;
2737 /* The position in the chain of DST dataflow set. */
2738 int pos_dst;
2741 /* Buffer for location list sorting and its allocated size. */
2742 static struct variable_union_info *vui_vec;
2743 static int vui_allocated;
2745 /* Compare function for qsort, order the structures by POS element. */
2747 static int
2748 variable_union_info_cmp_pos (const void *n1, const void *n2)
2750 const struct variable_union_info *const i1 =
2751 (const struct variable_union_info *) n1;
2752 const struct variable_union_info *const i2 =
2753 ( const struct variable_union_info *) n2;
2755 if (i1->pos != i2->pos)
2756 return i1->pos - i2->pos;
2758 return (i1->pos_dst - i2->pos_dst);
2761 /* Compute union of location parts of variable *SLOT and the same variable
2762 from hash table DATA. Compute "sorted" union of the location chains
2763 for common offsets, i.e. the locations of a variable part are sorted by
2764 a priority where the priority is the sum of the positions in the 2 chains
2765 (if a location is only in one list the position in the second list is
2766 defined to be larger than the length of the chains).
2767 When we are updating the location parts the newest location is in the
2768 beginning of the chain, so when we do the described "sorted" union
2769 we keep the newest locations in the beginning. */
2771 static int
2772 variable_union (variable *src, dataflow_set *set)
2774 variable *dst;
2775 variable **dstp;
2776 int i, j, k;
2778 dstp = shared_hash_find_slot (set->vars, src->dv);
2779 if (!dstp || !*dstp)
2781 src->refcount++;
2783 dst_can_be_shared = false;
2784 if (!dstp)
2785 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2787 *dstp = src;
2789 /* Continue traversing the hash table. */
2790 return 1;
2792 else
2793 dst = *dstp;
2795 gcc_assert (src->n_var_parts);
2796 gcc_checking_assert (src->onepart == dst->onepart);
2798 /* We can combine one-part variables very efficiently, because their
2799 entries are in canonical order. */
2800 if (src->onepart)
2802 location_chain **nodep, *dnode, *snode;
2804 gcc_assert (src->n_var_parts == 1
2805 && dst->n_var_parts == 1);
2807 snode = src->var_part[0].loc_chain;
2808 gcc_assert (snode);
2810 restart_onepart_unshared:
2811 nodep = &dst->var_part[0].loc_chain;
2812 dnode = *nodep;
2813 gcc_assert (dnode);
2815 while (snode)
2817 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2819 if (r > 0)
2821 location_chain *nnode;
2823 if (shared_var_p (dst, set->vars))
2825 dstp = unshare_variable (set, dstp, dst,
2826 VAR_INIT_STATUS_INITIALIZED);
2827 dst = *dstp;
2828 goto restart_onepart_unshared;
2831 *nodep = nnode = new location_chain;
2832 nnode->loc = snode->loc;
2833 nnode->init = snode->init;
2834 if (!snode->set_src || MEM_P (snode->set_src))
2835 nnode->set_src = NULL;
2836 else
2837 nnode->set_src = snode->set_src;
2838 nnode->next = dnode;
2839 dnode = nnode;
2841 else if (r == 0)
2842 gcc_checking_assert (rtx_equal_p (dnode->loc, snode->loc));
2844 if (r >= 0)
2845 snode = snode->next;
2847 nodep = &dnode->next;
2848 dnode = *nodep;
2851 return 1;
2854 gcc_checking_assert (!src->onepart);
2856 /* Count the number of location parts, result is K. */
2857 for (i = 0, j = 0, k = 0;
2858 i < src->n_var_parts && j < dst->n_var_parts; k++)
2860 if (VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2862 i++;
2863 j++;
2865 else if (VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
2866 i++;
2867 else
2868 j++;
2870 k += src->n_var_parts - i;
2871 k += dst->n_var_parts - j;
2873 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2874 thus there are at most MAX_VAR_PARTS different offsets. */
2875 gcc_checking_assert (dst->onepart ? k == 1 : k <= MAX_VAR_PARTS);
2877 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2879 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2880 dst = *dstp;
2883 i = src->n_var_parts - 1;
2884 j = dst->n_var_parts - 1;
2885 dst->n_var_parts = k;
2887 for (k--; k >= 0; k--)
2889 location_chain *node, *node2;
2891 if (i >= 0 && j >= 0
2892 && VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2894 /* Compute the "sorted" union of the chains, i.e. the locations which
2895 are in both chains go first, they are sorted by the sum of
2896 positions in the chains. */
2897 int dst_l, src_l;
2898 int ii, jj, n;
2899 struct variable_union_info *vui;
2901 /* If DST is shared compare the location chains.
2902 If they are different we will modify the chain in DST with
2903 high probability so make a copy of DST. */
2904 if (shared_var_p (dst, set->vars))
2906 for (node = src->var_part[i].loc_chain,
2907 node2 = dst->var_part[j].loc_chain; node && node2;
2908 node = node->next, node2 = node2->next)
2910 if (!((REG_P (node2->loc)
2911 && REG_P (node->loc)
2912 && REGNO (node2->loc) == REGNO (node->loc))
2913 || rtx_equal_p (node2->loc, node->loc)))
2915 if (node2->init < node->init)
2916 node2->init = node->init;
2917 break;
2920 if (node || node2)
2922 dstp = unshare_variable (set, dstp, dst,
2923 VAR_INIT_STATUS_UNKNOWN);
2924 dst = (variable *)*dstp;
2928 src_l = 0;
2929 for (node = src->var_part[i].loc_chain; node; node = node->next)
2930 src_l++;
2931 dst_l = 0;
2932 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2933 dst_l++;
2935 if (dst_l == 1)
2937 /* The most common case, much simpler, no qsort is needed. */
2938 location_chain *dstnode = dst->var_part[j].loc_chain;
2939 dst->var_part[k].loc_chain = dstnode;
2940 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
2941 node2 = dstnode;
2942 for (node = src->var_part[i].loc_chain; node; node = node->next)
2943 if (!((REG_P (dstnode->loc)
2944 && REG_P (node->loc)
2945 && REGNO (dstnode->loc) == REGNO (node->loc))
2946 || rtx_equal_p (dstnode->loc, node->loc)))
2948 location_chain *new_node;
2950 /* Copy the location from SRC. */
2951 new_node = new location_chain;
2952 new_node->loc = node->loc;
2953 new_node->init = node->init;
2954 if (!node->set_src || MEM_P (node->set_src))
2955 new_node->set_src = NULL;
2956 else
2957 new_node->set_src = node->set_src;
2958 node2->next = new_node;
2959 node2 = new_node;
2961 node2->next = NULL;
2963 else
2965 if (src_l + dst_l > vui_allocated)
2967 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l);
2968 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,
2969 vui_allocated);
2971 vui = vui_vec;
2973 /* Fill in the locations from DST. */
2974 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2975 node = node->next, jj++)
2977 vui[jj].lc = node;
2978 vui[jj].pos_dst = jj;
2980 /* Pos plus value larger than a sum of 2 valid positions. */
2981 vui[jj].pos = jj + src_l + dst_l;
2984 /* Fill in the locations from SRC. */
2985 n = dst_l;
2986 for (node = src->var_part[i].loc_chain, ii = 0; node;
2987 node = node->next, ii++)
2989 /* Find location from NODE. */
2990 for (jj = 0; jj < dst_l; jj++)
2992 if ((REG_P (vui[jj].lc->loc)
2993 && REG_P (node->loc)
2994 && REGNO (vui[jj].lc->loc) == REGNO (node->loc))
2995 || rtx_equal_p (vui[jj].lc->loc, node->loc))
2997 vui[jj].pos = jj + ii;
2998 break;
3001 if (jj >= dst_l) /* The location has not been found. */
3003 location_chain *new_node;
3005 /* Copy the location from SRC. */
3006 new_node = new location_chain;
3007 new_node->loc = node->loc;
3008 new_node->init = node->init;
3009 if (!node->set_src || MEM_P (node->set_src))
3010 new_node->set_src = NULL;
3011 else
3012 new_node->set_src = node->set_src;
3013 vui[n].lc = new_node;
3014 vui[n].pos_dst = src_l + dst_l;
3015 vui[n].pos = ii + src_l + dst_l;
3016 n++;
3020 if (dst_l == 2)
3022 /* Special case still very common case. For dst_l == 2
3023 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3024 vui[i].pos == i + src_l + dst_l. */
3025 if (vui[0].pos > vui[1].pos)
3027 /* Order should be 1, 0, 2... */
3028 dst->var_part[k].loc_chain = vui[1].lc;
3029 vui[1].lc->next = vui[0].lc;
3030 if (n >= 3)
3032 vui[0].lc->next = vui[2].lc;
3033 vui[n - 1].lc->next = NULL;
3035 else
3036 vui[0].lc->next = NULL;
3037 ii = 3;
3039 else
3041 dst->var_part[k].loc_chain = vui[0].lc;
3042 if (n >= 3 && vui[2].pos < vui[1].pos)
3044 /* Order should be 0, 2, 1, 3... */
3045 vui[0].lc->next = vui[2].lc;
3046 vui[2].lc->next = vui[1].lc;
3047 if (n >= 4)
3049 vui[1].lc->next = vui[3].lc;
3050 vui[n - 1].lc->next = NULL;
3052 else
3053 vui[1].lc->next = NULL;
3054 ii = 4;
3056 else
3058 /* Order should be 0, 1, 2... */
3059 ii = 1;
3060 vui[n - 1].lc->next = NULL;
3063 for (; ii < n; ii++)
3064 vui[ii - 1].lc->next = vui[ii].lc;
3066 else
3068 qsort (vui, n, sizeof (struct variable_union_info),
3069 variable_union_info_cmp_pos);
3071 /* Reconnect the nodes in sorted order. */
3072 for (ii = 1; ii < n; ii++)
3073 vui[ii - 1].lc->next = vui[ii].lc;
3074 vui[n - 1].lc->next = NULL;
3075 dst->var_part[k].loc_chain = vui[0].lc;
3078 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
3080 i--;
3081 j--;
3083 else if ((i >= 0 && j >= 0
3084 && VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
3085 || i < 0)
3087 dst->var_part[k] = dst->var_part[j];
3088 j--;
3090 else if ((i >= 0 && j >= 0
3091 && VAR_PART_OFFSET (src, i) > VAR_PART_OFFSET (dst, j))
3092 || j < 0)
3094 location_chain **nextp;
3096 /* Copy the chain from SRC. */
3097 nextp = &dst->var_part[k].loc_chain;
3098 for (node = src->var_part[i].loc_chain; node; node = node->next)
3100 location_chain *new_lc;
3102 new_lc = new location_chain;
3103 new_lc->next = NULL;
3104 new_lc->init = node->init;
3105 if (!node->set_src || MEM_P (node->set_src))
3106 new_lc->set_src = NULL;
3107 else
3108 new_lc->set_src = node->set_src;
3109 new_lc->loc = node->loc;
3111 *nextp = new_lc;
3112 nextp = &new_lc->next;
3115 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (src, i);
3116 i--;
3118 dst->var_part[k].cur_loc = NULL;
3121 if (flag_var_tracking_uninit)
3122 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
3124 location_chain *node, *node2;
3125 for (node = src->var_part[i].loc_chain; node; node = node->next)
3126 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
3127 if (rtx_equal_p (node->loc, node2->loc))
3129 if (node->init > node2->init)
3130 node2->init = node->init;
3134 /* Continue traversing the hash table. */
3135 return 1;
3138 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3140 static void
3141 dataflow_set_union (dataflow_set *dst, dataflow_set *src)
3143 int i;
3145 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3146 attrs_list_union (&dst->regs[i], src->regs[i]);
3148 if (dst->vars == empty_shared_hash)
3150 shared_hash_destroy (dst->vars);
3151 dst->vars = shared_hash_copy (src->vars);
3153 else
3155 variable_iterator_type hi;
3156 variable *var;
3158 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars),
3159 var, variable, hi)
3160 variable_union (var, dst);
3164 /* Whether the value is currently being expanded. */
3165 #define VALUE_RECURSED_INTO(x) \
3166 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3168 /* Whether no expansion was found, saving useless lookups.
3169 It must only be set when VALUE_CHANGED is clear. */
3170 #define NO_LOC_P(x) \
3171 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3173 /* Whether cur_loc in the value needs to be (re)computed. */
3174 #define VALUE_CHANGED(x) \
3175 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3176 /* Whether cur_loc in the decl needs to be (re)computed. */
3177 #define DECL_CHANGED(x) TREE_VISITED (x)
3179 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3180 user DECLs, this means they're in changed_variables. Values and
3181 debug exprs may be left with this flag set if no user variable
3182 requires them to be evaluated. */
3184 static inline void
3185 set_dv_changed (decl_or_value dv, bool newv)
3187 switch (dv_onepart_p (dv))
3189 case ONEPART_VALUE:
3190 if (newv)
3191 NO_LOC_P (dv_as_value (dv)) = false;
3192 VALUE_CHANGED (dv_as_value (dv)) = newv;
3193 break;
3195 case ONEPART_DEXPR:
3196 if (newv)
3197 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv))) = false;
3198 /* Fall through. */
3200 default:
3201 DECL_CHANGED (dv_as_decl (dv)) = newv;
3202 break;
3206 /* Return true if DV needs to have its cur_loc recomputed. */
3208 static inline bool
3209 dv_changed_p (decl_or_value dv)
3211 return (dv_is_value_p (dv)
3212 ? VALUE_CHANGED (dv_as_value (dv))
3213 : DECL_CHANGED (dv_as_decl (dv)));
3216 /* Return a location list node whose loc is rtx_equal to LOC, in the
3217 location list of a one-part variable or value VAR, or in that of
3218 any values recursively mentioned in the location lists. VARS must
3219 be in star-canonical form. */
3221 static location_chain *
3222 find_loc_in_1pdv (rtx loc, variable *var, variable_table_type *vars)
3224 location_chain *node;
3225 enum rtx_code loc_code;
3227 if (!var)
3228 return NULL;
3230 gcc_checking_assert (var->onepart);
3232 if (!var->n_var_parts)
3233 return NULL;
3235 gcc_checking_assert (var->dv != loc);
3237 loc_code = GET_CODE (loc);
3238 for (node = var->var_part[0].loc_chain; node; node = node->next)
3240 decl_or_value dv;
3241 variable *rvar;
3243 if (GET_CODE (node->loc) != loc_code)
3245 if (GET_CODE (node->loc) != VALUE)
3246 continue;
3248 else if (loc == node->loc)
3249 return node;
3250 else if (loc_code != VALUE)
3252 if (rtx_equal_p (loc, node->loc))
3253 return node;
3254 continue;
3257 /* Since we're in star-canonical form, we don't need to visit
3258 non-canonical nodes: one-part variables and non-canonical
3259 values would only point back to the canonical node. */
3260 if (dv_is_value_p (var->dv)
3261 && !canon_value_cmp (node->loc, dv_as_value (var->dv)))
3263 /* Skip all subsequent VALUEs. */
3264 while (node->next && GET_CODE (node->next->loc) == VALUE)
3266 node = node->next;
3267 gcc_checking_assert (!canon_value_cmp (node->loc,
3268 dv_as_value (var->dv)));
3269 if (loc == node->loc)
3270 return node;
3272 continue;
3275 gcc_checking_assert (node == var->var_part[0].loc_chain);
3276 gcc_checking_assert (!node->next);
3278 dv = dv_from_value (node->loc);
3279 rvar = vars->find_with_hash (dv, dv_htab_hash (dv));
3280 return find_loc_in_1pdv (loc, rvar, vars);
3283 /* ??? Gotta look in cselib_val locations too. */
3285 return NULL;
3288 /* Hash table iteration argument passed to variable_merge. */
3289 struct dfset_merge
3291 /* The set in which the merge is to be inserted. */
3292 dataflow_set *dst;
3293 /* The set that we're iterating in. */
3294 dataflow_set *cur;
3295 /* The set that may contain the other dv we are to merge with. */
3296 dataflow_set *src;
3297 /* Number of onepart dvs in src. */
3298 int src_onepart_cnt;
3301 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3302 loc_cmp order, and it is maintained as such. */
3304 static void
3305 insert_into_intersection (location_chain **nodep, rtx loc,
3306 enum var_init_status status)
3308 location_chain *node;
3309 int r;
3311 for (node = *nodep; node; nodep = &node->next, node = *nodep)
3312 if ((r = loc_cmp (node->loc, loc)) == 0)
3314 node->init = MIN (node->init, status);
3315 return;
3317 else if (r > 0)
3318 break;
3320 node = new location_chain;
3322 node->loc = loc;
3323 node->set_src = NULL;
3324 node->init = status;
3325 node->next = *nodep;
3326 *nodep = node;
3329 /* Insert in DEST the intersection of the locations present in both
3330 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3331 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3332 DSM->dst. */
3334 static void
3335 intersect_loc_chains (rtx val, location_chain **dest, struct dfset_merge *dsm,
3336 location_chain *s1node, variable *s2var)
3338 dataflow_set *s1set = dsm->cur;
3339 dataflow_set *s2set = dsm->src;
3340 location_chain *found;
3342 if (s2var)
3344 location_chain *s2node;
3346 gcc_checking_assert (s2var->onepart);
3348 if (s2var->n_var_parts)
3350 s2node = s2var->var_part[0].loc_chain;
3352 for (; s1node && s2node;
3353 s1node = s1node->next, s2node = s2node->next)
3354 if (s1node->loc != s2node->loc)
3355 break;
3356 else if (s1node->loc == val)
3357 continue;
3358 else
3359 insert_into_intersection (dest, s1node->loc,
3360 MIN (s1node->init, s2node->init));
3364 for (; s1node; s1node = s1node->next)
3366 if (s1node->loc == val)
3367 continue;
3369 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
3370 shared_hash_htab (s2set->vars))))
3372 insert_into_intersection (dest, s1node->loc,
3373 MIN (s1node->init, found->init));
3374 continue;
3377 if (GET_CODE (s1node->loc) == VALUE
3378 && !VALUE_RECURSED_INTO (s1node->loc))
3380 decl_or_value dv = dv_from_value (s1node->loc);
3381 variable *svar = shared_hash_find (s1set->vars, dv);
3382 if (svar)
3384 if (svar->n_var_parts == 1)
3386 VALUE_RECURSED_INTO (s1node->loc) = true;
3387 intersect_loc_chains (val, dest, dsm,
3388 svar->var_part[0].loc_chain,
3389 s2var);
3390 VALUE_RECURSED_INTO (s1node->loc) = false;
3395 /* ??? gotta look in cselib_val locations too. */
3397 /* ??? if the location is equivalent to any location in src,
3398 searched recursively
3400 add to dst the values needed to represent the equivalence
3402 telling whether locations S is equivalent to another dv's
3403 location list:
3405 for each location D in the list
3407 if S and D satisfy rtx_equal_p, then it is present
3409 else if D is a value, recurse without cycles
3411 else if S and D have the same CODE and MODE
3413 for each operand oS and the corresponding oD
3415 if oS and oD are not equivalent, then S an D are not equivalent
3417 else if they are RTX vectors
3419 if any vector oS element is not equivalent to its respective oD,
3420 then S and D are not equivalent
3428 /* Return -1 if X should be before Y in a location list for a 1-part
3429 variable, 1 if Y should be before X, and 0 if they're equivalent
3430 and should not appear in the list. */
3432 static int
3433 loc_cmp (rtx x, rtx y)
3435 int i, j, r;
3436 RTX_CODE code = GET_CODE (x);
3437 const char *fmt;
3439 if (x == y)
3440 return 0;
3442 if (REG_P (x))
3444 if (!REG_P (y))
3445 return -1;
3446 gcc_assert (GET_MODE (x) == GET_MODE (y));
3447 if (REGNO (x) == REGNO (y))
3448 return 0;
3449 else if (REGNO (x) < REGNO (y))
3450 return -1;
3451 else
3452 return 1;
3455 if (REG_P (y))
3456 return 1;
3458 if (MEM_P (x))
3460 if (!MEM_P (y))
3461 return -1;
3462 gcc_assert (GET_MODE (x) == GET_MODE (y));
3463 return loc_cmp (XEXP (x, 0), XEXP (y, 0));
3466 if (MEM_P (y))
3467 return 1;
3469 if (GET_CODE (x) == VALUE)
3471 if (GET_CODE (y) != VALUE)
3472 return -1;
3473 /* Don't assert the modes are the same, that is true only
3474 when not recursing. (subreg:QI (value:SI 1:1) 0)
3475 and (subreg:QI (value:DI 2:2) 0) can be compared,
3476 even when the modes are different. */
3477 if (canon_value_cmp (x, y))
3478 return -1;
3479 else
3480 return 1;
3483 if (GET_CODE (y) == VALUE)
3484 return 1;
3486 /* Entry value is the least preferable kind of expression. */
3487 if (GET_CODE (x) == ENTRY_VALUE)
3489 if (GET_CODE (y) != ENTRY_VALUE)
3490 return 1;
3491 gcc_assert (GET_MODE (x) == GET_MODE (y));
3492 return loc_cmp (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
3495 if (GET_CODE (y) == ENTRY_VALUE)
3496 return -1;
3498 if (GET_CODE (x) == GET_CODE (y))
3499 /* Compare operands below. */;
3500 else if (GET_CODE (x) < GET_CODE (y))
3501 return -1;
3502 else
3503 return 1;
3505 gcc_assert (GET_MODE (x) == GET_MODE (y));
3507 if (GET_CODE (x) == DEBUG_EXPR)
3509 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3510 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))
3511 return -1;
3512 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3513 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)));
3514 return 1;
3517 fmt = GET_RTX_FORMAT (code);
3518 for (i = 0; i < GET_RTX_LENGTH (code); i++)
3519 switch (fmt[i])
3521 case 'w':
3522 if (XWINT (x, i) == XWINT (y, i))
3523 break;
3524 else if (XWINT (x, i) < XWINT (y, i))
3525 return -1;
3526 else
3527 return 1;
3529 case 'n':
3530 case 'i':
3531 if (XINT (x, i) == XINT (y, i))
3532 break;
3533 else if (XINT (x, i) < XINT (y, i))
3534 return -1;
3535 else
3536 return 1;
3538 case 'p':
3539 r = compare_sizes_for_sort (SUBREG_BYTE (x), SUBREG_BYTE (y));
3540 if (r != 0)
3541 return r;
3542 break;
3544 case 'V':
3545 case 'E':
3546 /* Compare the vector length first. */
3547 if (XVECLEN (x, i) == XVECLEN (y, i))
3548 /* Compare the vectors elements. */;
3549 else if (XVECLEN (x, i) < XVECLEN (y, i))
3550 return -1;
3551 else
3552 return 1;
3554 for (j = 0; j < XVECLEN (x, i); j++)
3555 if ((r = loc_cmp (XVECEXP (x, i, j),
3556 XVECEXP (y, i, j))))
3557 return r;
3558 break;
3560 case 'e':
3561 if ((r = loc_cmp (XEXP (x, i), XEXP (y, i))))
3562 return r;
3563 break;
3565 case 'S':
3566 case 's':
3567 if (XSTR (x, i) == XSTR (y, i))
3568 break;
3569 if (!XSTR (x, i))
3570 return -1;
3571 if (!XSTR (y, i))
3572 return 1;
3573 if ((r = strcmp (XSTR (x, i), XSTR (y, i))) == 0)
3574 break;
3575 else if (r < 0)
3576 return -1;
3577 else
3578 return 1;
3580 case 'u':
3581 /* These are just backpointers, so they don't matter. */
3582 break;
3584 case '0':
3585 case 't':
3586 break;
3588 /* It is believed that rtx's at this level will never
3589 contain anything but integers and other rtx's,
3590 except for within LABEL_REFs and SYMBOL_REFs. */
3591 default:
3592 gcc_unreachable ();
3594 if (CONST_WIDE_INT_P (x))
3596 /* Compare the vector length first. */
3597 if (CONST_WIDE_INT_NUNITS (x) >= CONST_WIDE_INT_NUNITS (y))
3598 return 1;
3599 else if (CONST_WIDE_INT_NUNITS (x) < CONST_WIDE_INT_NUNITS (y))
3600 return -1;
3602 /* Compare the vectors elements. */;
3603 for (j = CONST_WIDE_INT_NUNITS (x) - 1; j >= 0 ; j--)
3605 if (CONST_WIDE_INT_ELT (x, j) < CONST_WIDE_INT_ELT (y, j))
3606 return -1;
3607 if (CONST_WIDE_INT_ELT (x, j) > CONST_WIDE_INT_ELT (y, j))
3608 return 1;
3612 return 0;
3615 /* Check the order of entries in one-part variables. */
3618 canonicalize_loc_order_check (variable **slot,
3619 dataflow_set *data ATTRIBUTE_UNUSED)
3621 variable *var = *slot;
3622 location_chain *node, *next;
3624 #ifdef ENABLE_RTL_CHECKING
3625 int i;
3626 for (i = 0; i < var->n_var_parts; i++)
3627 gcc_assert (var->var_part[0].cur_loc == NULL);
3628 gcc_assert (!var->in_changed_variables);
3629 #endif
3631 if (!var->onepart)
3632 return 1;
3634 gcc_assert (var->n_var_parts == 1);
3635 node = var->var_part[0].loc_chain;
3636 gcc_assert (node);
3638 while ((next = node->next))
3640 gcc_assert (loc_cmp (node->loc, next->loc) < 0);
3641 node = next;
3644 return 1;
3647 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3648 more likely to be chosen as canonical for an equivalence set.
3649 Ensure less likely values can reach more likely neighbors, making
3650 the connections bidirectional. */
3653 canonicalize_values_mark (variable **slot, dataflow_set *set)
3655 variable *var = *slot;
3656 decl_or_value dv = var->dv;
3657 rtx val;
3658 location_chain *node;
3660 if (!dv_is_value_p (dv))
3661 return 1;
3663 gcc_checking_assert (var->n_var_parts == 1);
3665 val = dv_as_value (dv);
3667 for (node = var->var_part[0].loc_chain; node; node = node->next)
3668 if (GET_CODE (node->loc) == VALUE)
3670 if (canon_value_cmp (node->loc, val))
3671 VALUE_RECURSED_INTO (val) = true;
3672 else
3674 decl_or_value odv = dv_from_value (node->loc);
3675 variable **oslot;
3676 oslot = shared_hash_find_slot_noinsert (set->vars, odv);
3678 set_slot_part (set, val, oslot, odv, 0,
3679 node->init, NULL_RTX);
3681 VALUE_RECURSED_INTO (node->loc) = true;
3685 return 1;
3688 /* Remove redundant entries from equivalence lists in onepart
3689 variables, canonicalizing equivalence sets into star shapes. */
3692 canonicalize_values_star (variable **slot, dataflow_set *set)
3694 variable *var = *slot;
3695 decl_or_value dv = var->dv;
3696 location_chain *node;
3697 decl_or_value cdv;
3698 rtx val, cval;
3699 variable **cslot;
3700 bool has_value;
3701 bool has_marks;
3703 if (!var->onepart)
3704 return 1;
3706 gcc_checking_assert (var->n_var_parts == 1);
3708 if (dv_is_value_p (dv))
3710 cval = dv_as_value (dv);
3711 if (!VALUE_RECURSED_INTO (cval))
3712 return 1;
3713 VALUE_RECURSED_INTO (cval) = false;
3715 else
3716 cval = NULL_RTX;
3718 restart:
3719 val = cval;
3720 has_value = false;
3721 has_marks = false;
3723 gcc_assert (var->n_var_parts == 1);
3725 for (node = var->var_part[0].loc_chain; node; node = node->next)
3726 if (GET_CODE (node->loc) == VALUE)
3728 has_value = true;
3729 if (VALUE_RECURSED_INTO (node->loc))
3730 has_marks = true;
3731 if (canon_value_cmp (node->loc, cval))
3732 cval = node->loc;
3735 if (!has_value)
3736 return 1;
3738 if (cval == val)
3740 if (!has_marks || dv_is_decl_p (dv))
3741 return 1;
3743 /* Keep it marked so that we revisit it, either after visiting a
3744 child node, or after visiting a new parent that might be
3745 found out. */
3746 VALUE_RECURSED_INTO (val) = true;
3748 for (node = var->var_part[0].loc_chain; node; node = node->next)
3749 if (GET_CODE (node->loc) == VALUE
3750 && VALUE_RECURSED_INTO (node->loc))
3752 cval = node->loc;
3753 restart_with_cval:
3754 VALUE_RECURSED_INTO (cval) = false;
3755 dv = dv_from_value (cval);
3756 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3757 if (!slot)
3759 gcc_assert (dv_is_decl_p (var->dv));
3760 /* The canonical value was reset and dropped.
3761 Remove it. */
3762 clobber_variable_part (set, NULL, var->dv, 0, NULL);
3763 return 1;
3765 var = *slot;
3766 gcc_assert (dv_is_value_p (var->dv));
3767 if (var->n_var_parts == 0)
3768 return 1;
3769 gcc_assert (var->n_var_parts == 1);
3770 goto restart;
3773 VALUE_RECURSED_INTO (val) = false;
3775 return 1;
3778 /* Push values to the canonical one. */
3779 cdv = dv_from_value (cval);
3780 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3782 for (node = var->var_part[0].loc_chain; node; node = node->next)
3783 if (node->loc != cval)
3785 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3786 node->init, NULL_RTX);
3787 if (GET_CODE (node->loc) == VALUE)
3789 decl_or_value ndv = dv_from_value (node->loc);
3791 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX,
3792 NO_INSERT);
3794 if (canon_value_cmp (node->loc, val))
3796 /* If it could have been a local minimum, it's not any more,
3797 since it's now neighbor to cval, so it may have to push
3798 to it. Conversely, if it wouldn't have prevailed over
3799 val, then whatever mark it has is fine: if it was to
3800 push, it will now push to a more canonical node, but if
3801 it wasn't, then it has already pushed any values it might
3802 have to. */
3803 VALUE_RECURSED_INTO (node->loc) = true;
3804 /* Make sure we visit node->loc by ensuring we cval is
3805 visited too. */
3806 VALUE_RECURSED_INTO (cval) = true;
3808 else if (!VALUE_RECURSED_INTO (node->loc))
3809 /* If we have no need to "recurse" into this node, it's
3810 already "canonicalized", so drop the link to the old
3811 parent. */
3812 clobber_variable_part (set, cval, ndv, 0, NULL);
3814 else if (GET_CODE (node->loc) == REG)
3816 attrs *list = set->regs[REGNO (node->loc)], **listp;
3818 /* Change an existing attribute referring to dv so that it
3819 refers to cdv, removing any duplicate this might
3820 introduce, and checking that no previous duplicates
3821 existed, all in a single pass. */
3823 while (list)
3825 if (list->offset == 0 && (list->dv == dv || list->dv == cdv))
3826 break;
3828 list = list->next;
3831 gcc_assert (list);
3832 if (list->dv == dv)
3834 list->dv = cdv;
3835 for (listp = &list->next; (list = *listp); listp = &list->next)
3837 if (list->offset)
3838 continue;
3840 if (list->dv == cdv)
3842 *listp = list->next;
3843 delete list;
3844 list = *listp;
3845 break;
3848 gcc_assert (list->dv != dv);
3851 else if (list->dv == cdv)
3853 for (listp = &list->next; (list = *listp); listp = &list->next)
3855 if (list->offset)
3856 continue;
3858 if (list->dv == dv)
3860 *listp = list->next;
3861 delete list;
3862 list = *listp;
3863 break;
3866 gcc_assert (list->dv != cdv);
3869 else
3870 gcc_unreachable ();
3872 if (flag_checking)
3873 while (list)
3875 if (list->offset == 0 && (list->dv == dv || list->dv == cdv))
3876 gcc_unreachable ();
3878 list = list->next;
3883 if (val)
3884 set_slot_part (set, val, cslot, cdv, 0,
3885 VAR_INIT_STATUS_INITIALIZED, NULL_RTX);
3887 slot = clobber_slot_part (set, cval, slot, 0, NULL);
3889 /* Variable may have been unshared. */
3890 var = *slot;
3891 gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
3892 && var->var_part[0].loc_chain->next == NULL);
3894 if (VALUE_RECURSED_INTO (cval))
3895 goto restart_with_cval;
3897 return 1;
3900 /* Bind one-part variables to the canonical value in an equivalence
3901 set. Not doing this causes dataflow convergence failure in rare
3902 circumstances, see PR42873. Unfortunately we can't do this
3903 efficiently as part of canonicalize_values_star, since we may not
3904 have determined or even seen the canonical value of a set when we
3905 get to a variable that references another member of the set. */
3908 canonicalize_vars_star (variable **slot, dataflow_set *set)
3910 variable *var = *slot;
3911 decl_or_value dv = var->dv;
3912 location_chain *node;
3913 rtx cval;
3914 decl_or_value cdv;
3915 variable **cslot;
3916 variable *cvar;
3917 location_chain *cnode;
3919 if (!var->onepart || var->onepart == ONEPART_VALUE)
3920 return 1;
3922 gcc_assert (var->n_var_parts == 1);
3924 node = var->var_part[0].loc_chain;
3926 if (GET_CODE (node->loc) != VALUE)
3927 return 1;
3929 gcc_assert (!node->next);
3930 cval = node->loc;
3932 /* Push values to the canonical one. */
3933 cdv = dv_from_value (cval);
3934 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3935 if (!cslot)
3936 return 1;
3937 cvar = *cslot;
3938 gcc_assert (cvar->n_var_parts == 1);
3940 cnode = cvar->var_part[0].loc_chain;
3942 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3943 that are not “more canonical” than it. */
3944 if (GET_CODE (cnode->loc) != VALUE
3945 || !canon_value_cmp (cnode->loc, cval))
3946 return 1;
3948 /* CVAL was found to be non-canonical. Change the variable to point
3949 to the canonical VALUE. */
3950 gcc_assert (!cnode->next);
3951 cval = cnode->loc;
3953 slot = set_slot_part (set, cval, slot, dv, 0,
3954 node->init, node->set_src);
3955 clobber_slot_part (set, cval, slot, 0, node->set_src);
3957 return 1;
3960 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3961 corresponding entry in DSM->src. Multi-part variables are combined
3962 with variable_union, whereas onepart dvs are combined with
3963 intersection. */
3965 static int
3966 variable_merge_over_cur (variable *s1var, struct dfset_merge *dsm)
3968 dataflow_set *dst = dsm->dst;
3969 variable **dstslot;
3970 variable *s2var, *dvar = NULL;
3971 decl_or_value dv = s1var->dv;
3972 onepart_enum onepart = s1var->onepart;
3973 rtx val;
3974 hashval_t dvhash;
3975 location_chain *node, **nodep;
3977 /* If the incoming onepart variable has an empty location list, then
3978 the intersection will be just as empty. For other variables,
3979 it's always union. */
3980 gcc_checking_assert (s1var->n_var_parts
3981 && s1var->var_part[0].loc_chain);
3983 if (!onepart)
3984 return variable_union (s1var, dst);
3986 gcc_checking_assert (s1var->n_var_parts == 1);
3988 dvhash = dv_htab_hash (dv);
3989 if (dv_is_value_p (dv))
3990 val = dv_as_value (dv);
3991 else
3992 val = NULL;
3994 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
3995 if (!s2var)
3997 dst_can_be_shared = false;
3998 return 1;
4001 dsm->src_onepart_cnt--;
4002 gcc_assert (s2var->var_part[0].loc_chain
4003 && s2var->onepart == onepart
4004 && s2var->n_var_parts == 1);
4006 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4007 if (dstslot)
4009 dvar = *dstslot;
4010 gcc_assert (dvar->refcount == 1
4011 && dvar->onepart == onepart
4012 && dvar->n_var_parts == 1);
4013 nodep = &dvar->var_part[0].loc_chain;
4015 else
4017 nodep = &node;
4018 node = NULL;
4021 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
4023 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
4024 dvhash, INSERT);
4025 *dstslot = dvar = s2var;
4026 dvar->refcount++;
4028 else
4030 dst_can_be_shared = false;
4032 intersect_loc_chains (val, nodep, dsm,
4033 s1var->var_part[0].loc_chain, s2var);
4035 if (!dstslot)
4037 if (node)
4039 dvar = onepart_pool_allocate (onepart);
4040 dvar->dv = dv;
4041 dvar->refcount = 1;
4042 dvar->n_var_parts = 1;
4043 dvar->onepart = onepart;
4044 dvar->in_changed_variables = false;
4045 dvar->var_part[0].loc_chain = node;
4046 dvar->var_part[0].cur_loc = NULL;
4047 if (onepart)
4048 VAR_LOC_1PAUX (dvar) = NULL;
4049 else
4050 VAR_PART_OFFSET (dvar, 0) = 0;
4052 dstslot
4053 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
4054 INSERT);
4055 gcc_assert (!*dstslot);
4056 *dstslot = dvar;
4058 else
4059 return 1;
4063 nodep = &dvar->var_part[0].loc_chain;
4064 while ((node = *nodep))
4066 location_chain **nextp = &node->next;
4068 if (GET_CODE (node->loc) == REG)
4070 attrs *list;
4072 for (list = dst->regs[REGNO (node->loc)]; list; list = list->next)
4073 if (GET_MODE (node->loc) == GET_MODE (list->loc)
4074 && dv_is_value_p (list->dv))
4075 break;
4077 if (!list)
4078 attrs_list_insert (&dst->regs[REGNO (node->loc)],
4079 dv, 0, node->loc);
4080 /* If this value became canonical for another value that had
4081 this register, we want to leave it alone. */
4082 else if (dv_as_value (list->dv) != val)
4084 dstslot = set_slot_part (dst, dv_as_value (list->dv),
4085 dstslot, dv, 0,
4086 node->init, NULL_RTX);
4087 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
4089 /* Since nextp points into the removed node, we can't
4090 use it. The pointer to the next node moved to nodep.
4091 However, if the variable we're walking is unshared
4092 during our walk, we'll keep walking the location list
4093 of the previously-shared variable, in which case the
4094 node won't have been removed, and we'll want to skip
4095 it. That's why we test *nodep here. */
4096 if (*nodep != node)
4097 nextp = nodep;
4100 else
4101 /* Canonicalization puts registers first, so we don't have to
4102 walk it all. */
4103 break;
4104 nodep = nextp;
4107 if (dvar != *dstslot)
4108 dvar = *dstslot;
4109 nodep = &dvar->var_part[0].loc_chain;
4111 if (val)
4113 /* Mark all referenced nodes for canonicalization, and make sure
4114 we have mutual equivalence links. */
4115 VALUE_RECURSED_INTO (val) = true;
4116 for (node = *nodep; node; node = node->next)
4117 if (GET_CODE (node->loc) == VALUE)
4119 VALUE_RECURSED_INTO (node->loc) = true;
4120 set_variable_part (dst, val, dv_from_value (node->loc), 0,
4121 node->init, NULL, INSERT);
4124 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4125 gcc_assert (*dstslot == dvar);
4126 canonicalize_values_star (dstslot, dst);
4127 gcc_checking_assert (dstslot
4128 == shared_hash_find_slot_noinsert_1 (dst->vars,
4129 dv, dvhash));
4130 dvar = *dstslot;
4132 else
4134 bool has_value = false, has_other = false;
4136 /* If we have one value and anything else, we're going to
4137 canonicalize this, so make sure all values have an entry in
4138 the table and are marked for canonicalization. */
4139 for (node = *nodep; node; node = node->next)
4141 if (GET_CODE (node->loc) == VALUE)
4143 /* If this was marked during register canonicalization,
4144 we know we have to canonicalize values. */
4145 if (has_value)
4146 has_other = true;
4147 has_value = true;
4148 if (has_other)
4149 break;
4151 else
4153 has_other = true;
4154 if (has_value)
4155 break;
4159 if (has_value && has_other)
4161 for (node = *nodep; node; node = node->next)
4163 if (GET_CODE (node->loc) == VALUE)
4165 decl_or_value dv = dv_from_value (node->loc);
4166 variable **slot = NULL;
4168 if (shared_hash_shared (dst->vars))
4169 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
4170 if (!slot)
4171 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
4172 INSERT);
4173 if (!*slot)
4175 variable *var = onepart_pool_allocate (ONEPART_VALUE);
4176 var->dv = dv;
4177 var->refcount = 1;
4178 var->n_var_parts = 1;
4179 var->onepart = ONEPART_VALUE;
4180 var->in_changed_variables = false;
4181 var->var_part[0].loc_chain = NULL;
4182 var->var_part[0].cur_loc = NULL;
4183 VAR_LOC_1PAUX (var) = NULL;
4184 *slot = var;
4187 VALUE_RECURSED_INTO (node->loc) = true;
4191 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4192 gcc_assert (*dstslot == dvar);
4193 canonicalize_values_star (dstslot, dst);
4194 gcc_checking_assert (dstslot
4195 == shared_hash_find_slot_noinsert_1 (dst->vars,
4196 dv, dvhash));
4197 dvar = *dstslot;
4201 if (!onepart_variable_different_p (dvar, s2var))
4203 variable_htab_free (dvar);
4204 *dstslot = dvar = s2var;
4205 dvar->refcount++;
4207 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
4209 variable_htab_free (dvar);
4210 *dstslot = dvar = s1var;
4211 dvar->refcount++;
4212 dst_can_be_shared = false;
4214 else
4215 dst_can_be_shared = false;
4217 return 1;
4220 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4221 multi-part variable. Unions of multi-part variables and
4222 intersections of one-part ones will be handled in
4223 variable_merge_over_cur(). */
4225 static int
4226 variable_merge_over_src (variable *s2var, struct dfset_merge *dsm)
4228 dataflow_set *dst = dsm->dst;
4229 decl_or_value dv = s2var->dv;
4231 if (!s2var->onepart)
4233 variable **dstp = shared_hash_find_slot (dst->vars, dv);
4234 *dstp = s2var;
4235 s2var->refcount++;
4236 return 1;
4239 dsm->src_onepart_cnt++;
4240 return 1;
4243 /* Combine dataflow set information from SRC2 into DST, using PDST
4244 to carry over information across passes. */
4246 static void
4247 dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
4249 dataflow_set cur = *dst;
4250 dataflow_set *src1 = &cur;
4251 struct dfset_merge dsm;
4252 int i;
4253 size_t src1_elems, src2_elems;
4254 variable_iterator_type hi;
4255 variable *var;
4257 src1_elems = shared_hash_htab (src1->vars)->elements ();
4258 src2_elems = shared_hash_htab (src2->vars)->elements ();
4259 dataflow_set_init (dst);
4260 dst->stack_adjust = cur.stack_adjust;
4261 shared_hash_destroy (dst->vars);
4262 dst->vars = new shared_hash;
4263 dst->vars->refcount = 1;
4264 dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems));
4266 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4267 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
4269 dsm.dst = dst;
4270 dsm.src = src2;
4271 dsm.cur = src1;
4272 dsm.src_onepart_cnt = 0;
4274 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars),
4275 var, variable, hi)
4276 variable_merge_over_src (var, &dsm);
4277 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars),
4278 var, variable, hi)
4279 variable_merge_over_cur (var, &dsm);
4281 if (dsm.src_onepart_cnt)
4282 dst_can_be_shared = false;
4284 dataflow_set_destroy (src1);
4287 /* Mark register equivalences. */
4289 static void
4290 dataflow_set_equiv_regs (dataflow_set *set)
4292 int i;
4293 attrs *list, **listp;
4295 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4297 rtx canon[NUM_MACHINE_MODES];
4299 /* If the list is empty or one entry, no need to canonicalize
4300 anything. */
4301 if (set->regs[i] == NULL || set->regs[i]->next == NULL)
4302 continue;
4304 memset (canon, 0, sizeof (canon));
4306 for (list = set->regs[i]; list; list = list->next)
4307 if (list->offset == 0 && dv_is_value_p (list->dv))
4309 rtx val = dv_as_value (list->dv);
4310 rtx *cvalp = &canon[(int)GET_MODE (val)];
4311 rtx cval = *cvalp;
4313 if (canon_value_cmp (val, cval))
4314 *cvalp = val;
4317 for (list = set->regs[i]; list; list = list->next)
4318 if (list->offset == 0 && dv_onepart_p (list->dv))
4320 rtx cval = canon[(int)GET_MODE (list->loc)];
4322 if (!cval)
4323 continue;
4325 if (dv_is_value_p (list->dv))
4327 rtx val = dv_as_value (list->dv);
4329 if (val == cval)
4330 continue;
4332 VALUE_RECURSED_INTO (val) = true;
4333 set_variable_part (set, val, dv_from_value (cval), 0,
4334 VAR_INIT_STATUS_INITIALIZED,
4335 NULL, NO_INSERT);
4338 VALUE_RECURSED_INTO (cval) = true;
4339 set_variable_part (set, cval, list->dv, 0,
4340 VAR_INIT_STATUS_INITIALIZED, NULL, NO_INSERT);
4343 for (listp = &set->regs[i]; (list = *listp);
4344 listp = list ? &list->next : listp)
4345 if (list->offset == 0 && dv_onepart_p (list->dv))
4347 rtx cval = canon[(int)GET_MODE (list->loc)];
4348 variable **slot;
4350 if (!cval)
4351 continue;
4353 if (dv_is_value_p (list->dv))
4355 rtx val = dv_as_value (list->dv);
4356 if (!VALUE_RECURSED_INTO (val))
4357 continue;
4360 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
4361 canonicalize_values_star (slot, set);
4362 if (*listp != list)
4363 list = NULL;
4368 /* Remove any redundant values in the location list of VAR, which must
4369 be unshared and 1-part. */
4371 static void
4372 remove_duplicate_values (variable *var)
4374 location_chain *node, **nodep;
4376 gcc_assert (var->onepart);
4377 gcc_assert (var->n_var_parts == 1);
4378 gcc_assert (var->refcount == 1);
4380 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
4382 if (GET_CODE (node->loc) == VALUE)
4384 if (VALUE_RECURSED_INTO (node->loc))
4386 /* Remove duplicate value node. */
4387 *nodep = node->next;
4388 delete node;
4389 continue;
4391 else
4392 VALUE_RECURSED_INTO (node->loc) = true;
4394 nodep = &node->next;
4397 for (node = var->var_part[0].loc_chain; node; node = node->next)
4398 if (GET_CODE (node->loc) == VALUE)
4400 gcc_assert (VALUE_RECURSED_INTO (node->loc));
4401 VALUE_RECURSED_INTO (node->loc) = false;
4406 /* Hash table iteration argument passed to variable_post_merge. */
4407 struct dfset_post_merge
4409 /* The new input set for the current block. */
4410 dataflow_set *set;
4411 /* Pointer to the permanent input set for the current block, or
4412 NULL. */
4413 dataflow_set **permp;
4416 /* Create values for incoming expressions associated with one-part
4417 variables that don't have value numbers for them. */
4420 variable_post_merge_new_vals (variable **slot, dfset_post_merge *dfpm)
4422 dataflow_set *set = dfpm->set;
4423 variable *var = *slot;
4424 location_chain *node;
4426 if (!var->onepart || !var->n_var_parts)
4427 return 1;
4429 gcc_assert (var->n_var_parts == 1);
4431 if (dv_is_decl_p (var->dv))
4433 bool check_dupes = false;
4435 restart:
4436 for (node = var->var_part[0].loc_chain; node; node = node->next)
4438 if (GET_CODE (node->loc) == VALUE)
4439 gcc_assert (!VALUE_RECURSED_INTO (node->loc));
4440 else if (GET_CODE (node->loc) == REG)
4442 attrs *att, **attp, **curp = NULL;
4444 if (var->refcount != 1)
4446 slot = unshare_variable (set, slot, var,
4447 VAR_INIT_STATUS_INITIALIZED);
4448 var = *slot;
4449 goto restart;
4452 for (attp = &set->regs[REGNO (node->loc)]; (att = *attp);
4453 attp = &att->next)
4454 if (att->offset == 0
4455 && GET_MODE (att->loc) == GET_MODE (node->loc))
4457 if (dv_is_value_p (att->dv))
4459 rtx cval = dv_as_value (att->dv);
4460 node->loc = cval;
4461 check_dupes = true;
4462 break;
4464 else if (att->dv == var->dv)
4465 curp = attp;
4468 if (!curp)
4470 curp = attp;
4471 while (*curp)
4472 if ((*curp)->offset == 0
4473 && GET_MODE ((*curp)->loc) == GET_MODE (node->loc)
4474 && (*curp)->dv == var->dv)
4475 break;
4476 else
4477 curp = &(*curp)->next;
4478 gcc_assert (*curp);
4481 if (!att)
4483 decl_or_value cdv;
4484 rtx cval;
4486 if (!*dfpm->permp)
4488 *dfpm->permp = XNEW (dataflow_set);
4489 dataflow_set_init (*dfpm->permp);
4492 for (att = (*dfpm->permp)->regs[REGNO (node->loc)];
4493 att; att = att->next)
4494 if (GET_MODE (att->loc) == GET_MODE (node->loc))
4496 gcc_assert (att->offset == 0
4497 && dv_is_value_p (att->dv));
4498 val_reset (set, att->dv);
4499 break;
4502 if (att)
4504 cdv = att->dv;
4505 cval = dv_as_value (cdv);
4507 else
4509 /* Create a unique value to hold this register,
4510 that ought to be found and reused in
4511 subsequent rounds. */
4512 cselib_val *v;
4513 gcc_assert (!cselib_lookup (node->loc,
4514 GET_MODE (node->loc), 0,
4515 VOIDmode));
4516 v = cselib_lookup (node->loc, GET_MODE (node->loc), 1,
4517 VOIDmode);
4518 cselib_preserve_value (v);
4519 cselib_invalidate_rtx (node->loc);
4520 cval = v->val_rtx;
4521 cdv = dv_from_value (cval);
4522 if (dump_file)
4523 fprintf (dump_file,
4524 "Created new value %u:%u for reg %i\n",
4525 v->uid, v->hash, REGNO (node->loc));
4528 var_reg_decl_set (*dfpm->permp, node->loc,
4529 VAR_INIT_STATUS_INITIALIZED,
4530 cdv, 0, NULL, INSERT);
4532 node->loc = cval;
4533 check_dupes = true;
4536 /* Remove attribute referring to the decl, which now
4537 uses the value for the register, already existing or
4538 to be added when we bring perm in. */
4539 att = *curp;
4540 *curp = att->next;
4541 delete att;
4545 if (check_dupes)
4546 remove_duplicate_values (var);
4549 return 1;
4552 /* Reset values in the permanent set that are not associated with the
4553 chosen expression. */
4556 variable_post_merge_perm_vals (variable **pslot, dfset_post_merge *dfpm)
4558 dataflow_set *set = dfpm->set;
4559 variable *pvar = *pslot, *var;
4560 location_chain *pnode;
4561 decl_or_value dv;
4562 attrs *att;
4564 gcc_assert (dv_is_value_p (pvar->dv)
4565 && pvar->n_var_parts == 1);
4566 pnode = pvar->var_part[0].loc_chain;
4567 gcc_assert (pnode
4568 && !pnode->next
4569 && REG_P (pnode->loc));
4571 dv = pvar->dv;
4573 var = shared_hash_find (set->vars, dv);
4574 if (var)
4576 /* Although variable_post_merge_new_vals may have made decls
4577 non-star-canonical, values that pre-existed in canonical form
4578 remain canonical, and newly-created values reference a single
4579 REG, so they are canonical as well. Since VAR has the
4580 location list for a VALUE, using find_loc_in_1pdv for it is
4581 fine, since VALUEs don't map back to DECLs. */
4582 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
4583 return 1;
4584 val_reset (set, dv);
4587 for (att = set->regs[REGNO (pnode->loc)]; att; att = att->next)
4588 if (att->offset == 0
4589 && GET_MODE (att->loc) == GET_MODE (pnode->loc)
4590 && dv_is_value_p (att->dv))
4591 break;
4593 /* If there is a value associated with this register already, create
4594 an equivalence. */
4595 if (att && dv_as_value (att->dv) != dv_as_value (dv))
4597 rtx cval = dv_as_value (att->dv);
4598 set_variable_part (set, cval, dv, 0, pnode->init, NULL, INSERT);
4599 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
4600 NULL, INSERT);
4602 else if (!att)
4604 attrs_list_insert (&set->regs[REGNO (pnode->loc)],
4605 dv, 0, pnode->loc);
4606 variable_union (pvar, set);
4609 return 1;
4612 /* Just checking stuff and registering register attributes for
4613 now. */
4615 static void
4616 dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
4618 struct dfset_post_merge dfpm;
4620 dfpm.set = set;
4621 dfpm.permp = permp;
4623 shared_hash_htab (set->vars)
4624 ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm);
4625 if (*permp)
4626 shared_hash_htab ((*permp)->vars)
4627 ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm);
4628 shared_hash_htab (set->vars)
4629 ->traverse <dataflow_set *, canonicalize_values_star> (set);
4630 shared_hash_htab (set->vars)
4631 ->traverse <dataflow_set *, canonicalize_vars_star> (set);
4634 /* Return a node whose loc is a MEM that refers to EXPR in the
4635 location list of a one-part variable or value VAR, or in that of
4636 any values recursively mentioned in the location lists. */
4638 static location_chain *
4639 find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars)
4641 location_chain *node;
4642 decl_or_value dv;
4643 variable *var;
4644 location_chain *where = NULL;
4646 if (!val)
4647 return NULL;
4649 gcc_assert (GET_CODE (val) == VALUE
4650 && !VALUE_RECURSED_INTO (val));
4652 dv = dv_from_value (val);
4653 var = vars->find_with_hash (dv, dv_htab_hash (dv));
4655 if (!var)
4656 return NULL;
4658 gcc_assert (var->onepart);
4660 if (!var->n_var_parts)
4661 return NULL;
4663 VALUE_RECURSED_INTO (val) = true;
4665 for (node = var->var_part[0].loc_chain; node; node = node->next)
4666 if (MEM_P (node->loc)
4667 && MEM_EXPR (node->loc) == expr
4668 && int_mem_offset (node->loc) == 0)
4670 where = node;
4671 break;
4673 else if (GET_CODE (node->loc) == VALUE
4674 && !VALUE_RECURSED_INTO (node->loc)
4675 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
4676 break;
4678 VALUE_RECURSED_INTO (val) = false;
4680 return where;
4683 /* Return TRUE if the value of MEM may vary across a call. */
4685 static bool
4686 mem_dies_at_call (rtx mem)
4688 tree expr = MEM_EXPR (mem);
4689 tree decl;
4691 if (!expr)
4692 return true;
4694 decl = get_base_address (expr);
4696 if (!decl)
4697 return true;
4699 if (!DECL_P (decl))
4700 return true;
4702 return (may_be_aliased (decl)
4703 || (!TREE_READONLY (decl) && is_global_var (decl)));
4706 /* Remove all MEMs from the location list of a hash table entry for a
4707 one-part variable, except those whose MEM attributes map back to
4708 the variable itself, directly or within a VALUE. */
4711 dataflow_set_preserve_mem_locs (variable **slot, dataflow_set *set)
4713 variable *var = *slot;
4715 if (var->onepart == ONEPART_VDECL || var->onepart == ONEPART_DEXPR)
4717 tree decl = dv_as_decl (var->dv);
4718 location_chain *loc, **locp;
4719 bool changed = false;
4721 if (!var->n_var_parts)
4722 return 1;
4724 gcc_assert (var->n_var_parts == 1);
4726 if (shared_var_p (var, set->vars))
4728 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4730 /* We want to remove dying MEMs that don't refer to DECL. */
4731 if (GET_CODE (loc->loc) == MEM
4732 && (MEM_EXPR (loc->loc) != decl
4733 || int_mem_offset (loc->loc) != 0)
4734 && mem_dies_at_call (loc->loc))
4735 break;
4736 /* We want to move here MEMs that do refer to DECL. */
4737 else if (GET_CODE (loc->loc) == VALUE
4738 && find_mem_expr_in_1pdv (decl, loc->loc,
4739 shared_hash_htab (set->vars)))
4740 break;
4743 if (!loc)
4744 return 1;
4746 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4747 var = *slot;
4748 gcc_assert (var->n_var_parts == 1);
4751 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4752 loc; loc = *locp)
4754 rtx old_loc = loc->loc;
4755 if (GET_CODE (old_loc) == VALUE)
4757 location_chain *mem_node
4758 = find_mem_expr_in_1pdv (decl, loc->loc,
4759 shared_hash_htab (set->vars));
4761 /* ??? This picks up only one out of multiple MEMs that
4762 refer to the same variable. Do we ever need to be
4763 concerned about dealing with more than one, or, given
4764 that they should all map to the same variable
4765 location, their addresses will have been merged and
4766 they will be regarded as equivalent? */
4767 if (mem_node)
4769 loc->loc = mem_node->loc;
4770 loc->set_src = mem_node->set_src;
4771 loc->init = MIN (loc->init, mem_node->init);
4775 if (GET_CODE (loc->loc) != MEM
4776 || (MEM_EXPR (loc->loc) == decl
4777 && int_mem_offset (loc->loc) == 0)
4778 || !mem_dies_at_call (loc->loc))
4780 if (old_loc != loc->loc && emit_notes)
4782 if (old_loc == var->var_part[0].cur_loc)
4784 changed = true;
4785 var->var_part[0].cur_loc = NULL;
4788 locp = &loc->next;
4789 continue;
4792 if (emit_notes)
4794 if (old_loc == var->var_part[0].cur_loc)
4796 changed = true;
4797 var->var_part[0].cur_loc = NULL;
4800 *locp = loc->next;
4801 delete loc;
4804 if (!var->var_part[0].loc_chain)
4806 var->n_var_parts--;
4807 changed = true;
4809 if (changed)
4810 variable_was_changed (var, set);
4813 return 1;
4816 /* Remove all MEMs from the location list of a hash table entry for a
4817 onepart variable. */
4820 dataflow_set_remove_mem_locs (variable **slot, dataflow_set *set)
4822 variable *var = *slot;
4824 if (var->onepart != NOT_ONEPART)
4826 location_chain *loc, **locp;
4827 bool changed = false;
4828 rtx cur_loc;
4830 gcc_assert (var->n_var_parts == 1);
4832 if (shared_var_p (var, set->vars))
4834 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4835 if (GET_CODE (loc->loc) == MEM
4836 && mem_dies_at_call (loc->loc))
4837 break;
4839 if (!loc)
4840 return 1;
4842 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4843 var = *slot;
4844 gcc_assert (var->n_var_parts == 1);
4847 if (VAR_LOC_1PAUX (var))
4848 cur_loc = VAR_LOC_FROM (var);
4849 else
4850 cur_loc = var->var_part[0].cur_loc;
4852 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4853 loc; loc = *locp)
4855 if (GET_CODE (loc->loc) != MEM
4856 || !mem_dies_at_call (loc->loc))
4858 locp = &loc->next;
4859 continue;
4862 *locp = loc->next;
4863 /* If we have deleted the location which was last emitted
4864 we have to emit new location so add the variable to set
4865 of changed variables. */
4866 if (cur_loc == loc->loc)
4868 changed = true;
4869 var->var_part[0].cur_loc = NULL;
4870 if (VAR_LOC_1PAUX (var))
4871 VAR_LOC_FROM (var) = NULL;
4873 delete loc;
4876 if (!var->var_part[0].loc_chain)
4878 var->n_var_parts--;
4879 changed = true;
4881 if (changed)
4882 variable_was_changed (var, set);
4885 return 1;
4888 /* Remove all variable-location information about call-clobbered
4889 registers, as well as associations between MEMs and VALUEs. */
4891 static void
4892 dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
4894 unsigned int r;
4895 hard_reg_set_iterator hrsi;
4897 HARD_REG_SET callee_clobbers
4898 = insn_callee_abi (call_insn).full_reg_clobbers ();
4900 EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, r, hrsi)
4901 var_regno_delete (set, r);
4903 if (MAY_HAVE_DEBUG_BIND_INSNS)
4905 set->traversed_vars = set->vars;
4906 shared_hash_htab (set->vars)
4907 ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
4908 set->traversed_vars = set->vars;
4909 shared_hash_htab (set->vars)
4910 ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set);
4911 set->traversed_vars = NULL;
4915 static bool
4916 variable_part_different_p (variable_part *vp1, variable_part *vp2)
4918 location_chain *lc1, *lc2;
4920 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4922 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4924 if (REG_P (lc1->loc) && REG_P (lc2->loc))
4926 if (REGNO (lc1->loc) == REGNO (lc2->loc))
4927 break;
4929 if (rtx_equal_p (lc1->loc, lc2->loc))
4930 break;
4932 if (!lc2)
4933 return true;
4935 return false;
4938 /* Return true if one-part variables VAR1 and VAR2 are different.
4939 They must be in canonical order. */
4941 static bool
4942 onepart_variable_different_p (variable *var1, variable *var2)
4944 location_chain *lc1, *lc2;
4946 if (var1 == var2)
4947 return false;
4949 gcc_assert (var1->n_var_parts == 1
4950 && var2->n_var_parts == 1);
4952 lc1 = var1->var_part[0].loc_chain;
4953 lc2 = var2->var_part[0].loc_chain;
4955 gcc_assert (lc1 && lc2);
4957 while (lc1 && lc2)
4959 if (loc_cmp (lc1->loc, lc2->loc))
4960 return true;
4961 lc1 = lc1->next;
4962 lc2 = lc2->next;
4965 return lc1 != lc2;
4968 /* Return true if one-part variables VAR1 and VAR2 are different.
4969 They must be in canonical order. */
4971 static void
4972 dump_onepart_variable_differences (variable *var1, variable *var2)
4974 location_chain *lc1, *lc2;
4976 gcc_assert (var1 != var2);
4977 gcc_assert (dump_file);
4978 gcc_assert (var1->dv == var2->dv);
4979 gcc_assert (var1->n_var_parts == 1
4980 && var2->n_var_parts == 1);
4982 lc1 = var1->var_part[0].loc_chain;
4983 lc2 = var2->var_part[0].loc_chain;
4985 gcc_assert (lc1 && lc2);
4987 while (lc1 && lc2)
4989 switch (loc_cmp (lc1->loc, lc2->loc))
4991 case -1:
4992 fprintf (dump_file, "removed: ");
4993 print_rtl_single (dump_file, lc1->loc);
4994 lc1 = lc1->next;
4995 continue;
4996 case 0:
4997 break;
4998 case 1:
4999 fprintf (dump_file, "added: ");
5000 print_rtl_single (dump_file, lc2->loc);
5001 lc2 = lc2->next;
5002 continue;
5003 default:
5004 gcc_unreachable ();
5006 lc1 = lc1->next;
5007 lc2 = lc2->next;
5010 while (lc1)
5012 fprintf (dump_file, "removed: ");
5013 print_rtl_single (dump_file, lc1->loc);
5014 lc1 = lc1->next;
5017 while (lc2)
5019 fprintf (dump_file, "added: ");
5020 print_rtl_single (dump_file, lc2->loc);
5021 lc2 = lc2->next;
5025 /* Return true if variables VAR1 and VAR2 are different. */
5027 static bool
5028 variable_different_p (variable *var1, variable *var2)
5030 int i;
5032 if (var1 == var2)
5033 return false;
5035 if (var1->onepart != var2->onepart)
5036 return true;
5038 if (var1->n_var_parts != var2->n_var_parts)
5039 return true;
5041 if (var1->onepart && var1->n_var_parts)
5043 gcc_checking_assert (var1->dv == var2->dv && var1->n_var_parts == 1);
5044 /* One-part values have locations in a canonical order. */
5045 return onepart_variable_different_p (var1, var2);
5048 for (i = 0; i < var1->n_var_parts; i++)
5050 if (VAR_PART_OFFSET (var1, i) != VAR_PART_OFFSET (var2, i))
5051 return true;
5052 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
5053 return true;
5054 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
5055 return true;
5057 return false;
5060 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5062 static bool
5063 dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
5065 variable_iterator_type hi;
5066 variable *var1;
5067 bool diffound = false;
5068 bool details = (dump_file && (dump_flags & TDF_DETAILS));
5070 #define RETRUE \
5071 do \
5073 if (!details) \
5074 return true; \
5075 else \
5076 diffound = true; \
5078 while (0)
5080 if (old_set->vars == new_set->vars)
5081 return false;
5083 if (shared_hash_htab (old_set->vars)->elements ()
5084 != shared_hash_htab (new_set->vars)->elements ())
5085 RETRUE;
5087 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars),
5088 var1, variable, hi)
5090 variable_table_type *htab = shared_hash_htab (new_set->vars);
5091 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5093 if (!var2)
5095 if (dump_file && (dump_flags & TDF_DETAILS))
5097 fprintf (dump_file, "dataflow difference found: removal of:\n");
5098 dump_var (var1);
5100 RETRUE;
5102 else if (variable_different_p (var1, var2))
5104 if (details)
5106 fprintf (dump_file, "dataflow difference found: "
5107 "old and new follow:\n");
5108 dump_var (var1);
5109 if (dv_onepart_p (var1->dv))
5110 dump_onepart_variable_differences (var1, var2);
5111 dump_var (var2);
5113 RETRUE;
5117 /* There's no need to traverse the second hashtab unless we want to
5118 print the details. If both have the same number of elements and
5119 the second one had all entries found in the first one, then the
5120 second can't have any extra entries. */
5121 if (!details)
5122 return diffound;
5124 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set->vars),
5125 var1, variable, hi)
5127 variable_table_type *htab = shared_hash_htab (old_set->vars);
5128 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5129 if (!var2)
5131 if (details)
5133 fprintf (dump_file, "dataflow difference found: addition of:\n");
5134 dump_var (var1);
5136 RETRUE;
5140 #undef RETRUE
5142 return diffound;
5145 /* Free the contents of dataflow set SET. */
5147 static void
5148 dataflow_set_destroy (dataflow_set *set)
5150 int i;
5152 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5153 attrs_list_clear (&set->regs[i]);
5155 shared_hash_destroy (set->vars);
5156 set->vars = NULL;
5159 /* Return true if T is a tracked parameter with non-degenerate record type. */
5161 static bool
5162 tracked_record_parameter_p (tree t)
5164 if (TREE_CODE (t) != PARM_DECL)
5165 return false;
5167 if (DECL_MODE (t) == BLKmode)
5168 return false;
5170 tree type = TREE_TYPE (t);
5171 if (TREE_CODE (type) != RECORD_TYPE)
5172 return false;
5174 if (TYPE_FIELDS (type) == NULL_TREE
5175 || DECL_CHAIN (TYPE_FIELDS (type)) == NULL_TREE)
5176 return false;
5178 return true;
5181 /* Shall EXPR be tracked? */
5183 static bool
5184 track_expr_p (tree expr, bool need_rtl)
5186 rtx decl_rtl;
5187 tree realdecl;
5189 if (TREE_CODE (expr) == DEBUG_EXPR_DECL)
5190 return DECL_RTL_SET_P (expr);
5192 /* If EXPR is not a parameter or a variable do not track it. */
5193 if (!VAR_P (expr) && TREE_CODE (expr) != PARM_DECL)
5194 return 0;
5196 /* It also must have a name... */
5197 if (!DECL_NAME (expr) && need_rtl)
5198 return 0;
5200 /* ... and a RTL assigned to it. */
5201 decl_rtl = DECL_RTL_IF_SET (expr);
5202 if (!decl_rtl && need_rtl)
5203 return 0;
5205 /* If this expression is really a debug alias of some other declaration, we
5206 don't need to track this expression if the ultimate declaration is
5207 ignored. */
5208 realdecl = expr;
5209 if (VAR_P (realdecl) && DECL_HAS_DEBUG_EXPR_P (realdecl))
5211 realdecl = DECL_DEBUG_EXPR (realdecl);
5212 if (!DECL_P (realdecl))
5214 if (handled_component_p (realdecl)
5215 || (TREE_CODE (realdecl) == MEM_REF
5216 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5218 HOST_WIDE_INT bitsize, bitpos;
5219 bool reverse;
5220 tree innerdecl
5221 = get_ref_base_and_extent_hwi (realdecl, &bitpos,
5222 &bitsize, &reverse);
5223 if (!innerdecl
5224 || !DECL_P (innerdecl)
5225 || DECL_IGNORED_P (innerdecl)
5226 /* Do not track declarations for parts of tracked record
5227 parameters since we want to track them as a whole. */
5228 || tracked_record_parameter_p (innerdecl)
5229 || TREE_STATIC (innerdecl)
5230 || bitsize == 0
5231 || bitpos + bitsize > 256)
5232 return 0;
5233 else
5234 realdecl = expr;
5236 else
5237 return 0;
5241 /* Do not track EXPR if REALDECL it should be ignored for debugging
5242 purposes. */
5243 if (DECL_IGNORED_P (realdecl))
5244 return 0;
5246 /* Do not track global variables until we are able to emit correct location
5247 list for them. */
5248 if (TREE_STATIC (realdecl))
5249 return 0;
5251 /* When the EXPR is a DECL for alias of some variable (see example)
5252 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5253 DECL_RTL contains SYMBOL_REF.
5255 Example:
5256 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5257 char **_dl_argv;
5259 if (decl_rtl && MEM_P (decl_rtl)
5260 && contains_symbol_ref_p (XEXP (decl_rtl, 0)))
5261 return 0;
5263 /* If RTX is a memory it should not be very large (because it would be
5264 an array or struct). */
5265 if (decl_rtl && MEM_P (decl_rtl))
5267 /* Do not track structures and arrays. */
5268 if ((GET_MODE (decl_rtl) == BLKmode
5269 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
5270 && !tracked_record_parameter_p (realdecl))
5271 return 0;
5272 if (MEM_SIZE_KNOWN_P (decl_rtl)
5273 && maybe_gt (MEM_SIZE (decl_rtl), MAX_VAR_PARTS))
5274 return 0;
5277 DECL_CHANGED (expr) = 0;
5278 DECL_CHANGED (realdecl) = 0;
5279 return 1;
5282 /* Determine whether a given LOC refers to the same variable part as
5283 EXPR+OFFSET. */
5285 static bool
5286 same_variable_part_p (rtx loc, tree expr, poly_int64 offset)
5288 tree expr2;
5289 poly_int64 offset2;
5291 if (! DECL_P (expr))
5292 return false;
5294 if (REG_P (loc))
5296 expr2 = REG_EXPR (loc);
5297 offset2 = REG_OFFSET (loc);
5299 else if (MEM_P (loc))
5301 expr2 = MEM_EXPR (loc);
5302 offset2 = int_mem_offset (loc);
5304 else
5305 return false;
5307 if (! expr2 || ! DECL_P (expr2))
5308 return false;
5310 expr = var_debug_decl (expr);
5311 expr2 = var_debug_decl (expr2);
5313 return (expr == expr2 && known_eq (offset, offset2));
5316 /* LOC is a REG or MEM that we would like to track if possible.
5317 If EXPR is null, we don't know what expression LOC refers to,
5318 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5319 LOC is an lvalue register.
5321 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5322 is something we can track. When returning true, store the mode of
5323 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5324 from EXPR in *OFFSET_OUT (if nonnull). */
5326 static bool
5327 track_loc_p (rtx loc, tree expr, poly_int64 offset, bool store_reg_p,
5328 machine_mode *mode_out, HOST_WIDE_INT *offset_out)
5330 machine_mode mode;
5332 if (expr == NULL || !track_expr_p (expr, true))
5333 return false;
5335 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5336 whole subreg, but only the old inner part is really relevant. */
5337 mode = GET_MODE (loc);
5338 if (REG_P (loc) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc)))
5340 machine_mode pseudo_mode;
5342 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc));
5343 if (paradoxical_subreg_p (mode, pseudo_mode))
5345 offset += byte_lowpart_offset (pseudo_mode, mode);
5346 mode = pseudo_mode;
5350 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5351 Do the same if we are storing to a register and EXPR occupies
5352 the whole of register LOC; in that case, the whole of EXPR is
5353 being changed. We exclude complex modes from the second case
5354 because the real and imaginary parts are represented as separate
5355 pseudo registers, even if the whole complex value fits into one
5356 hard register. */
5357 if ((paradoxical_subreg_p (mode, DECL_MODE (expr))
5358 || (store_reg_p
5359 && !COMPLEX_MODE_P (DECL_MODE (expr))
5360 && hard_regno_nregs (REGNO (loc), DECL_MODE (expr)) == 1))
5361 && known_eq (offset + byte_lowpart_offset (DECL_MODE (expr), mode), 0))
5363 mode = DECL_MODE (expr);
5364 offset = 0;
5367 HOST_WIDE_INT const_offset;
5368 if (!track_offset_p (offset, &const_offset))
5369 return false;
5371 if (mode_out)
5372 *mode_out = mode;
5373 if (offset_out)
5374 *offset_out = const_offset;
5375 return true;
5378 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5379 want to track. When returning nonnull, make sure that the attributes
5380 on the returned value are updated. */
5382 static rtx
5383 var_lowpart (machine_mode mode, rtx loc)
5385 unsigned int regno;
5387 if (GET_MODE (loc) == mode)
5388 return loc;
5390 if (!REG_P (loc) && !MEM_P (loc))
5391 return NULL;
5393 poly_uint64 offset = byte_lowpart_offset (mode, GET_MODE (loc));
5395 if (MEM_P (loc))
5396 return adjust_address_nv (loc, mode, offset);
5398 poly_uint64 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
5399 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
5400 reg_offset, mode);
5401 return gen_rtx_REG_offset (loc, mode, regno, offset);
5404 /* Carry information about uses and stores while walking rtx. */
5406 struct count_use_info
5408 /* The insn where the RTX is. */
5409 rtx_insn *insn;
5411 /* The basic block where insn is. */
5412 basic_block bb;
5414 /* The array of n_sets sets in the insn, as determined by cselib. */
5415 struct cselib_set *sets;
5416 int n_sets;
5418 /* True if we're counting stores, false otherwise. */
5419 bool store_p;
5422 /* Find a VALUE corresponding to X. */
5424 static inline cselib_val *
5425 find_use_val (rtx x, machine_mode mode, struct count_use_info *cui)
5427 int i;
5429 if (cui->sets)
5431 /* This is called after uses are set up and before stores are
5432 processed by cselib, so it's safe to look up srcs, but not
5433 dsts. So we look up expressions that appear in srcs or in
5434 dest expressions, but we search the sets array for dests of
5435 stores. */
5436 if (cui->store_p)
5438 /* Some targets represent memset and memcpy patterns
5439 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5440 (set (mem:BLK ...) (const_int ...)) or
5441 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5442 in that case, otherwise we end up with mode mismatches. */
5443 if (mode == BLKmode && MEM_P (x))
5444 return NULL;
5445 for (i = 0; i < cui->n_sets; i++)
5446 if (cui->sets[i].dest == x)
5447 return cui->sets[i].src_elt;
5449 else
5450 return cselib_lookup (x, mode, 0, VOIDmode);
5453 return NULL;
5456 /* Replace all registers and addresses in an expression with VALUE
5457 expressions that map back to them, unless the expression is a
5458 register. If no mapping is or can be performed, returns NULL. */
5460 static rtx
5461 replace_expr_with_values (rtx loc)
5463 if (REG_P (loc) || GET_CODE (loc) == ENTRY_VALUE)
5464 return NULL;
5465 else if (MEM_P (loc))
5467 cselib_val *addr = cselib_lookup (XEXP (loc, 0),
5468 get_address_mode (loc), 0,
5469 GET_MODE (loc));
5470 if (addr)
5471 return replace_equiv_address_nv (loc, addr->val_rtx);
5472 else
5473 return NULL;
5475 else
5476 return cselib_subst_to_values (loc, VOIDmode);
5479 /* Return true if X contains a DEBUG_EXPR. */
5481 static bool
5482 rtx_debug_expr_p (const_rtx x)
5484 subrtx_iterator::array_type array;
5485 FOR_EACH_SUBRTX (iter, array, x, ALL)
5486 if (GET_CODE (*iter) == DEBUG_EXPR)
5487 return true;
5488 return false;
5491 /* Determine what kind of micro operation to choose for a USE. Return
5492 MO_CLOBBER if no micro operation is to be generated. */
5494 static enum micro_operation_type
5495 use_type (rtx loc, struct count_use_info *cui, machine_mode *modep)
5497 tree expr;
5499 if (cui && cui->sets)
5501 if (GET_CODE (loc) == VAR_LOCATION)
5503 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc), false))
5505 rtx ploc = PAT_VAR_LOCATION_LOC (loc);
5506 if (! VAR_LOC_UNKNOWN_P (ploc))
5508 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc), 1,
5509 VOIDmode);
5511 /* ??? flag_float_store and volatile mems are never
5512 given values, but we could in theory use them for
5513 locations. */
5514 gcc_assert (val || 1);
5516 return MO_VAL_LOC;
5518 else
5519 return MO_CLOBBER;
5522 if (REG_P (loc) || MEM_P (loc))
5524 if (modep)
5525 *modep = GET_MODE (loc);
5526 if (cui->store_p)
5528 if (REG_P (loc)
5529 || (find_use_val (loc, GET_MODE (loc), cui)
5530 && cselib_lookup (XEXP (loc, 0),
5531 get_address_mode (loc), 0,
5532 GET_MODE (loc))))
5533 return MO_VAL_SET;
5535 else
5537 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5539 if (val && !cselib_preserved_value_p (val))
5540 return MO_VAL_USE;
5545 if (REG_P (loc))
5547 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER);
5549 if (loc == cfa_base_rtx)
5550 return MO_CLOBBER;
5551 expr = REG_EXPR (loc);
5553 if (!expr)
5554 return MO_USE_NO_VAR;
5555 else if (target_for_debug_bind (var_debug_decl (expr)))
5556 return MO_CLOBBER;
5557 else if (track_loc_p (loc, expr, REG_OFFSET (loc),
5558 false, modep, NULL))
5559 return MO_USE;
5560 else
5561 return MO_USE_NO_VAR;
5563 else if (MEM_P (loc))
5565 expr = MEM_EXPR (loc);
5567 if (!expr)
5568 return MO_CLOBBER;
5569 else if (target_for_debug_bind (var_debug_decl (expr)))
5570 return MO_CLOBBER;
5571 else if (track_loc_p (loc, expr, int_mem_offset (loc),
5572 false, modep, NULL)
5573 /* Multi-part variables shouldn't refer to one-part
5574 variable names such as VALUEs (never happens) or
5575 DEBUG_EXPRs (only happens in the presence of debug
5576 insns). */
5577 && (!MAY_HAVE_DEBUG_BIND_INSNS
5578 || !rtx_debug_expr_p (XEXP (loc, 0))))
5579 return MO_USE;
5580 else
5581 return MO_CLOBBER;
5584 return MO_CLOBBER;
5587 /* Log to OUT information about micro-operation MOPT involving X in
5588 INSN of BB. */
5590 static inline void
5591 log_op_type (rtx x, basic_block bb, rtx_insn *insn,
5592 enum micro_operation_type mopt, FILE *out)
5594 fprintf (out, "bb %i op %i insn %i %s ",
5595 bb->index, VTI (bb)->mos.length (),
5596 INSN_UID (insn), micro_operation_type_name[mopt]);
5597 print_inline_rtx (out, x, 2);
5598 fputc ('\n', out);
5601 /* Tell whether the CONCAT used to holds a VALUE and its location
5602 needs value resolution, i.e., an attempt of mapping the location
5603 back to other incoming values. */
5604 #define VAL_NEEDS_RESOLUTION(x) \
5605 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5606 /* Whether the location in the CONCAT is a tracked expression, that
5607 should also be handled like a MO_USE. */
5608 #define VAL_HOLDS_TRACK_EXPR(x) \
5609 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5610 /* Whether the location in the CONCAT should be handled like a MO_COPY
5611 as well. */
5612 #define VAL_EXPR_IS_COPIED(x) \
5613 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5614 /* Whether the location in the CONCAT should be handled like a
5615 MO_CLOBBER as well. */
5616 #define VAL_EXPR_IS_CLOBBERED(x) \
5617 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5619 /* All preserved VALUEs. */
5620 static vec<rtx> preserved_values;
5622 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5624 static void
5625 preserve_value (cselib_val *val)
5627 cselib_preserve_value (val);
5628 preserved_values.safe_push (val->val_rtx);
5631 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5632 any rtxes not suitable for CONST use not replaced by VALUEs
5633 are discovered. */
5635 static bool
5636 non_suitable_const (const_rtx x)
5638 subrtx_iterator::array_type array;
5639 FOR_EACH_SUBRTX (iter, array, x, ALL)
5641 const_rtx x = *iter;
5642 switch (GET_CODE (x))
5644 case REG:
5645 case DEBUG_EXPR:
5646 case PC:
5647 case SCRATCH:
5648 case ASM_INPUT:
5649 case ASM_OPERANDS:
5650 return true;
5651 case MEM:
5652 if (!MEM_READONLY_P (x))
5653 return true;
5654 break;
5655 default:
5656 break;
5659 return false;
5662 /* Add uses (register and memory references) LOC which will be tracked
5663 to VTI (bb)->mos. */
5665 static void
5666 add_uses (rtx loc, struct count_use_info *cui)
5668 machine_mode mode = VOIDmode;
5669 enum micro_operation_type type = use_type (loc, cui, &mode);
5671 if (type != MO_CLOBBER)
5673 basic_block bb = cui->bb;
5674 micro_operation mo;
5676 mo.type = type;
5677 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
5678 mo.insn = cui->insn;
5680 if (type == MO_VAL_LOC)
5682 rtx oloc = loc;
5683 rtx vloc = PAT_VAR_LOCATION_LOC (oloc);
5684 cselib_val *val;
5686 gcc_assert (cui->sets);
5688 if (MEM_P (vloc)
5689 && !REG_P (XEXP (vloc, 0))
5690 && !MEM_P (XEXP (vloc, 0)))
5692 rtx mloc = vloc;
5693 machine_mode address_mode = get_address_mode (mloc);
5694 cselib_val *val
5695 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5696 GET_MODE (mloc));
5698 if (val && !cselib_preserved_value_p (val))
5699 preserve_value (val);
5702 if (CONSTANT_P (vloc)
5703 && (GET_CODE (vloc) != CONST || non_suitable_const (vloc)))
5704 /* For constants don't look up any value. */;
5705 else if (!VAR_LOC_UNKNOWN_P (vloc) && !unsuitable_loc (vloc)
5706 && (val = find_use_val (vloc, GET_MODE (oloc), cui)))
5708 machine_mode mode2;
5709 enum micro_operation_type type2;
5710 rtx nloc = NULL;
5711 bool resolvable = REG_P (vloc) || MEM_P (vloc);
5713 if (resolvable)
5714 nloc = replace_expr_with_values (vloc);
5716 if (nloc)
5718 oloc = shallow_copy_rtx (oloc);
5719 PAT_VAR_LOCATION_LOC (oloc) = nloc;
5722 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc);
5724 type2 = use_type (vloc, 0, &mode2);
5726 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5727 || type2 == MO_CLOBBER);
5729 if (type2 == MO_CLOBBER
5730 && !cselib_preserved_value_p (val))
5732 VAL_NEEDS_RESOLUTION (oloc) = resolvable;
5733 preserve_value (val);
5736 else if (!VAR_LOC_UNKNOWN_P (vloc))
5738 oloc = shallow_copy_rtx (oloc);
5739 PAT_VAR_LOCATION_LOC (oloc) = gen_rtx_UNKNOWN_VAR_LOC ();
5742 mo.u.loc = oloc;
5744 else if (type == MO_VAL_USE)
5746 machine_mode mode2 = VOIDmode;
5747 enum micro_operation_type type2;
5748 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5749 rtx vloc, oloc = loc, nloc;
5751 gcc_assert (cui->sets);
5753 if (MEM_P (oloc)
5754 && !REG_P (XEXP (oloc, 0))
5755 && !MEM_P (XEXP (oloc, 0)))
5757 rtx mloc = oloc;
5758 machine_mode address_mode = get_address_mode (mloc);
5759 cselib_val *val
5760 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5761 GET_MODE (mloc));
5763 if (val && !cselib_preserved_value_p (val))
5764 preserve_value (val);
5767 type2 = use_type (loc, 0, &mode2);
5769 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5770 || type2 == MO_CLOBBER);
5772 if (type2 == MO_USE)
5773 vloc = var_lowpart (mode2, loc);
5774 else
5775 vloc = oloc;
5777 /* The loc of a MO_VAL_USE may have two forms:
5779 (concat val src): val is at src, a value-based
5780 representation.
5782 (concat (concat val use) src): same as above, with use as
5783 the MO_USE tracked value, if it differs from src.
5787 gcc_checking_assert (REG_P (loc) || MEM_P (loc));
5788 nloc = replace_expr_with_values (loc);
5789 if (!nloc)
5790 nloc = oloc;
5792 if (vloc != nloc)
5793 oloc = gen_rtx_CONCAT (mode2, val->val_rtx, vloc);
5794 else
5795 oloc = val->val_rtx;
5797 mo.u.loc = gen_rtx_CONCAT (mode, oloc, nloc);
5799 if (type2 == MO_USE)
5800 VAL_HOLDS_TRACK_EXPR (mo.u.loc) = 1;
5801 if (!cselib_preserved_value_p (val))
5803 VAL_NEEDS_RESOLUTION (mo.u.loc) = 1;
5804 preserve_value (val);
5807 else
5808 gcc_assert (type == MO_USE || type == MO_USE_NO_VAR);
5810 if (dump_file && (dump_flags & TDF_DETAILS))
5811 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
5812 VTI (bb)->mos.safe_push (mo);
5816 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5818 static void
5819 add_uses_1 (rtx *x, void *cui)
5821 subrtx_var_iterator::array_type array;
5822 FOR_EACH_SUBRTX_VAR (iter, array, *x, NONCONST)
5823 add_uses (*iter, (struct count_use_info *) cui);
5826 /* This is the value used during expansion of locations. We want it
5827 to be unbounded, so that variables expanded deep in a recursion
5828 nest are fully evaluated, so that their values are cached
5829 correctly. We avoid recursion cycles through other means, and we
5830 don't unshare RTL, so excess complexity is not a problem. */
5831 #define EXPR_DEPTH (INT_MAX)
5832 /* We use this to keep too-complex expressions from being emitted as
5833 location notes, and then to debug information. Users can trade
5834 compile time for ridiculously complex expressions, although they're
5835 seldom useful, and they may often have to be discarded as not
5836 representable anyway. */
5837 #define EXPR_USE_DEPTH (param_max_vartrack_expr_depth)
5839 /* Attempt to reverse the EXPR operation in the debug info and record
5840 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5841 no longer live we can express its value as VAL - 6. */
5843 static void
5844 reverse_op (rtx val, const_rtx expr, rtx_insn *insn)
5846 rtx src, arg, ret;
5847 cselib_val *v;
5848 struct elt_loc_list *l;
5849 enum rtx_code code;
5850 int count;
5852 if (GET_CODE (expr) != SET)
5853 return;
5855 if (!REG_P (SET_DEST (expr)) || GET_MODE (val) != GET_MODE (SET_DEST (expr)))
5856 return;
5858 src = SET_SRC (expr);
5859 switch (GET_CODE (src))
5861 case PLUS:
5862 case MINUS:
5863 case XOR:
5864 case NOT:
5865 case NEG:
5866 if (!REG_P (XEXP (src, 0)))
5867 return;
5868 break;
5869 case SIGN_EXTEND:
5870 case ZERO_EXTEND:
5871 if (!REG_P (XEXP (src, 0)) && !MEM_P (XEXP (src, 0)))
5872 return;
5873 break;
5874 default:
5875 return;
5878 if (!SCALAR_INT_MODE_P (GET_MODE (src)) || XEXP (src, 0) == cfa_base_rtx)
5879 return;
5881 v = cselib_lookup (XEXP (src, 0), GET_MODE (XEXP (src, 0)), 0, VOIDmode);
5882 if (!v || !cselib_preserved_value_p (v))
5883 return;
5885 /* Use canonical V to avoid creating multiple redundant expressions
5886 for different VALUES equivalent to V. */
5887 v = canonical_cselib_val (v);
5889 /* Adding a reverse op isn't useful if V already has an always valid
5890 location. Ignore ENTRY_VALUE, while it is always constant, we should
5891 prefer non-ENTRY_VALUE locations whenever possible. */
5892 for (l = v->locs, count = 0; l; l = l->next, count++)
5893 if (CONSTANT_P (l->loc)
5894 && (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
5895 return;
5896 /* Avoid creating too large locs lists. */
5897 else if (count == param_max_vartrack_reverse_op_size)
5898 return;
5900 switch (GET_CODE (src))
5902 case NOT:
5903 case NEG:
5904 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5905 return;
5906 ret = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (val), val);
5907 break;
5908 case SIGN_EXTEND:
5909 case ZERO_EXTEND:
5910 ret = gen_lowpart_SUBREG (GET_MODE (v->val_rtx), val);
5911 break;
5912 case XOR:
5913 code = XOR;
5914 goto binary;
5915 case PLUS:
5916 code = MINUS;
5917 goto binary;
5918 case MINUS:
5919 code = PLUS;
5920 goto binary;
5921 binary:
5922 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5923 return;
5924 arg = XEXP (src, 1);
5925 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5927 arg = cselib_expand_value_rtx (arg, scratch_regs, 5);
5928 if (arg == NULL_RTX)
5929 return;
5930 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5931 return;
5933 ret = simplify_gen_binary (code, GET_MODE (val), val, arg);
5934 break;
5935 default:
5936 gcc_unreachable ();
5939 cselib_add_permanent_equiv (v, ret, insn);
5942 /* Add stores (register and memory references) LOC which will be tracked
5943 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5944 CUIP->insn is instruction which the LOC is part of. */
5946 static void
5947 add_stores (rtx loc, const_rtx expr, void *cuip)
5949 machine_mode mode = VOIDmode, mode2;
5950 struct count_use_info *cui = (struct count_use_info *)cuip;
5951 basic_block bb = cui->bb;
5952 micro_operation mo;
5953 rtx oloc = loc, nloc, src = NULL;
5954 enum micro_operation_type type = use_type (loc, cui, &mode);
5955 bool track_p = false;
5956 cselib_val *v;
5957 bool resolve, preserve;
5959 if (type == MO_CLOBBER)
5960 return;
5962 mode2 = mode;
5964 if (REG_P (loc))
5966 gcc_assert (loc != cfa_base_rtx);
5967 if ((GET_CODE (expr) == CLOBBER && type != MO_VAL_SET)
5968 || !(track_p = use_type (loc, NULL, &mode2) == MO_USE)
5969 || GET_CODE (expr) == CLOBBER)
5971 mo.type = MO_CLOBBER;
5972 mo.u.loc = loc;
5973 if (GET_CODE (expr) == SET
5974 && (SET_DEST (expr) == loc
5975 || (GET_CODE (SET_DEST (expr)) == STRICT_LOW_PART
5976 && XEXP (SET_DEST (expr), 0) == loc))
5977 && !unsuitable_loc (SET_SRC (expr))
5978 && find_use_val (loc, mode, cui))
5980 gcc_checking_assert (type == MO_VAL_SET);
5981 mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
5984 else
5986 if (GET_CODE (expr) == SET
5987 && SET_DEST (expr) == loc
5988 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
5989 src = var_lowpart (mode2, SET_SRC (expr));
5990 loc = var_lowpart (mode2, loc);
5992 if (src == NULL)
5994 mo.type = MO_SET;
5995 mo.u.loc = loc;
5997 else
5999 rtx xexpr = gen_rtx_SET (loc, src);
6000 if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
6002 /* If this is an instruction copying (part of) a parameter
6003 passed by invisible reference to its register location,
6004 pretend it's a SET so that the initial memory location
6005 is discarded, as the parameter register can be reused
6006 for other purposes and we do not track locations based
6007 on generic registers. */
6008 if (MEM_P (src)
6009 && REG_EXPR (loc)
6010 && TREE_CODE (REG_EXPR (loc)) == PARM_DECL
6011 && DECL_MODE (REG_EXPR (loc)) != BLKmode
6012 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc)))
6013 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc)), 0)
6014 != arg_pointer_rtx)
6015 mo.type = MO_SET;
6016 else
6017 mo.type = MO_COPY;
6019 else
6020 mo.type = MO_SET;
6021 mo.u.loc = xexpr;
6024 mo.insn = cui->insn;
6026 else if (MEM_P (loc)
6027 && ((track_p = use_type (loc, NULL, &mode2) == MO_USE)
6028 || cui->sets))
6030 if (MEM_P (loc) && type == MO_VAL_SET
6031 && !REG_P (XEXP (loc, 0))
6032 && !MEM_P (XEXP (loc, 0)))
6034 rtx mloc = loc;
6035 machine_mode address_mode = get_address_mode (mloc);
6036 cselib_val *val = cselib_lookup (XEXP (mloc, 0),
6037 address_mode, 0,
6038 GET_MODE (mloc));
6040 if (val && !cselib_preserved_value_p (val))
6041 preserve_value (val);
6044 if (GET_CODE (expr) == CLOBBER || !track_p)
6046 mo.type = MO_CLOBBER;
6047 mo.u.loc = track_p ? var_lowpart (mode2, loc) : loc;
6049 else
6051 if (GET_CODE (expr) == SET
6052 && SET_DEST (expr) == loc
6053 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
6054 src = var_lowpart (mode2, SET_SRC (expr));
6055 loc = var_lowpart (mode2, loc);
6057 if (src == NULL)
6059 mo.type = MO_SET;
6060 mo.u.loc = loc;
6062 else
6064 rtx xexpr = gen_rtx_SET (loc, src);
6065 if (same_variable_part_p (SET_SRC (xexpr),
6066 MEM_EXPR (loc),
6067 int_mem_offset (loc)))
6068 mo.type = MO_COPY;
6069 else
6070 mo.type = MO_SET;
6071 mo.u.loc = xexpr;
6074 mo.insn = cui->insn;
6076 else
6077 return;
6079 if (type != MO_VAL_SET)
6080 goto log_and_return;
6082 v = find_use_val (oloc, mode, cui);
6084 if (!v)
6085 goto log_and_return;
6087 resolve = preserve = !cselib_preserved_value_p (v);
6089 /* We cannot track values for multiple-part variables, so we track only
6090 locations for tracked record parameters. */
6091 if (track_p
6092 && REG_P (loc)
6093 && REG_EXPR (loc)
6094 && tracked_record_parameter_p (REG_EXPR (loc)))
6096 /* Although we don't use the value here, it could be used later by the
6097 mere virtue of its existence as the operand of the reverse operation
6098 that gave rise to it (typically extension/truncation). Make sure it
6099 is preserved as required by vt_expand_var_loc_chain. */
6100 if (preserve)
6101 preserve_value (v);
6102 goto log_and_return;
6105 if (loc == stack_pointer_rtx
6106 && (maybe_ne (hard_frame_pointer_adjustment, -1)
6107 || (!frame_pointer_needed && !ACCUMULATE_OUTGOING_ARGS))
6108 && preserve)
6109 cselib_set_value_sp_based (v);
6111 /* Don't record MO_VAL_SET for VALUEs that can be described using
6112 cfa_base_rtx or cfa_base_rtx + CONST_INT, cselib already knows
6113 all the needed equivalences and they shouldn't change depending
6114 on which register holds that VALUE in some instruction. */
6115 if (!frame_pointer_needed
6116 && cfa_base_rtx
6117 && cselib_sp_derived_value_p (v)
6118 && loc == stack_pointer_rtx)
6120 if (preserve)
6121 preserve_value (v);
6122 return;
6125 nloc = replace_expr_with_values (oloc);
6126 if (nloc)
6127 oloc = nloc;
6129 if (GET_CODE (PATTERN (cui->insn)) == COND_EXEC)
6131 cselib_val *oval = cselib_lookup (oloc, GET_MODE (oloc), 0, VOIDmode);
6133 if (oval == v)
6134 return;
6135 gcc_assert (REG_P (oloc) || MEM_P (oloc));
6137 if (oval && !cselib_preserved_value_p (oval))
6139 micro_operation moa;
6141 preserve_value (oval);
6143 moa.type = MO_VAL_USE;
6144 moa.u.loc = gen_rtx_CONCAT (mode, oval->val_rtx, oloc);
6145 VAL_NEEDS_RESOLUTION (moa.u.loc) = 1;
6146 moa.insn = cui->insn;
6148 if (dump_file && (dump_flags & TDF_DETAILS))
6149 log_op_type (moa.u.loc, cui->bb, cui->insn,
6150 moa.type, dump_file);
6151 VTI (bb)->mos.safe_push (moa);
6154 resolve = false;
6156 else if (resolve && GET_CODE (mo.u.loc) == SET)
6158 if (REG_P (SET_SRC (expr)) || MEM_P (SET_SRC (expr)))
6159 nloc = replace_expr_with_values (SET_SRC (expr));
6160 else
6161 nloc = NULL_RTX;
6163 /* Avoid the mode mismatch between oexpr and expr. */
6164 if (!nloc && mode != mode2)
6166 nloc = SET_SRC (expr);
6167 gcc_assert (oloc == SET_DEST (expr));
6170 if (nloc && nloc != SET_SRC (mo.u.loc))
6171 oloc = gen_rtx_SET (oloc, nloc);
6172 else
6174 if (oloc == SET_DEST (mo.u.loc))
6175 /* No point in duplicating. */
6176 oloc = mo.u.loc;
6177 if (!REG_P (SET_SRC (mo.u.loc)))
6178 resolve = false;
6181 else if (!resolve)
6183 if (GET_CODE (mo.u.loc) == SET
6184 && oloc == SET_DEST (mo.u.loc))
6185 /* No point in duplicating. */
6186 oloc = mo.u.loc;
6188 else
6189 resolve = false;
6191 loc = gen_rtx_CONCAT (mode, v->val_rtx, oloc);
6193 if (mo.u.loc != oloc)
6194 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, mo.u.loc);
6196 /* The loc of a MO_VAL_SET may have various forms:
6198 (concat val dst): dst now holds val
6200 (concat val (set dst src)): dst now holds val, copied from src
6202 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6203 after replacing mems and non-top-level regs with values.
6205 (concat (concat val dstv) (set dst src)): dst now holds val,
6206 copied from src. dstv is a value-based representation of dst, if
6207 it differs from dst. If resolution is needed, src is a REG, and
6208 its mode is the same as that of val.
6210 (concat (concat val (set dstv srcv)) (set dst src)): src
6211 copied to dst, holding val. dstv and srcv are value-based
6212 representations of dst and src, respectively.
6216 if (GET_CODE (PATTERN (cui->insn)) != COND_EXEC)
6217 reverse_op (v->val_rtx, expr, cui->insn);
6219 mo.u.loc = loc;
6221 if (track_p)
6222 VAL_HOLDS_TRACK_EXPR (loc) = 1;
6223 if (preserve)
6225 VAL_NEEDS_RESOLUTION (loc) = resolve;
6226 preserve_value (v);
6228 if (mo.type == MO_CLOBBER)
6229 VAL_EXPR_IS_CLOBBERED (loc) = 1;
6230 if (mo.type == MO_COPY)
6231 VAL_EXPR_IS_COPIED (loc) = 1;
6233 mo.type = MO_VAL_SET;
6235 log_and_return:
6236 if (dump_file && (dump_flags & TDF_DETAILS))
6237 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
6238 VTI (bb)->mos.safe_push (mo);
6241 /* Arguments to the call. */
6242 static rtx call_arguments;
6244 /* Compute call_arguments. */
6246 static void
6247 prepare_call_arguments (basic_block bb, rtx_insn *insn)
6249 rtx link, x, call;
6250 rtx prev, cur, next;
6251 rtx this_arg = NULL_RTX;
6252 tree type = NULL_TREE, t, fndecl = NULL_TREE;
6253 tree obj_type_ref = NULL_TREE;
6254 CUMULATIVE_ARGS args_so_far_v;
6255 cumulative_args_t args_so_far;
6257 memset (&args_so_far_v, 0, sizeof (args_so_far_v));
6258 args_so_far = pack_cumulative_args (&args_so_far_v);
6259 call = get_call_rtx_from (insn);
6260 if (call)
6262 if (GET_CODE (XEXP (XEXP (call, 0), 0)) == SYMBOL_REF)
6264 rtx symbol = XEXP (XEXP (call, 0), 0);
6265 if (SYMBOL_REF_DECL (symbol))
6266 fndecl = SYMBOL_REF_DECL (symbol);
6268 if (fndecl == NULL_TREE)
6269 fndecl = MEM_EXPR (XEXP (call, 0));
6270 if (fndecl
6271 && TREE_CODE (TREE_TYPE (fndecl)) != FUNCTION_TYPE
6272 && TREE_CODE (TREE_TYPE (fndecl)) != METHOD_TYPE)
6273 fndecl = NULL_TREE;
6274 if (fndecl && TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6275 type = TREE_TYPE (fndecl);
6276 if (fndecl && TREE_CODE (fndecl) != FUNCTION_DECL)
6278 if (INDIRECT_REF_P (fndecl)
6279 && TREE_CODE (TREE_OPERAND (fndecl, 0)) == OBJ_TYPE_REF)
6280 obj_type_ref = TREE_OPERAND (fndecl, 0);
6281 fndecl = NULL_TREE;
6283 if (type)
6285 for (t = TYPE_ARG_TYPES (type); t && t != void_list_node;
6286 t = TREE_CHAIN (t))
6287 if (TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
6288 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t))))
6289 break;
6290 if ((t == NULL || t == void_list_node) && obj_type_ref == NULL_TREE)
6291 type = NULL;
6292 else
6294 int nargs ATTRIBUTE_UNUSED = list_length (TYPE_ARG_TYPES (type));
6295 link = CALL_INSN_FUNCTION_USAGE (insn);
6296 #ifndef PCC_STATIC_STRUCT_RETURN
6297 if (aggregate_value_p (TREE_TYPE (type), type)
6298 && targetm.calls.struct_value_rtx (type, 0) == 0)
6300 tree struct_addr = build_pointer_type (TREE_TYPE (type));
6301 function_arg_info arg (struct_addr, /*named=*/true);
6302 rtx reg;
6303 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6304 nargs + 1);
6305 reg = targetm.calls.function_arg (args_so_far, arg);
6306 targetm.calls.function_arg_advance (args_so_far, arg);
6307 if (reg == NULL_RTX)
6309 for (; link; link = XEXP (link, 1))
6310 if (GET_CODE (XEXP (link, 0)) == USE
6311 && MEM_P (XEXP (XEXP (link, 0), 0)))
6313 link = XEXP (link, 1);
6314 break;
6318 else
6319 #endif
6320 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6321 nargs);
6322 if (obj_type_ref && TYPE_ARG_TYPES (type) != void_list_node)
6324 t = TYPE_ARG_TYPES (type);
6325 function_arg_info arg (TREE_VALUE (t), /*named=*/true);
6326 this_arg = targetm.calls.function_arg (args_so_far, arg);
6327 if (this_arg && !REG_P (this_arg))
6328 this_arg = NULL_RTX;
6329 else if (this_arg == NULL_RTX)
6331 for (; link; link = XEXP (link, 1))
6332 if (GET_CODE (XEXP (link, 0)) == USE
6333 && MEM_P (XEXP (XEXP (link, 0), 0)))
6335 this_arg = XEXP (XEXP (link, 0), 0);
6336 break;
6343 t = type ? TYPE_ARG_TYPES (type) : NULL_TREE;
6345 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6346 if (GET_CODE (XEXP (link, 0)) == USE)
6348 rtx item = NULL_RTX;
6349 x = XEXP (XEXP (link, 0), 0);
6350 if (GET_MODE (link) == VOIDmode
6351 || GET_MODE (link) == BLKmode
6352 || (GET_MODE (link) != GET_MODE (x)
6353 && ((GET_MODE_CLASS (GET_MODE (link)) != MODE_INT
6354 && GET_MODE_CLASS (GET_MODE (link)) != MODE_PARTIAL_INT)
6355 || (GET_MODE_CLASS (GET_MODE (x)) != MODE_INT
6356 && GET_MODE_CLASS (GET_MODE (x)) != MODE_PARTIAL_INT))))
6357 /* Can't do anything for these, if the original type mode
6358 isn't known or can't be converted. */;
6359 else if (REG_P (x))
6361 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6362 scalar_int_mode mode;
6363 if (val && cselib_preserved_value_p (val))
6364 item = val->val_rtx;
6365 else if (is_a <scalar_int_mode> (GET_MODE (x), &mode))
6367 opt_scalar_int_mode mode_iter;
6368 FOR_EACH_WIDER_MODE (mode_iter, mode)
6370 mode = mode_iter.require ();
6371 if (GET_MODE_BITSIZE (mode) > BITS_PER_WORD)
6372 break;
6374 rtx reg = simplify_subreg (mode, x, GET_MODE (x), 0);
6375 if (reg == NULL_RTX || !REG_P (reg))
6376 continue;
6377 val = cselib_lookup (reg, mode, 0, VOIDmode);
6378 if (val && cselib_preserved_value_p (val))
6380 item = val->val_rtx;
6381 break;
6386 else if (MEM_P (x))
6388 rtx mem = x;
6389 cselib_val *val;
6391 if (!frame_pointer_needed)
6393 class adjust_mem_data amd;
6394 amd.mem_mode = VOIDmode;
6395 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
6396 amd.store = true;
6397 mem = simplify_replace_fn_rtx (mem, NULL_RTX, adjust_mems,
6398 &amd);
6399 gcc_assert (amd.side_effects.is_empty ());
6401 val = cselib_lookup (mem, GET_MODE (mem), 0, VOIDmode);
6402 if (val && cselib_preserved_value_p (val))
6403 item = val->val_rtx;
6404 else if (GET_MODE_CLASS (GET_MODE (mem)) != MODE_INT
6405 && GET_MODE_CLASS (GET_MODE (mem)) != MODE_PARTIAL_INT)
6407 /* For non-integer stack argument see also if they weren't
6408 initialized by integers. */
6409 scalar_int_mode imode;
6410 if (int_mode_for_mode (GET_MODE (mem)).exists (&imode)
6411 && imode != GET_MODE (mem))
6413 val = cselib_lookup (adjust_address_nv (mem, imode, 0),
6414 imode, 0, VOIDmode);
6415 if (val && cselib_preserved_value_p (val))
6416 item = lowpart_subreg (GET_MODE (x), val->val_rtx,
6417 imode);
6421 if (item)
6423 rtx x2 = x;
6424 if (GET_MODE (item) != GET_MODE (link))
6425 item = lowpart_subreg (GET_MODE (link), item, GET_MODE (item));
6426 if (GET_MODE (x2) != GET_MODE (link))
6427 x2 = lowpart_subreg (GET_MODE (link), x2, GET_MODE (x2));
6428 item = gen_rtx_CONCAT (GET_MODE (link), x2, item);
6429 call_arguments
6430 = gen_rtx_EXPR_LIST (VOIDmode, item, call_arguments);
6432 if (t && t != void_list_node)
6434 rtx reg;
6435 function_arg_info arg (TREE_VALUE (t), /*named=*/true);
6436 apply_pass_by_reference_rules (&args_so_far_v, arg);
6437 reg = targetm.calls.function_arg (args_so_far, arg);
6438 if (TREE_CODE (arg.type) == REFERENCE_TYPE
6439 && INTEGRAL_TYPE_P (TREE_TYPE (arg.type))
6440 && reg
6441 && REG_P (reg)
6442 && GET_MODE (reg) == arg.mode
6443 && (GET_MODE_CLASS (arg.mode) == MODE_INT
6444 || GET_MODE_CLASS (arg.mode) == MODE_PARTIAL_INT)
6445 && REG_P (x)
6446 && REGNO (x) == REGNO (reg)
6447 && GET_MODE (x) == arg.mode
6448 && item)
6450 machine_mode indmode
6451 = TYPE_MODE (TREE_TYPE (arg.type));
6452 rtx mem = gen_rtx_MEM (indmode, x);
6453 cselib_val *val = cselib_lookup (mem, indmode, 0, VOIDmode);
6454 if (val && cselib_preserved_value_p (val))
6456 item = gen_rtx_CONCAT (indmode, mem, val->val_rtx);
6457 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6458 call_arguments);
6460 else
6462 struct elt_loc_list *l;
6463 tree initial;
6465 /* Try harder, when passing address of a constant
6466 pool integer it can be easily read back. */
6467 item = XEXP (item, 1);
6468 if (GET_CODE (item) == SUBREG)
6469 item = SUBREG_REG (item);
6470 gcc_assert (GET_CODE (item) == VALUE);
6471 val = CSELIB_VAL_PTR (item);
6472 for (l = val->locs; l; l = l->next)
6473 if (GET_CODE (l->loc) == SYMBOL_REF
6474 && TREE_CONSTANT_POOL_ADDRESS_P (l->loc)
6475 && SYMBOL_REF_DECL (l->loc)
6476 && DECL_INITIAL (SYMBOL_REF_DECL (l->loc)))
6478 initial = DECL_INITIAL (SYMBOL_REF_DECL (l->loc));
6479 if (tree_fits_shwi_p (initial))
6481 item = GEN_INT (tree_to_shwi (initial));
6482 item = gen_rtx_CONCAT (indmode, mem, item);
6483 call_arguments
6484 = gen_rtx_EXPR_LIST (VOIDmode, item,
6485 call_arguments);
6487 break;
6491 targetm.calls.function_arg_advance (args_so_far, arg);
6492 t = TREE_CHAIN (t);
6496 /* Add debug arguments. */
6497 if (fndecl
6498 && TREE_CODE (fndecl) == FUNCTION_DECL
6499 && DECL_HAS_DEBUG_ARGS_P (fndecl))
6501 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (fndecl);
6502 if (debug_args)
6504 unsigned int ix;
6505 tree param;
6506 for (ix = 0; vec_safe_iterate (*debug_args, ix, &param); ix += 2)
6508 rtx item;
6509 tree dtemp = (**debug_args)[ix + 1];
6510 machine_mode mode = DECL_MODE (dtemp);
6511 item = gen_rtx_DEBUG_PARAMETER_REF (mode, param);
6512 item = gen_rtx_CONCAT (mode, item, DECL_RTL_KNOWN_SET (dtemp));
6513 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6514 call_arguments);
6519 /* Reverse call_arguments chain. */
6520 prev = NULL_RTX;
6521 for (cur = call_arguments; cur; cur = next)
6523 next = XEXP (cur, 1);
6524 XEXP (cur, 1) = prev;
6525 prev = cur;
6527 call_arguments = prev;
6529 x = get_call_rtx_from (insn);
6530 if (x)
6532 x = XEXP (XEXP (x, 0), 0);
6533 if (GET_CODE (x) == SYMBOL_REF)
6534 /* Don't record anything. */;
6535 else if (CONSTANT_P (x))
6537 x = gen_rtx_CONCAT (GET_MODE (x) == VOIDmode ? Pmode : GET_MODE (x),
6538 pc_rtx, x);
6539 call_arguments
6540 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6542 else
6544 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6545 if (val && cselib_preserved_value_p (val))
6547 x = gen_rtx_CONCAT (GET_MODE (x), pc_rtx, val->val_rtx);
6548 call_arguments
6549 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6553 if (this_arg)
6555 machine_mode mode
6556 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref)));
6557 rtx clobbered = gen_rtx_MEM (mode, this_arg);
6558 HOST_WIDE_INT token
6559 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref));
6560 if (token)
6561 clobbered = plus_constant (mode, clobbered,
6562 token * GET_MODE_SIZE (mode));
6563 clobbered = gen_rtx_MEM (mode, clobbered);
6564 x = gen_rtx_CONCAT (mode, gen_rtx_CLOBBER (VOIDmode, pc_rtx), clobbered);
6565 call_arguments
6566 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6570 /* Callback for cselib_record_sets_hook, that records as micro
6571 operations uses and stores in an insn after cselib_record_sets has
6572 analyzed the sets in an insn, but before it modifies the stored
6573 values in the internal tables, unless cselib_record_sets doesn't
6574 call it directly (perhaps because we're not doing cselib in the
6575 first place, in which case sets and n_sets will be 0). */
6577 static void
6578 add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
6580 basic_block bb = BLOCK_FOR_INSN (insn);
6581 int n1, n2;
6582 struct count_use_info cui;
6583 micro_operation *mos;
6585 cselib_hook_called = true;
6587 cui.insn = insn;
6588 cui.bb = bb;
6589 cui.sets = sets;
6590 cui.n_sets = n_sets;
6592 n1 = VTI (bb)->mos.length ();
6593 cui.store_p = false;
6594 note_uses (&PATTERN (insn), add_uses_1, &cui);
6595 n2 = VTI (bb)->mos.length () - 1;
6596 mos = VTI (bb)->mos.address ();
6598 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6599 MO_VAL_LOC last. */
6600 while (n1 < n2)
6602 while (n1 < n2 && mos[n1].type == MO_USE)
6603 n1++;
6604 while (n1 < n2 && mos[n2].type != MO_USE)
6605 n2--;
6606 if (n1 < n2)
6607 std::swap (mos[n1], mos[n2]);
6610 n2 = VTI (bb)->mos.length () - 1;
6611 while (n1 < n2)
6613 while (n1 < n2 && mos[n1].type != MO_VAL_LOC)
6614 n1++;
6615 while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
6616 n2--;
6617 if (n1 < n2)
6618 std::swap (mos[n1], mos[n2]);
6621 if (CALL_P (insn))
6623 micro_operation mo;
6625 mo.type = MO_CALL;
6626 mo.insn = insn;
6627 mo.u.loc = call_arguments;
6628 call_arguments = NULL_RTX;
6630 if (dump_file && (dump_flags & TDF_DETAILS))
6631 log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
6632 VTI (bb)->mos.safe_push (mo);
6635 n1 = VTI (bb)->mos.length ();
6636 /* This will record NEXT_INSN (insn), such that we can
6637 insert notes before it without worrying about any
6638 notes that MO_USEs might emit after the insn. */
6639 cui.store_p = true;
6640 note_stores (insn, add_stores, &cui);
6641 n2 = VTI (bb)->mos.length () - 1;
6642 mos = VTI (bb)->mos.address ();
6644 /* Order the MO_VAL_USEs first (note_stores does nothing
6645 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6646 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6647 while (n1 < n2)
6649 while (n1 < n2 && mos[n1].type == MO_VAL_USE)
6650 n1++;
6651 while (n1 < n2 && mos[n2].type != MO_VAL_USE)
6652 n2--;
6653 if (n1 < n2)
6654 std::swap (mos[n1], mos[n2]);
6657 n2 = VTI (bb)->mos.length () - 1;
6658 while (n1 < n2)
6660 while (n1 < n2 && mos[n1].type == MO_CLOBBER)
6661 n1++;
6662 while (n1 < n2 && mos[n2].type != MO_CLOBBER)
6663 n2--;
6664 if (n1 < n2)
6665 std::swap (mos[n1], mos[n2]);
6669 static enum var_init_status
6670 find_src_status (dataflow_set *in, rtx src)
6672 tree decl = NULL_TREE;
6673 enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED;
6675 if (! flag_var_tracking_uninit)
6676 status = VAR_INIT_STATUS_INITIALIZED;
6678 if (src && REG_P (src))
6679 decl = var_debug_decl (REG_EXPR (src));
6680 else if (src && MEM_P (src))
6681 decl = var_debug_decl (MEM_EXPR (src));
6683 if (src && decl)
6684 status = get_init_value (in, src, dv_from_decl (decl));
6686 return status;
6689 /* SRC is the source of an assignment. Use SET to try to find what
6690 was ultimately assigned to SRC. Return that value if known,
6691 otherwise return SRC itself. */
6693 static rtx
6694 find_src_set_src (dataflow_set *set, rtx src)
6696 tree decl = NULL_TREE; /* The variable being copied around. */
6697 rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */
6698 variable *var;
6699 location_chain *nextp;
6700 int i;
6701 bool found;
6703 if (src && REG_P (src))
6704 decl = var_debug_decl (REG_EXPR (src));
6705 else if (src && MEM_P (src))
6706 decl = var_debug_decl (MEM_EXPR (src));
6708 if (src && decl)
6710 decl_or_value dv = dv_from_decl (decl);
6712 var = shared_hash_find (set->vars, dv);
6713 if (var)
6715 found = false;
6716 for (i = 0; i < var->n_var_parts && !found; i++)
6717 for (nextp = var->var_part[i].loc_chain; nextp && !found;
6718 nextp = nextp->next)
6719 if (rtx_equal_p (nextp->loc, src))
6721 set_src = nextp->set_src;
6722 found = true;
6728 return set_src;
6731 /* Compute the changes of variable locations in the basic block BB. */
6733 static bool
6734 compute_bb_dataflow (basic_block bb)
6736 unsigned int i;
6737 micro_operation *mo;
6738 bool changed;
6739 dataflow_set old_out;
6740 dataflow_set *in = &VTI (bb)->in;
6741 dataflow_set *out = &VTI (bb)->out;
6743 dataflow_set_init (&old_out);
6744 dataflow_set_copy (&old_out, out);
6745 dataflow_set_copy (out, in);
6747 if (MAY_HAVE_DEBUG_BIND_INSNS)
6748 local_get_addr_cache = new hash_map<rtx, rtx>;
6750 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
6752 rtx_insn *insn = mo->insn;
6754 switch (mo->type)
6756 case MO_CALL:
6757 dataflow_set_clear_at_call (out, insn);
6758 break;
6760 case MO_USE:
6762 rtx loc = mo->u.loc;
6764 if (REG_P (loc))
6765 var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6766 else if (MEM_P (loc))
6767 var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6769 break;
6771 case MO_VAL_LOC:
6773 rtx loc = mo->u.loc;
6774 rtx val, vloc;
6775 tree var;
6777 if (GET_CODE (loc) == CONCAT)
6779 val = XEXP (loc, 0);
6780 vloc = XEXP (loc, 1);
6782 else
6784 val = NULL_RTX;
6785 vloc = loc;
6788 var = PAT_VAR_LOCATION_DECL (vloc);
6790 clobber_variable_part (out, NULL_RTX,
6791 dv_from_decl (var), 0, NULL_RTX);
6792 if (val)
6794 if (VAL_NEEDS_RESOLUTION (loc))
6795 val_resolve (out, val, PAT_VAR_LOCATION_LOC (vloc), insn);
6796 set_variable_part (out, val, dv_from_decl (var), 0,
6797 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6798 INSERT);
6800 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
6801 set_variable_part (out, PAT_VAR_LOCATION_LOC (vloc),
6802 dv_from_decl (var), 0,
6803 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6804 INSERT);
6806 break;
6808 case MO_VAL_USE:
6810 rtx loc = mo->u.loc;
6811 rtx val, vloc, uloc;
6813 vloc = uloc = XEXP (loc, 1);
6814 val = XEXP (loc, 0);
6816 if (GET_CODE (val) == CONCAT)
6818 uloc = XEXP (val, 1);
6819 val = XEXP (val, 0);
6822 if (VAL_NEEDS_RESOLUTION (loc))
6823 val_resolve (out, val, vloc, insn);
6824 else
6825 val_store (out, val, uloc, insn, false);
6827 if (VAL_HOLDS_TRACK_EXPR (loc))
6829 if (GET_CODE (uloc) == REG)
6830 var_reg_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6831 NULL);
6832 else if (GET_CODE (uloc) == MEM)
6833 var_mem_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6834 NULL);
6837 break;
6839 case MO_VAL_SET:
6841 rtx loc = mo->u.loc;
6842 rtx val, vloc, uloc;
6843 rtx dstv, srcv;
6845 vloc = loc;
6846 uloc = XEXP (vloc, 1);
6847 val = XEXP (vloc, 0);
6848 vloc = uloc;
6850 if (GET_CODE (uloc) == SET)
6852 dstv = SET_DEST (uloc);
6853 srcv = SET_SRC (uloc);
6855 else
6857 dstv = uloc;
6858 srcv = NULL;
6861 if (GET_CODE (val) == CONCAT)
6863 dstv = vloc = XEXP (val, 1);
6864 val = XEXP (val, 0);
6867 if (GET_CODE (vloc) == SET)
6869 srcv = SET_SRC (vloc);
6871 gcc_assert (val != srcv);
6872 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
6874 dstv = vloc = SET_DEST (vloc);
6876 if (VAL_NEEDS_RESOLUTION (loc))
6877 val_resolve (out, val, srcv, insn);
6879 else if (VAL_NEEDS_RESOLUTION (loc))
6881 gcc_assert (GET_CODE (uloc) == SET
6882 && GET_CODE (SET_SRC (uloc)) == REG);
6883 val_resolve (out, val, SET_SRC (uloc), insn);
6886 if (VAL_HOLDS_TRACK_EXPR (loc))
6888 if (VAL_EXPR_IS_CLOBBERED (loc))
6890 if (REG_P (uloc))
6891 var_reg_delete (out, uloc, true);
6892 else if (MEM_P (uloc))
6894 gcc_assert (MEM_P (dstv));
6895 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
6896 var_mem_delete (out, dstv, true);
6899 else
6901 bool copied_p = VAL_EXPR_IS_COPIED (loc);
6902 rtx src = NULL, dst = uloc;
6903 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
6905 if (GET_CODE (uloc) == SET)
6907 src = SET_SRC (uloc);
6908 dst = SET_DEST (uloc);
6911 if (copied_p)
6913 if (flag_var_tracking_uninit)
6915 status = find_src_status (in, src);
6917 if (status == VAR_INIT_STATUS_UNKNOWN)
6918 status = find_src_status (out, src);
6921 src = find_src_set_src (in, src);
6924 if (REG_P (dst))
6925 var_reg_delete_and_set (out, dst, !copied_p,
6926 status, srcv);
6927 else if (MEM_P (dst))
6929 gcc_assert (MEM_P (dstv));
6930 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
6931 var_mem_delete_and_set (out, dstv, !copied_p,
6932 status, srcv);
6936 else if (REG_P (uloc))
6937 var_regno_delete (out, REGNO (uloc));
6938 else if (MEM_P (uloc))
6940 gcc_checking_assert (GET_CODE (vloc) == MEM);
6941 gcc_checking_assert (dstv == vloc);
6942 if (dstv != vloc)
6943 clobber_overlapping_mems (out, vloc);
6946 val_store (out, val, dstv, insn, true);
6948 break;
6950 case MO_SET:
6952 rtx loc = mo->u.loc;
6953 rtx set_src = NULL;
6955 if (GET_CODE (loc) == SET)
6957 set_src = SET_SRC (loc);
6958 loc = SET_DEST (loc);
6961 if (REG_P (loc))
6962 var_reg_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6963 set_src);
6964 else if (MEM_P (loc))
6965 var_mem_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6966 set_src);
6968 break;
6970 case MO_COPY:
6972 rtx loc = mo->u.loc;
6973 enum var_init_status src_status;
6974 rtx set_src = NULL;
6976 if (GET_CODE (loc) == SET)
6978 set_src = SET_SRC (loc);
6979 loc = SET_DEST (loc);
6982 if (! flag_var_tracking_uninit)
6983 src_status = VAR_INIT_STATUS_INITIALIZED;
6984 else
6986 src_status = find_src_status (in, set_src);
6988 if (src_status == VAR_INIT_STATUS_UNKNOWN)
6989 src_status = find_src_status (out, set_src);
6992 set_src = find_src_set_src (in, set_src);
6994 if (REG_P (loc))
6995 var_reg_delete_and_set (out, loc, false, src_status, set_src);
6996 else if (MEM_P (loc))
6997 var_mem_delete_and_set (out, loc, false, src_status, set_src);
6999 break;
7001 case MO_USE_NO_VAR:
7003 rtx loc = mo->u.loc;
7005 if (REG_P (loc))
7006 var_reg_delete (out, loc, false);
7007 else if (MEM_P (loc))
7008 var_mem_delete (out, loc, false);
7010 break;
7012 case MO_CLOBBER:
7014 rtx loc = mo->u.loc;
7016 if (REG_P (loc))
7017 var_reg_delete (out, loc, true);
7018 else if (MEM_P (loc))
7019 var_mem_delete (out, loc, true);
7021 break;
7023 case MO_ADJUST:
7024 out->stack_adjust += mo->u.adjust;
7025 break;
7029 if (MAY_HAVE_DEBUG_BIND_INSNS)
7031 delete local_get_addr_cache;
7032 local_get_addr_cache = NULL;
7034 dataflow_set_equiv_regs (out);
7035 shared_hash_htab (out->vars)
7036 ->traverse <dataflow_set *, canonicalize_values_mark> (out);
7037 shared_hash_htab (out->vars)
7038 ->traverse <dataflow_set *, canonicalize_values_star> (out);
7039 if (flag_checking)
7040 shared_hash_htab (out->vars)
7041 ->traverse <dataflow_set *, canonicalize_loc_order_check> (out);
7043 changed = dataflow_set_different (&old_out, out);
7044 dataflow_set_destroy (&old_out);
7045 return changed;
7048 /* Find the locations of variables in the whole function. */
7050 static bool
7051 vt_find_locations (void)
7053 bb_heap_t *worklist = new bb_heap_t (LONG_MIN);
7054 bb_heap_t *pending = new bb_heap_t (LONG_MIN);
7055 sbitmap in_worklist, in_pending;
7056 basic_block bb;
7057 edge e;
7058 int *bb_order;
7059 int *rc_order;
7060 int i;
7061 int htabsz = 0;
7062 int htabmax = param_max_vartrack_size;
7063 bool success = true;
7064 unsigned int n_blocks_processed = 0;
7066 timevar_push (TV_VAR_TRACKING_DATAFLOW);
7067 /* Compute reverse completion order of depth first search of the CFG
7068 so that the data-flow runs faster. */
7069 rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS);
7070 bb_order = XNEWVEC (int, last_basic_block_for_fn (cfun));
7071 auto_bitmap exit_bbs;
7072 bitmap_set_bit (exit_bbs, EXIT_BLOCK);
7073 auto_vec<std::pair<int, int> > toplevel_scc_extents;
7074 int n = rev_post_order_and_mark_dfs_back_seme
7075 (cfun, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)), exit_bbs, true,
7076 rc_order, &toplevel_scc_extents);
7077 for (i = 0; i < n; i++)
7078 bb_order[rc_order[i]] = i;
7080 in_worklist = sbitmap_alloc (last_basic_block_for_fn (cfun));
7081 in_pending = sbitmap_alloc (last_basic_block_for_fn (cfun));
7082 bitmap_clear (in_worklist);
7083 bitmap_clear (in_pending);
7085 /* We're performing the dataflow iteration independently over the
7086 toplevel SCCs plus leading non-cyclic entry blocks and separately
7087 over the tail. That ensures best memory locality and the least
7088 number of visited blocks. */
7089 unsigned extent = 0;
7090 int curr_start = -1;
7091 int curr_end = -1;
7094 curr_start = curr_end + 1;
7095 if (toplevel_scc_extents.length () <= extent)
7096 curr_end = n - 1;
7097 else
7098 curr_end = toplevel_scc_extents[extent++].second;
7100 for (int i = curr_start; i <= curr_end; ++i)
7102 pending->insert (i, BASIC_BLOCK_FOR_FN (cfun, rc_order[i]));
7103 bitmap_set_bit (in_pending, rc_order[i]);
7106 while (success && !pending->empty ())
7108 std::swap (worklist, pending);
7109 std::swap (in_worklist, in_pending);
7111 while (!worklist->empty ())
7113 bool changed;
7114 edge_iterator ei;
7115 int oldinsz, oldoutsz;
7117 bb = worklist->extract_min ();
7118 bitmap_clear_bit (in_worklist, bb->index);
7120 if (VTI (bb)->in.vars)
7122 htabsz -= (shared_hash_htab (VTI (bb)->in.vars)->size ()
7123 + shared_hash_htab (VTI (bb)->out.vars)->size ());
7124 oldinsz = shared_hash_htab (VTI (bb)->in.vars)->elements ();
7125 oldoutsz = shared_hash_htab (VTI (bb)->out.vars)->elements ();
7127 else
7128 oldinsz = oldoutsz = 0;
7130 if (MAY_HAVE_DEBUG_BIND_INSNS)
7132 dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
7133 bool first = true, adjust = false;
7135 /* Calculate the IN set as the intersection of
7136 predecessor OUT sets. */
7138 dataflow_set_clear (in);
7139 dst_can_be_shared = true;
7141 FOR_EACH_EDGE (e, ei, bb->preds)
7142 if (!VTI (e->src)->flooded)
7143 gcc_assert (bb_order[bb->index]
7144 <= bb_order[e->src->index]);
7145 else if (first)
7147 dataflow_set_copy (in, &VTI (e->src)->out);
7148 first_out = &VTI (e->src)->out;
7149 first = false;
7151 else
7153 dataflow_set_merge (in, &VTI (e->src)->out);
7154 adjust = true;
7157 if (adjust)
7159 dataflow_post_merge_adjust (in, &VTI (bb)->permp);
7161 if (flag_checking)
7162 /* Merge and merge_adjust should keep entries in
7163 canonical order. */
7164 shared_hash_htab (in->vars)
7165 ->traverse <dataflow_set *,
7166 canonicalize_loc_order_check> (in);
7168 if (dst_can_be_shared)
7170 shared_hash_destroy (in->vars);
7171 in->vars = shared_hash_copy (first_out->vars);
7175 VTI (bb)->flooded = true;
7177 else
7179 /* Calculate the IN set as union of predecessor OUT sets. */
7180 dataflow_set_clear (&VTI (bb)->in);
7181 FOR_EACH_EDGE (e, ei, bb->preds)
7182 dataflow_set_union (&VTI (bb)->in, &VTI (e->src)->out);
7185 changed = compute_bb_dataflow (bb);
7186 n_blocks_processed++;
7187 htabsz += (shared_hash_htab (VTI (bb)->in.vars)->size ()
7188 + shared_hash_htab (VTI (bb)->out.vars)->size ());
7190 if (htabmax && htabsz > htabmax)
7192 if (MAY_HAVE_DEBUG_BIND_INSNS)
7193 inform (DECL_SOURCE_LOCATION (cfun->decl),
7194 "variable tracking size limit exceeded with "
7195 "%<-fvar-tracking-assignments%>, retrying without");
7196 else
7197 inform (DECL_SOURCE_LOCATION (cfun->decl),
7198 "variable tracking size limit exceeded");
7199 success = false;
7200 break;
7203 if (changed)
7205 FOR_EACH_EDGE (e, ei, bb->succs)
7207 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
7208 continue;
7210 /* Iterate to an earlier block in RPO in the next
7211 round, iterate to the same block immediately. */
7212 if (bb_order[e->dest->index] < bb_order[bb->index])
7214 gcc_assert (bb_order[e->dest->index] >= curr_start);
7215 if (!bitmap_bit_p (in_pending, e->dest->index))
7217 /* Send E->DEST to next round. */
7218 bitmap_set_bit (in_pending, e->dest->index);
7219 pending->insert (bb_order[e->dest->index],
7220 e->dest);
7223 else if (bb_order[e->dest->index] <= curr_end
7224 && !bitmap_bit_p (in_worklist, e->dest->index))
7226 /* Add E->DEST to current round or delay
7227 processing if it is in the next SCC. */
7228 bitmap_set_bit (in_worklist, e->dest->index);
7229 worklist->insert (bb_order[e->dest->index],
7230 e->dest);
7235 if (dump_file)
7236 fprintf (dump_file,
7237 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, "
7238 "tsz %i\n", bb->index,
7239 (int)shared_hash_htab (VTI (bb)->in.vars)->size (),
7240 oldinsz,
7241 (int)shared_hash_htab (VTI (bb)->out.vars)->size (),
7242 oldoutsz,
7243 (int)worklist->nodes (), (int)pending->nodes (),
7244 htabsz);
7246 if (dump_file && (dump_flags & TDF_DETAILS))
7248 fprintf (dump_file, "BB %i IN:\n", bb->index);
7249 dump_dataflow_set (&VTI (bb)->in);
7250 fprintf (dump_file, "BB %i OUT:\n", bb->index);
7251 dump_dataflow_set (&VTI (bb)->out);
7256 while (curr_end != n - 1);
7258 statistics_counter_event (cfun, "compute_bb_dataflow times",
7259 n_blocks_processed);
7261 if (success && MAY_HAVE_DEBUG_BIND_INSNS)
7262 FOR_EACH_BB_FN (bb, cfun)
7263 gcc_assert (VTI (bb)->flooded);
7265 free (rc_order);
7266 free (bb_order);
7267 delete worklist;
7268 delete pending;
7269 sbitmap_free (in_worklist);
7270 sbitmap_free (in_pending);
7272 timevar_pop (TV_VAR_TRACKING_DATAFLOW);
7273 return success;
7276 /* Print the content of the LIST to dump file. */
7278 static void
7279 dump_attrs_list (attrs *list)
7281 for (; list; list = list->next)
7283 if (dv_is_decl_p (list->dv))
7284 print_mem_expr (dump_file, dv_as_decl (list->dv));
7285 else
7286 print_rtl_single (dump_file, dv_as_value (list->dv));
7287 fprintf (dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset);
7289 fprintf (dump_file, "\n");
7292 /* Print the information about variable *SLOT to dump file. */
7295 dump_var_tracking_slot (variable **slot, void *data ATTRIBUTE_UNUSED)
7297 variable *var = *slot;
7299 dump_var (var);
7301 /* Continue traversing the hash table. */
7302 return 1;
7305 /* Print the information about variable VAR to dump file. */
7307 static void
7308 dump_var (variable *var)
7310 int i;
7311 location_chain *node;
7313 if (dv_is_decl_p (var->dv))
7315 const_tree decl = dv_as_decl (var->dv);
7317 if (DECL_NAME (decl))
7319 fprintf (dump_file, " name: %s",
7320 IDENTIFIER_POINTER (DECL_NAME (decl)));
7321 if (dump_flags & TDF_UID)
7322 fprintf (dump_file, "D.%u", DECL_UID (decl));
7324 else if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
7325 fprintf (dump_file, " name: D#%u", DEBUG_TEMP_UID (decl));
7326 else
7327 fprintf (dump_file, " name: D.%u", DECL_UID (decl));
7328 fprintf (dump_file, "\n");
7330 else
7332 fputc (' ', dump_file);
7333 print_rtl_single (dump_file, dv_as_value (var->dv));
7336 for (i = 0; i < var->n_var_parts; i++)
7338 fprintf (dump_file, " offset %ld\n",
7339 (long)(var->onepart ? 0 : VAR_PART_OFFSET (var, i)));
7340 for (node = var->var_part[i].loc_chain; node; node = node->next)
7342 fprintf (dump_file, " ");
7343 if (node->init == VAR_INIT_STATUS_UNINITIALIZED)
7344 fprintf (dump_file, "[uninit]");
7345 print_rtl_single (dump_file, node->loc);
7350 /* Print the information about variables from hash table VARS to dump file. */
7352 static void
7353 dump_vars (variable_table_type *vars)
7355 if (!vars->is_empty ())
7357 fprintf (dump_file, "Variables:\n");
7358 vars->traverse <void *, dump_var_tracking_slot> (NULL);
7362 /* Print the dataflow set SET to dump file. */
7364 static void
7365 dump_dataflow_set (dataflow_set *set)
7367 int i;
7369 fprintf (dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n",
7370 set->stack_adjust);
7371 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
7373 if (set->regs[i])
7375 fprintf (dump_file, "Reg %d:", i);
7376 dump_attrs_list (set->regs[i]);
7379 dump_vars (shared_hash_htab (set->vars));
7380 fprintf (dump_file, "\n");
7383 /* Print the IN and OUT sets for each basic block to dump file. */
7385 static void
7386 dump_dataflow_sets (void)
7388 basic_block bb;
7390 FOR_EACH_BB_FN (bb, cfun)
7392 fprintf (dump_file, "\nBasic block %d:\n", bb->index);
7393 fprintf (dump_file, "IN:\n");
7394 dump_dataflow_set (&VTI (bb)->in);
7395 fprintf (dump_file, "OUT:\n");
7396 dump_dataflow_set (&VTI (bb)->out);
7400 /* Return the variable for DV in dropped_values, inserting one if
7401 requested with INSERT. */
7403 static inline variable *
7404 variable_from_dropped (decl_or_value dv, enum insert_option insert)
7406 variable **slot;
7407 variable *empty_var;
7408 onepart_enum onepart;
7410 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), insert);
7412 if (!slot)
7413 return NULL;
7415 if (*slot)
7416 return *slot;
7418 gcc_checking_assert (insert == INSERT);
7420 onepart = dv_onepart_p (dv);
7422 gcc_checking_assert (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR);
7424 empty_var = onepart_pool_allocate (onepart);
7425 empty_var->dv = dv;
7426 empty_var->refcount = 1;
7427 empty_var->n_var_parts = 0;
7428 empty_var->onepart = onepart;
7429 empty_var->in_changed_variables = false;
7430 empty_var->var_part[0].loc_chain = NULL;
7431 empty_var->var_part[0].cur_loc = NULL;
7432 VAR_LOC_1PAUX (empty_var) = NULL;
7433 set_dv_changed (dv, true);
7435 *slot = empty_var;
7437 return empty_var;
7440 /* Recover the one-part aux from dropped_values. */
7442 static struct onepart_aux *
7443 recover_dropped_1paux (variable *var)
7445 variable *dvar;
7447 gcc_checking_assert (var->onepart);
7449 if (VAR_LOC_1PAUX (var))
7450 return VAR_LOC_1PAUX (var);
7452 if (var->onepart == ONEPART_VDECL)
7453 return NULL;
7455 dvar = variable_from_dropped (var->dv, NO_INSERT);
7457 if (!dvar)
7458 return NULL;
7460 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (dvar);
7461 VAR_LOC_1PAUX (dvar) = NULL;
7463 return VAR_LOC_1PAUX (var);
7466 /* Add variable VAR to the hash table of changed variables and
7467 if it has no locations delete it from SET's hash table. */
7469 static void
7470 variable_was_changed (variable *var, dataflow_set *set)
7472 hashval_t hash = dv_htab_hash (var->dv);
7474 if (emit_notes)
7476 variable **slot;
7478 /* Remember this decl or VALUE has been added to changed_variables. */
7479 set_dv_changed (var->dv, true);
7481 slot = changed_variables->find_slot_with_hash (var->dv, hash, INSERT);
7483 if (*slot)
7485 variable *old_var = *slot;
7486 gcc_assert (old_var->in_changed_variables);
7487 old_var->in_changed_variables = false;
7488 if (var != old_var && var->onepart)
7490 /* Restore the auxiliary info from an empty variable
7491 previously created for changed_variables, so it is
7492 not lost. */
7493 gcc_checking_assert (!VAR_LOC_1PAUX (var));
7494 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (old_var);
7495 VAR_LOC_1PAUX (old_var) = NULL;
7497 variable_htab_free (*slot);
7500 if (set && var->n_var_parts == 0)
7502 onepart_enum onepart = var->onepart;
7503 variable *empty_var = NULL;
7504 variable **dslot = NULL;
7506 if (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR)
7508 dslot = dropped_values->find_slot_with_hash (var->dv,
7509 dv_htab_hash (var->dv),
7510 INSERT);
7511 empty_var = *dslot;
7513 if (empty_var)
7515 gcc_checking_assert (!empty_var->in_changed_variables);
7516 if (!VAR_LOC_1PAUX (var))
7518 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (empty_var);
7519 VAR_LOC_1PAUX (empty_var) = NULL;
7521 else
7522 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
7526 if (!empty_var)
7528 empty_var = onepart_pool_allocate (onepart);
7529 empty_var->dv = var->dv;
7530 empty_var->refcount = 1;
7531 empty_var->n_var_parts = 0;
7532 empty_var->onepart = onepart;
7533 if (dslot)
7535 empty_var->refcount++;
7536 *dslot = empty_var;
7539 else
7540 empty_var->refcount++;
7541 empty_var->in_changed_variables = true;
7542 *slot = empty_var;
7543 if (onepart)
7545 empty_var->var_part[0].loc_chain = NULL;
7546 empty_var->var_part[0].cur_loc = NULL;
7547 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (var);
7548 VAR_LOC_1PAUX (var) = NULL;
7550 goto drop_var;
7552 else
7554 if (var->onepart && !VAR_LOC_1PAUX (var))
7555 recover_dropped_1paux (var);
7556 var->refcount++;
7557 var->in_changed_variables = true;
7558 *slot = var;
7561 else
7563 gcc_assert (set);
7564 if (var->n_var_parts == 0)
7566 variable **slot;
7568 drop_var:
7569 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
7570 if (slot)
7572 if (shared_hash_shared (set->vars))
7573 slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
7574 NO_INSERT);
7575 shared_hash_htab (set->vars)->clear_slot (slot);
7581 /* Look for the index in VAR->var_part corresponding to OFFSET.
7582 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7583 referenced int will be set to the index that the part has or should
7584 have, if it should be inserted. */
7586 static inline int
7587 find_variable_location_part (variable *var, HOST_WIDE_INT offset,
7588 int *insertion_point)
7590 int pos, low, high;
7592 if (var->onepart)
7594 if (offset != 0)
7595 return -1;
7597 if (insertion_point)
7598 *insertion_point = 0;
7600 return var->n_var_parts - 1;
7603 /* Find the location part. */
7604 low = 0;
7605 high = var->n_var_parts;
7606 while (low != high)
7608 pos = (low + high) / 2;
7609 if (VAR_PART_OFFSET (var, pos) < offset)
7610 low = pos + 1;
7611 else
7612 high = pos;
7614 pos = low;
7616 if (insertion_point)
7617 *insertion_point = pos;
7619 if (pos < var->n_var_parts && VAR_PART_OFFSET (var, pos) == offset)
7620 return pos;
7622 return -1;
7625 static variable **
7626 set_slot_part (dataflow_set *set, rtx loc, variable **slot,
7627 decl_or_value dv, HOST_WIDE_INT offset,
7628 enum var_init_status initialized, rtx set_src)
7630 int pos;
7631 location_chain *node, *next;
7632 location_chain **nextp;
7633 variable *var;
7634 onepart_enum onepart;
7636 var = *slot;
7638 if (var)
7639 onepart = var->onepart;
7640 else
7641 onepart = dv_onepart_p (dv);
7643 gcc_checking_assert (offset == 0 || !onepart);
7644 gcc_checking_assert (dv != loc);
7646 if (! flag_var_tracking_uninit)
7647 initialized = VAR_INIT_STATUS_INITIALIZED;
7649 if (!var)
7651 /* Create new variable information. */
7652 var = onepart_pool_allocate (onepart);
7653 var->dv = dv;
7654 var->refcount = 1;
7655 var->n_var_parts = 1;
7656 var->onepart = onepart;
7657 var->in_changed_variables = false;
7658 if (var->onepart)
7659 VAR_LOC_1PAUX (var) = NULL;
7660 else
7661 VAR_PART_OFFSET (var, 0) = offset;
7662 var->var_part[0].loc_chain = NULL;
7663 var->var_part[0].cur_loc = NULL;
7664 *slot = var;
7665 pos = 0;
7666 nextp = &var->var_part[0].loc_chain;
7668 else if (onepart)
7670 int r = -1, c = 0;
7672 gcc_assert (var->dv == dv);
7674 pos = 0;
7676 if (GET_CODE (loc) == VALUE)
7678 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7679 nextp = &node->next)
7680 if (GET_CODE (node->loc) == VALUE)
7682 if (node->loc == loc)
7684 r = 0;
7685 break;
7687 if (canon_value_cmp (node->loc, loc))
7688 c++;
7689 else
7691 r = 1;
7692 break;
7695 else if (REG_P (node->loc) || MEM_P (node->loc))
7696 c++;
7697 else
7699 r = 1;
7700 break;
7703 else if (REG_P (loc))
7705 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7706 nextp = &node->next)
7707 if (REG_P (node->loc))
7709 if (REGNO (node->loc) < REGNO (loc))
7710 c++;
7711 else
7713 if (REGNO (node->loc) == REGNO (loc))
7714 r = 0;
7715 else
7716 r = 1;
7717 break;
7720 else
7722 r = 1;
7723 break;
7726 else if (MEM_P (loc))
7728 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7729 nextp = &node->next)
7730 if (REG_P (node->loc))
7731 c++;
7732 else if (MEM_P (node->loc))
7734 if ((r = loc_cmp (XEXP (node->loc, 0), XEXP (loc, 0))) >= 0)
7735 break;
7736 else
7737 c++;
7739 else
7741 r = 1;
7742 break;
7745 else
7746 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7747 nextp = &node->next)
7748 if ((r = loc_cmp (node->loc, loc)) >= 0)
7749 break;
7750 else
7751 c++;
7753 if (r == 0)
7754 return slot;
7756 if (shared_var_p (var, set->vars))
7758 slot = unshare_variable (set, slot, var, initialized);
7759 var = *slot;
7760 for (nextp = &var->var_part[0].loc_chain; c;
7761 nextp = &(*nextp)->next)
7762 c--;
7763 gcc_assert ((!node && !*nextp) || node->loc == (*nextp)->loc);
7766 else
7768 int inspos = 0;
7770 gcc_assert (dv_as_decl (var->dv) == dv_as_decl (dv));
7772 pos = find_variable_location_part (var, offset, &inspos);
7774 if (pos >= 0)
7776 node = var->var_part[pos].loc_chain;
7778 if (node
7779 && ((REG_P (node->loc) && REG_P (loc)
7780 && REGNO (node->loc) == REGNO (loc))
7781 || rtx_equal_p (node->loc, loc)))
7783 /* LOC is in the beginning of the chain so we have nothing
7784 to do. */
7785 if (node->init < initialized)
7786 node->init = initialized;
7787 if (set_src != NULL)
7788 node->set_src = set_src;
7790 return slot;
7792 else
7794 /* We have to make a copy of a shared variable. */
7795 if (shared_var_p (var, set->vars))
7797 slot = unshare_variable (set, slot, var, initialized);
7798 var = *slot;
7802 else
7804 /* We have not found the location part, new one will be created. */
7806 /* We have to make a copy of the shared variable. */
7807 if (shared_var_p (var, set->vars))
7809 slot = unshare_variable (set, slot, var, initialized);
7810 var = *slot;
7813 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7814 thus there are at most MAX_VAR_PARTS different offsets. */
7815 gcc_assert (var->n_var_parts < MAX_VAR_PARTS
7816 && (!var->n_var_parts || !onepart));
7818 /* We have to move the elements of array starting at index
7819 inspos to the next position. */
7820 for (pos = var->n_var_parts; pos > inspos; pos--)
7821 var->var_part[pos] = var->var_part[pos - 1];
7823 var->n_var_parts++;
7824 gcc_checking_assert (!onepart);
7825 VAR_PART_OFFSET (var, pos) = offset;
7826 var->var_part[pos].loc_chain = NULL;
7827 var->var_part[pos].cur_loc = NULL;
7830 /* Delete the location from the list. */
7831 nextp = &var->var_part[pos].loc_chain;
7832 for (node = var->var_part[pos].loc_chain; node; node = next)
7834 next = node->next;
7835 if ((REG_P (node->loc) && REG_P (loc)
7836 && REGNO (node->loc) == REGNO (loc))
7837 || rtx_equal_p (node->loc, loc))
7839 /* Save these values, to assign to the new node, before
7840 deleting this one. */
7841 if (node->init > initialized)
7842 initialized = node->init;
7843 if (node->set_src != NULL && set_src == NULL)
7844 set_src = node->set_src;
7845 if (var->var_part[pos].cur_loc == node->loc)
7846 var->var_part[pos].cur_loc = NULL;
7847 delete node;
7848 *nextp = next;
7849 break;
7851 else
7852 nextp = &node->next;
7855 nextp = &var->var_part[pos].loc_chain;
7858 /* Add the location to the beginning. */
7859 node = new location_chain;
7860 node->loc = loc;
7861 node->init = initialized;
7862 node->set_src = set_src;
7863 node->next = *nextp;
7864 *nextp = node;
7866 /* If no location was emitted do so. */
7867 if (var->var_part[pos].cur_loc == NULL)
7868 variable_was_changed (var, set);
7870 return slot;
7873 /* Set the part of variable's location in the dataflow set SET. The
7874 variable part is specified by variable's declaration in DV and
7875 offset OFFSET and the part's location by LOC. IOPT should be
7876 NO_INSERT if the variable is known to be in SET already and the
7877 variable hash table must not be resized, and INSERT otherwise. */
7879 static void
7880 set_variable_part (dataflow_set *set, rtx loc,
7881 decl_or_value dv, HOST_WIDE_INT offset,
7882 enum var_init_status initialized, rtx set_src,
7883 enum insert_option iopt)
7885 variable **slot;
7887 if (iopt == NO_INSERT)
7888 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7889 else
7891 slot = shared_hash_find_slot (set->vars, dv);
7892 if (!slot)
7893 slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
7895 set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
7898 /* Remove all recorded register locations for the given variable part
7899 from dataflow set SET, except for those that are identical to loc.
7900 The variable part is specified by variable's declaration or value
7901 DV and offset OFFSET. */
7903 static variable **
7904 clobber_slot_part (dataflow_set *set, rtx loc, variable **slot,
7905 HOST_WIDE_INT offset, rtx set_src)
7907 variable *var = *slot;
7908 int pos = find_variable_location_part (var, offset, NULL);
7910 if (pos >= 0)
7912 location_chain *node, *next;
7914 /* Remove the register locations from the dataflow set. */
7915 next = var->var_part[pos].loc_chain;
7916 for (node = next; node; node = next)
7918 next = node->next;
7919 if (node->loc != loc
7920 && (!flag_var_tracking_uninit
7921 || !set_src
7922 || MEM_P (set_src)
7923 || !rtx_equal_p (set_src, node->set_src)))
7925 if (REG_P (node->loc))
7927 attrs *anode, *anext;
7928 attrs **anextp;
7930 /* Remove the variable part from the register's
7931 list, but preserve any other variable parts
7932 that might be regarded as live in that same
7933 register. */
7934 anextp = &set->regs[REGNO (node->loc)];
7935 for (anode = *anextp; anode; anode = anext)
7937 anext = anode->next;
7938 if (anode->dv == var->dv && anode->offset == offset)
7940 delete anode;
7941 *anextp = anext;
7943 else
7944 anextp = &anode->next;
7948 slot = delete_slot_part (set, node->loc, slot, offset);
7953 return slot;
7956 /* Remove all recorded register locations for the given variable part
7957 from dataflow set SET, except for those that are identical to loc.
7958 The variable part is specified by variable's declaration or value
7959 DV and offset OFFSET. */
7961 static void
7962 clobber_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
7963 HOST_WIDE_INT offset, rtx set_src)
7965 variable **slot;
7967 if (!dv || (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
7968 return;
7970 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7971 if (!slot)
7972 return;
7974 clobber_slot_part (set, loc, slot, offset, set_src);
7977 /* Delete the part of variable's location from dataflow set SET. The
7978 variable part is specified by its SET->vars slot SLOT and offset
7979 OFFSET and the part's location by LOC. */
7981 static variable **
7982 delete_slot_part (dataflow_set *set, rtx loc, variable **slot,
7983 HOST_WIDE_INT offset)
7985 variable *var = *slot;
7986 int pos = find_variable_location_part (var, offset, NULL);
7988 if (pos >= 0)
7990 location_chain *node, *next;
7991 location_chain **nextp;
7992 bool changed;
7993 rtx cur_loc;
7995 if (shared_var_p (var, set->vars))
7997 /* If the variable contains the location part we have to
7998 make a copy of the variable. */
7999 for (node = var->var_part[pos].loc_chain; node;
8000 node = node->next)
8002 if ((REG_P (node->loc) && REG_P (loc)
8003 && REGNO (node->loc) == REGNO (loc))
8004 || rtx_equal_p (node->loc, loc))
8006 slot = unshare_variable (set, slot, var,
8007 VAR_INIT_STATUS_UNKNOWN);
8008 var = *slot;
8009 break;
8014 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
8015 cur_loc = VAR_LOC_FROM (var);
8016 else
8017 cur_loc = var->var_part[pos].cur_loc;
8019 /* Delete the location part. */
8020 changed = false;
8021 nextp = &var->var_part[pos].loc_chain;
8022 for (node = *nextp; node; node = next)
8024 next = node->next;
8025 if ((REG_P (node->loc) && REG_P (loc)
8026 && REGNO (node->loc) == REGNO (loc))
8027 || rtx_equal_p (node->loc, loc))
8029 /* If we have deleted the location which was last emitted
8030 we have to emit new location so add the variable to set
8031 of changed variables. */
8032 if (cur_loc == node->loc)
8034 changed = true;
8035 var->var_part[pos].cur_loc = NULL;
8036 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
8037 VAR_LOC_FROM (var) = NULL;
8039 delete node;
8040 *nextp = next;
8041 break;
8043 else
8044 nextp = &node->next;
8047 if (var->var_part[pos].loc_chain == NULL)
8049 changed = true;
8050 var->n_var_parts--;
8051 while (pos < var->n_var_parts)
8053 var->var_part[pos] = var->var_part[pos + 1];
8054 pos++;
8057 if (changed)
8058 variable_was_changed (var, set);
8061 return slot;
8064 /* Delete the part of variable's location from dataflow set SET. The
8065 variable part is specified by variable's declaration or value DV
8066 and offset OFFSET and the part's location by LOC. */
8068 static void
8069 delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
8070 HOST_WIDE_INT offset)
8072 variable **slot = shared_hash_find_slot_noinsert (set->vars, dv);
8073 if (!slot)
8074 return;
8076 delete_slot_part (set, loc, slot, offset);
8080 /* Structure for passing some other parameters to function
8081 vt_expand_loc_callback. */
8082 class expand_loc_callback_data
8084 public:
8085 /* The variables and values active at this point. */
8086 variable_table_type *vars;
8088 /* Stack of values and debug_exprs under expansion, and their
8089 children. */
8090 auto_vec<rtx, 4> expanding;
8092 /* Stack of values and debug_exprs whose expansion hit recursion
8093 cycles. They will have VALUE_RECURSED_INTO marked when added to
8094 this list. This flag will be cleared if any of its dependencies
8095 resolves to a valid location. So, if the flag remains set at the
8096 end of the search, we know no valid location for this one can
8097 possibly exist. */
8098 auto_vec<rtx, 4> pending;
8100 /* The maximum depth among the sub-expressions under expansion.
8101 Zero indicates no expansion so far. */
8102 expand_depth depth;
8105 /* Allocate the one-part auxiliary data structure for VAR, with enough
8106 room for COUNT dependencies. */
8108 static void
8109 loc_exp_dep_alloc (variable *var, int count)
8111 size_t allocsize;
8113 gcc_checking_assert (var->onepart);
8115 /* We can be called with COUNT == 0 to allocate the data structure
8116 without any dependencies, e.g. for the backlinks only. However,
8117 if we are specifying a COUNT, then the dependency list must have
8118 been emptied before. It would be possible to adjust pointers or
8119 force it empty here, but this is better done at an earlier point
8120 in the algorithm, so we instead leave an assertion to catch
8121 errors. */
8122 gcc_checking_assert (!count
8123 || VAR_LOC_DEP_VEC (var) == NULL
8124 || VAR_LOC_DEP_VEC (var)->is_empty ());
8126 if (VAR_LOC_1PAUX (var) && VAR_LOC_DEP_VEC (var)->space (count))
8127 return;
8129 allocsize = offsetof (struct onepart_aux, deps)
8130 + deps_vec::embedded_size (count);
8132 if (VAR_LOC_1PAUX (var))
8134 VAR_LOC_1PAUX (var) = XRESIZEVAR (struct onepart_aux,
8135 VAR_LOC_1PAUX (var), allocsize);
8136 /* If the reallocation moves the onepaux structure, the
8137 back-pointer to BACKLINKS in the first list member will still
8138 point to its old location. Adjust it. */
8139 if (VAR_LOC_DEP_LST (var))
8140 VAR_LOC_DEP_LST (var)->pprev = VAR_LOC_DEP_LSTP (var);
8142 else
8144 VAR_LOC_1PAUX (var) = XNEWVAR (struct onepart_aux, allocsize);
8145 *VAR_LOC_DEP_LSTP (var) = NULL;
8146 VAR_LOC_FROM (var) = NULL;
8147 VAR_LOC_DEPTH (var).complexity = 0;
8148 VAR_LOC_DEPTH (var).entryvals = 0;
8150 VAR_LOC_DEP_VEC (var)->embedded_init (count);
8153 /* Remove all entries from the vector of active dependencies of VAR,
8154 removing them from the back-links lists too. */
8156 static void
8157 loc_exp_dep_clear (variable *var)
8159 while (VAR_LOC_DEP_VEC (var) && !VAR_LOC_DEP_VEC (var)->is_empty ())
8161 loc_exp_dep *led = &VAR_LOC_DEP_VEC (var)->last ();
8162 if (led->next)
8163 led->next->pprev = led->pprev;
8164 if (led->pprev)
8165 *led->pprev = led->next;
8166 VAR_LOC_DEP_VEC (var)->pop ();
8170 /* Insert an active dependency from VAR on X to the vector of
8171 dependencies, and add the corresponding back-link to X's list of
8172 back-links in VARS. */
8174 static void
8175 loc_exp_insert_dep (variable *var, rtx x, variable_table_type *vars)
8177 decl_or_value dv;
8178 variable *xvar;
8179 loc_exp_dep *led;
8181 dv = dv_from_rtx (x);
8183 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8184 an additional look up? */
8185 xvar = vars->find_with_hash (dv, dv_htab_hash (dv));
8187 if (!xvar)
8189 xvar = variable_from_dropped (dv, NO_INSERT);
8190 gcc_checking_assert (xvar);
8193 /* No point in adding the same backlink more than once. This may
8194 arise if say the same value appears in two complex expressions in
8195 the same loc_list, or even more than once in a single
8196 expression. */
8197 if (VAR_LOC_DEP_LST (xvar) && VAR_LOC_DEP_LST (xvar)->dv == var->dv)
8198 return;
8200 if (var->onepart == NOT_ONEPART)
8201 led = new loc_exp_dep;
8202 else
8204 loc_exp_dep empty;
8205 memset (&empty, 0, sizeof (empty));
8206 VAR_LOC_DEP_VEC (var)->quick_push (empty);
8207 led = &VAR_LOC_DEP_VEC (var)->last ();
8209 led->dv = var->dv;
8210 led->value = x;
8212 loc_exp_dep_alloc (xvar, 0);
8213 led->pprev = VAR_LOC_DEP_LSTP (xvar);
8214 led->next = *led->pprev;
8215 if (led->next)
8216 led->next->pprev = &led->next;
8217 *led->pprev = led;
8220 /* Create active dependencies of VAR on COUNT values starting at
8221 VALUE, and corresponding back-links to the entries in VARS. Return
8222 true if we found any pending-recursion results. */
8224 static bool
8225 loc_exp_dep_set (variable *var, rtx result, rtx *value, int count,
8226 variable_table_type *vars)
8228 bool pending_recursion = false;
8230 gcc_checking_assert (VAR_LOC_DEP_VEC (var) == NULL
8231 || VAR_LOC_DEP_VEC (var)->is_empty ());
8233 /* Set up all dependencies from last_child (as set up at the end of
8234 the loop above) to the end. */
8235 loc_exp_dep_alloc (var, count);
8237 while (count--)
8239 rtx x = *value++;
8241 if (!pending_recursion)
8242 pending_recursion = !result && VALUE_RECURSED_INTO (x);
8244 loc_exp_insert_dep (var, x, vars);
8247 return pending_recursion;
8250 /* Notify the back-links of IVAR that are pending recursion that we
8251 have found a non-NIL value for it, so they are cleared for another
8252 attempt to compute a current location. */
8254 static void
8255 notify_dependents_of_resolved_value (variable *ivar, variable_table_type *vars)
8257 loc_exp_dep *led, *next;
8259 for (led = VAR_LOC_DEP_LST (ivar); led; led = next)
8261 decl_or_value dv = led->dv;
8262 variable *var;
8264 next = led->next;
8266 if (dv_is_value_p (dv))
8268 rtx value = dv_as_value (dv);
8270 /* If we have already resolved it, leave it alone. */
8271 if (!VALUE_RECURSED_INTO (value))
8272 continue;
8274 /* Check that VALUE_RECURSED_INTO, true from the test above,
8275 implies NO_LOC_P. */
8276 gcc_checking_assert (NO_LOC_P (value));
8278 /* We won't notify variables that are being expanded,
8279 because their dependency list is cleared before
8280 recursing. */
8281 NO_LOC_P (value) = false;
8282 VALUE_RECURSED_INTO (value) = false;
8284 gcc_checking_assert (dv_changed_p (dv));
8286 else
8288 gcc_checking_assert (dv_onepart_p (dv) != NOT_ONEPART);
8289 if (!dv_changed_p (dv))
8290 continue;
8293 var = vars->find_with_hash (dv, dv_htab_hash (dv));
8295 if (!var)
8296 var = variable_from_dropped (dv, NO_INSERT);
8298 if (var)
8299 notify_dependents_of_resolved_value (var, vars);
8301 if (next)
8302 next->pprev = led->pprev;
8303 if (led->pprev)
8304 *led->pprev = next;
8305 led->next = NULL;
8306 led->pprev = NULL;
8310 static rtx vt_expand_loc_callback (rtx x, bitmap regs,
8311 int max_depth, void *data);
8313 /* Return the combined depth, when one sub-expression evaluated to
8314 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8316 static inline expand_depth
8317 update_depth (expand_depth saved_depth, expand_depth best_depth)
8319 /* If we didn't find anything, stick with what we had. */
8320 if (!best_depth.complexity)
8321 return saved_depth;
8323 /* If we found hadn't found anything, use the depth of the current
8324 expression. Do NOT add one extra level, we want to compute the
8325 maximum depth among sub-expressions. We'll increment it later,
8326 if appropriate. */
8327 if (!saved_depth.complexity)
8328 return best_depth;
8330 /* Combine the entryval count so that regardless of which one we
8331 return, the entryval count is accurate. */
8332 best_depth.entryvals = saved_depth.entryvals
8333 = best_depth.entryvals + saved_depth.entryvals;
8335 if (saved_depth.complexity < best_depth.complexity)
8336 return best_depth;
8337 else
8338 return saved_depth;
8341 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8342 DATA for cselib expand callback. If PENDRECP is given, indicate in
8343 it whether any sub-expression couldn't be fully evaluated because
8344 it is pending recursion resolution. */
8346 static inline rtx
8347 vt_expand_var_loc_chain (variable *var, bitmap regs, void *data,
8348 bool *pendrecp)
8350 class expand_loc_callback_data *elcd
8351 = (class expand_loc_callback_data *) data;
8352 location_chain *loc, *next;
8353 rtx result = NULL;
8354 int first_child, result_first_child, last_child;
8355 bool pending_recursion;
8356 rtx loc_from = NULL;
8357 struct elt_loc_list *cloc = NULL;
8358 expand_depth depth = { 0, 0 }, saved_depth = elcd->depth;
8359 int wanted_entryvals, found_entryvals = 0;
8361 /* Clear all backlinks pointing at this, so that we're not notified
8362 while we're active. */
8363 loc_exp_dep_clear (var);
8365 retry:
8366 if (var->onepart == ONEPART_VALUE)
8368 cselib_val *val = CSELIB_VAL_PTR (dv_as_value (var->dv));
8370 gcc_checking_assert (cselib_preserved_value_p (val));
8372 cloc = val->locs;
8375 first_child = result_first_child = last_child
8376 = elcd->expanding.length ();
8378 wanted_entryvals = found_entryvals;
8380 /* Attempt to expand each available location in turn. */
8381 for (next = loc = var->n_var_parts ? var->var_part[0].loc_chain : NULL;
8382 loc || cloc; loc = next)
8384 result_first_child = last_child;
8386 if (!loc)
8388 loc_from = cloc->loc;
8389 next = loc;
8390 cloc = cloc->next;
8391 if (unsuitable_loc (loc_from))
8392 continue;
8394 else
8396 loc_from = loc->loc;
8397 next = loc->next;
8400 gcc_checking_assert (!unsuitable_loc (loc_from));
8402 elcd->depth.complexity = elcd->depth.entryvals = 0;
8403 result = cselib_expand_value_rtx_cb (loc_from, regs, EXPR_DEPTH,
8404 vt_expand_loc_callback, data);
8405 last_child = elcd->expanding.length ();
8407 if (result)
8409 depth = elcd->depth;
8411 gcc_checking_assert (depth.complexity
8412 || result_first_child == last_child);
8414 if (last_child - result_first_child != 1)
8416 if (!depth.complexity && GET_CODE (result) == ENTRY_VALUE)
8417 depth.entryvals++;
8418 depth.complexity++;
8421 if (depth.complexity <= EXPR_USE_DEPTH)
8423 if (depth.entryvals <= wanted_entryvals)
8424 break;
8425 else if (!found_entryvals || depth.entryvals < found_entryvals)
8426 found_entryvals = depth.entryvals;
8429 result = NULL;
8432 /* Set it up in case we leave the loop. */
8433 depth.complexity = depth.entryvals = 0;
8434 loc_from = NULL;
8435 result_first_child = first_child;
8438 if (!loc_from && wanted_entryvals < found_entryvals)
8440 /* We found entries with ENTRY_VALUEs and skipped them. Since
8441 we could not find any expansions without ENTRY_VALUEs, but we
8442 found at least one with them, go back and get an entry with
8443 the minimum number ENTRY_VALUE count that we found. We could
8444 avoid looping, but since each sub-loc is already resolved,
8445 the re-expansion should be trivial. ??? Should we record all
8446 attempted locs as dependencies, so that we retry the
8447 expansion should any of them change, in the hope it can give
8448 us a new entry without an ENTRY_VALUE? */
8449 elcd->expanding.truncate (first_child);
8450 goto retry;
8453 /* Register all encountered dependencies as active. */
8454 pending_recursion = loc_exp_dep_set
8455 (var, result, elcd->expanding.address () + result_first_child,
8456 last_child - result_first_child, elcd->vars);
8458 elcd->expanding.truncate (first_child);
8460 /* Record where the expansion came from. */
8461 gcc_checking_assert (!result || !pending_recursion);
8462 VAR_LOC_FROM (var) = loc_from;
8463 VAR_LOC_DEPTH (var) = depth;
8465 gcc_checking_assert (!depth.complexity == !result);
8467 elcd->depth = update_depth (saved_depth, depth);
8469 /* Indicate whether any of the dependencies are pending recursion
8470 resolution. */
8471 if (pendrecp)
8472 *pendrecp = pending_recursion;
8474 if (!pendrecp || !pending_recursion)
8475 var->var_part[0].cur_loc = result;
8477 return result;
8480 /* Callback for cselib_expand_value, that looks for expressions
8481 holding the value in the var-tracking hash tables. Return X for
8482 standard processing, anything else is to be used as-is. */
8484 static rtx
8485 vt_expand_loc_callback (rtx x, bitmap regs,
8486 int max_depth ATTRIBUTE_UNUSED,
8487 void *data)
8489 class expand_loc_callback_data *elcd
8490 = (class expand_loc_callback_data *) data;
8491 decl_or_value dv;
8492 variable *var;
8493 rtx result, subreg;
8494 bool pending_recursion = false;
8495 bool from_empty = false;
8497 switch (GET_CODE (x))
8499 case SUBREG:
8500 subreg = cselib_expand_value_rtx_cb (SUBREG_REG (x), regs,
8501 EXPR_DEPTH,
8502 vt_expand_loc_callback, data);
8504 if (!subreg)
8505 return NULL;
8507 result = simplify_gen_subreg (GET_MODE (x), subreg,
8508 GET_MODE (SUBREG_REG (x)),
8509 SUBREG_BYTE (x));
8511 /* Invalid SUBREGs are ok in debug info. ??? We could try
8512 alternate expansions for the VALUE as well. */
8513 if (!result && GET_MODE (subreg) != VOIDmode)
8514 result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
8516 return result;
8518 case DEBUG_EXPR:
8519 case VALUE:
8520 dv = dv_from_rtx (x);
8521 break;
8523 default:
8524 return x;
8527 elcd->expanding.safe_push (x);
8529 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8530 gcc_checking_assert (!VALUE_RECURSED_INTO (x) || NO_LOC_P (x));
8532 if (NO_LOC_P (x))
8534 gcc_checking_assert (VALUE_RECURSED_INTO (x) || !dv_changed_p (dv));
8535 return NULL;
8538 var = elcd->vars->find_with_hash (dv, dv_htab_hash (dv));
8540 if (!var)
8542 from_empty = true;
8543 var = variable_from_dropped (dv, INSERT);
8546 gcc_checking_assert (var);
8548 if (!dv_changed_p (dv))
8550 gcc_checking_assert (!NO_LOC_P (x));
8551 gcc_checking_assert (var->var_part[0].cur_loc);
8552 gcc_checking_assert (VAR_LOC_1PAUX (var));
8553 gcc_checking_assert (VAR_LOC_1PAUX (var)->depth.complexity);
8555 elcd->depth = update_depth (elcd->depth, VAR_LOC_1PAUX (var)->depth);
8557 return var->var_part[0].cur_loc;
8560 VALUE_RECURSED_INTO (x) = true;
8561 /* This is tentative, but it makes some tests simpler. */
8562 NO_LOC_P (x) = true;
8564 gcc_checking_assert (var->n_var_parts == 1 || from_empty);
8566 result = vt_expand_var_loc_chain (var, regs, data, &pending_recursion);
8568 if (pending_recursion)
8570 gcc_checking_assert (!result);
8571 elcd->pending.safe_push (x);
8573 else
8575 NO_LOC_P (x) = !result;
8576 VALUE_RECURSED_INTO (x) = false;
8577 set_dv_changed (dv, false);
8579 if (result)
8580 notify_dependents_of_resolved_value (var, elcd->vars);
8583 return result;
8586 /* While expanding variables, we may encounter recursion cycles
8587 because of mutual (possibly indirect) dependencies between two
8588 particular variables (or values), say A and B. If we're trying to
8589 expand A when we get to B, which in turn attempts to expand A, if
8590 we can't find any other expansion for B, we'll add B to this
8591 pending-recursion stack, and tentatively return NULL for its
8592 location. This tentative value will be used for any other
8593 occurrences of B, unless A gets some other location, in which case
8594 it will notify B that it is worth another try at computing a
8595 location for it, and it will use the location computed for A then.
8596 At the end of the expansion, the tentative NULL locations become
8597 final for all members of PENDING that didn't get a notification.
8598 This function performs this finalization of NULL locations. */
8600 static void
8601 resolve_expansions_pending_recursion (vec<rtx, va_heap> *pending)
8603 while (!pending->is_empty ())
8605 rtx x = pending->pop ();
8606 decl_or_value dv;
8608 if (!VALUE_RECURSED_INTO (x))
8609 continue;
8611 gcc_checking_assert (NO_LOC_P (x));
8612 VALUE_RECURSED_INTO (x) = false;
8613 dv = dv_from_rtx (x);
8614 gcc_checking_assert (dv_changed_p (dv));
8615 set_dv_changed (dv, false);
8619 /* Initialize expand_loc_callback_data D with variable hash table V.
8620 It must be a macro because of alloca (vec stack). */
8621 #define INIT_ELCD(d, v) \
8622 do \
8624 (d).vars = (v); \
8625 (d).depth.complexity = (d).depth.entryvals = 0; \
8627 while (0)
8628 /* Finalize expand_loc_callback_data D, resolved to location L. */
8629 #define FINI_ELCD(d, l) \
8630 do \
8632 resolve_expansions_pending_recursion (&(d).pending); \
8633 (d).pending.release (); \
8634 (d).expanding.release (); \
8636 if ((l) && MEM_P (l)) \
8637 (l) = targetm.delegitimize_address (l); \
8639 while (0)
8641 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8642 equivalences in VARS, updating their CUR_LOCs in the process. */
8644 static rtx
8645 vt_expand_loc (rtx loc, variable_table_type *vars)
8647 class expand_loc_callback_data data;
8648 rtx result;
8650 if (!MAY_HAVE_DEBUG_BIND_INSNS)
8651 return loc;
8653 INIT_ELCD (data, vars);
8655 result = cselib_expand_value_rtx_cb (loc, scratch_regs, EXPR_DEPTH,
8656 vt_expand_loc_callback, &data);
8658 FINI_ELCD (data, result);
8660 return result;
8663 /* Expand the one-part VARiable to a location, using the equivalences
8664 in VARS, updating their CUR_LOCs in the process. */
8666 static rtx
8667 vt_expand_1pvar (variable *var, variable_table_type *vars)
8669 class expand_loc_callback_data data;
8670 rtx loc;
8672 gcc_checking_assert (var->onepart && var->n_var_parts == 1);
8674 if (!dv_changed_p (var->dv))
8675 return var->var_part[0].cur_loc;
8677 INIT_ELCD (data, vars);
8679 loc = vt_expand_var_loc_chain (var, scratch_regs, &data, NULL);
8681 gcc_checking_assert (data.expanding.is_empty ());
8683 FINI_ELCD (data, loc);
8685 return loc;
8688 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8689 additional parameters: WHERE specifies whether the note shall be emitted
8690 before or after instruction INSN. */
8693 emit_note_insn_var_location (variable **varp, emit_note_data *data)
8695 variable *var = *varp;
8696 rtx_insn *insn = data->insn;
8697 enum emit_note_where where = data->where;
8698 variable_table_type *vars = data->vars;
8699 rtx_note *note;
8700 rtx note_vl;
8701 int i, j, n_var_parts;
8702 bool complete;
8703 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
8704 HOST_WIDE_INT last_limit;
8705 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
8706 rtx loc[MAX_VAR_PARTS];
8707 tree decl;
8708 location_chain *lc;
8710 gcc_checking_assert (var->onepart == NOT_ONEPART
8711 || var->onepart == ONEPART_VDECL);
8713 decl = dv_as_decl (var->dv);
8715 complete = true;
8716 last_limit = 0;
8717 n_var_parts = 0;
8718 if (!var->onepart)
8719 for (i = 0; i < var->n_var_parts; i++)
8720 if (var->var_part[i].cur_loc == NULL && var->var_part[i].loc_chain)
8721 var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
8722 for (i = 0; i < var->n_var_parts; i++)
8724 machine_mode mode, wider_mode;
8725 rtx loc2;
8726 HOST_WIDE_INT offset, size, wider_size;
8728 if (i == 0 && var->onepart)
8730 gcc_checking_assert (var->n_var_parts == 1);
8731 offset = 0;
8732 initialized = VAR_INIT_STATUS_INITIALIZED;
8733 loc2 = vt_expand_1pvar (var, vars);
8735 else
8737 if (last_limit < VAR_PART_OFFSET (var, i))
8739 complete = false;
8740 break;
8742 else if (last_limit > VAR_PART_OFFSET (var, i))
8743 continue;
8744 offset = VAR_PART_OFFSET (var, i);
8745 loc2 = var->var_part[i].cur_loc;
8746 if (loc2 && GET_CODE (loc2) == MEM
8747 && GET_CODE (XEXP (loc2, 0)) == VALUE)
8749 rtx depval = XEXP (loc2, 0);
8751 loc2 = vt_expand_loc (loc2, vars);
8753 if (loc2)
8754 loc_exp_insert_dep (var, depval, vars);
8756 if (!loc2)
8758 complete = false;
8759 continue;
8761 gcc_checking_assert (GET_CODE (loc2) != VALUE);
8762 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
8763 if (var->var_part[i].cur_loc == lc->loc)
8765 initialized = lc->init;
8766 break;
8768 gcc_assert (lc);
8771 offsets[n_var_parts] = offset;
8772 if (!loc2)
8774 complete = false;
8775 continue;
8777 loc[n_var_parts] = loc2;
8778 mode = GET_MODE (var->var_part[i].cur_loc);
8779 if (mode == VOIDmode && var->onepart)
8780 mode = DECL_MODE (decl);
8781 /* We ony track subparts of constant-sized objects, since at present
8782 there's no representation for polynomial pieces. */
8783 if (!GET_MODE_SIZE (mode).is_constant (&size))
8785 complete = false;
8786 continue;
8788 last_limit = offsets[n_var_parts] + size;
8790 /* Attempt to merge adjacent registers or memory. */
8791 for (j = i + 1; j < var->n_var_parts; j++)
8792 if (last_limit <= VAR_PART_OFFSET (var, j))
8793 break;
8794 if (j < var->n_var_parts
8795 && GET_MODE_WIDER_MODE (mode).exists (&wider_mode)
8796 && GET_MODE_SIZE (wider_mode).is_constant (&wider_size)
8797 && var->var_part[j].cur_loc
8798 && mode == GET_MODE (var->var_part[j].cur_loc)
8799 && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
8800 && last_limit == (var->onepart ? 0 : VAR_PART_OFFSET (var, j))
8801 && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
8802 && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
8804 rtx new_loc = NULL;
8805 poly_int64 offset2;
8807 if (REG_P (loc[n_var_parts])
8808 && hard_regno_nregs (REGNO (loc[n_var_parts]), mode) * 2
8809 == hard_regno_nregs (REGNO (loc[n_var_parts]), wider_mode)
8810 && end_hard_regno (mode, REGNO (loc[n_var_parts]))
8811 == REGNO (loc2))
8813 if (! WORDS_BIG_ENDIAN && ! BYTES_BIG_ENDIAN)
8814 new_loc = simplify_subreg (wider_mode, loc[n_var_parts],
8815 mode, 0);
8816 else if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
8817 new_loc = simplify_subreg (wider_mode, loc2, mode, 0);
8818 if (new_loc)
8820 if (!REG_P (new_loc)
8821 || REGNO (new_loc) != REGNO (loc[n_var_parts]))
8822 new_loc = NULL;
8823 else
8824 REG_ATTRS (new_loc) = REG_ATTRS (loc[n_var_parts]);
8827 else if (MEM_P (loc[n_var_parts])
8828 && GET_CODE (XEXP (loc2, 0)) == PLUS
8829 && REG_P (XEXP (XEXP (loc2, 0), 0))
8830 && poly_int_rtx_p (XEXP (XEXP (loc2, 0), 1), &offset2))
8832 poly_int64 end1 = size;
8833 rtx base1 = strip_offset_and_add (XEXP (loc[n_var_parts], 0),
8834 &end1);
8835 if (rtx_equal_p (base1, XEXP (XEXP (loc2, 0), 0))
8836 && known_eq (end1, offset2))
8837 new_loc = adjust_address_nv (loc[n_var_parts],
8838 wider_mode, 0);
8841 if (new_loc)
8843 loc[n_var_parts] = new_loc;
8844 mode = wider_mode;
8845 last_limit = offsets[n_var_parts] + wider_size;
8846 i = j;
8849 ++n_var_parts;
8851 poly_uint64 type_size_unit
8852 = tree_to_poly_uint64 (TYPE_SIZE_UNIT (TREE_TYPE (decl)));
8853 if (maybe_lt (poly_uint64 (last_limit), type_size_unit))
8854 complete = false;
8856 if (! flag_var_tracking_uninit)
8857 initialized = VAR_INIT_STATUS_INITIALIZED;
8859 note_vl = NULL_RTX;
8860 if (!complete)
8861 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, NULL_RTX, initialized);
8862 else if (n_var_parts == 1)
8864 rtx expr_list;
8866 if (offsets[0] || GET_CODE (loc[0]) == PARALLEL)
8867 expr_list = gen_rtx_EXPR_LIST (VOIDmode, loc[0], GEN_INT (offsets[0]));
8868 else
8869 expr_list = loc[0];
8871 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, expr_list, initialized);
8873 else if (n_var_parts)
8875 rtx parallel;
8877 for (i = 0; i < n_var_parts; i++)
8878 loc[i]
8879 = gen_rtx_EXPR_LIST (VOIDmode, loc[i], GEN_INT (offsets[i]));
8881 parallel = gen_rtx_PARALLEL (VOIDmode,
8882 gen_rtvec_v (n_var_parts, loc));
8883 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl,
8884 parallel, initialized);
8887 if (where != EMIT_NOTE_BEFORE_INSN)
8889 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8890 if (where == EMIT_NOTE_AFTER_CALL_INSN)
8891 NOTE_DURING_CALL_P (note) = true;
8893 else
8895 /* Make sure that the call related notes come first. */
8896 while (NEXT_INSN (insn)
8897 && NOTE_P (insn)
8898 && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8899 && NOTE_DURING_CALL_P (insn))
8900 insn = NEXT_INSN (insn);
8901 if (NOTE_P (insn)
8902 && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8903 && NOTE_DURING_CALL_P (insn))
8904 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8905 else
8906 note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
8908 NOTE_VAR_LOCATION (note) = note_vl;
8910 set_dv_changed (var->dv, false);
8911 gcc_assert (var->in_changed_variables);
8912 var->in_changed_variables = false;
8913 changed_variables->clear_slot (varp);
8915 /* Continue traversing the hash table. */
8916 return 1;
8919 /* While traversing changed_variables, push onto DATA (a stack of RTX
8920 values) entries that aren't user variables. */
8923 var_track_values_to_stack (variable **slot,
8924 vec<rtx, va_heap> *changed_values_stack)
8926 variable *var = *slot;
8928 if (var->onepart == ONEPART_VALUE)
8929 changed_values_stack->safe_push (dv_as_value (var->dv));
8930 else if (var->onepart == ONEPART_DEXPR)
8931 changed_values_stack->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var->dv)));
8933 return 1;
8936 /* Remove from changed_variables the entry whose DV corresponds to
8937 value or debug_expr VAL. */
8938 static void
8939 remove_value_from_changed_variables (rtx val)
8941 decl_or_value dv = dv_from_rtx (val);
8942 variable **slot;
8943 variable *var;
8945 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8946 NO_INSERT);
8947 var = *slot;
8948 var->in_changed_variables = false;
8949 changed_variables->clear_slot (slot);
8952 /* If VAL (a value or debug_expr) has backlinks to variables actively
8953 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8954 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8955 have dependencies of their own to notify. */
8957 static void
8958 notify_dependents_of_changed_value (rtx val, variable_table_type *htab,
8959 vec<rtx, va_heap> *changed_values_stack)
8961 variable **slot;
8962 variable *var;
8963 loc_exp_dep *led;
8964 decl_or_value dv = dv_from_rtx (val);
8966 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8967 NO_INSERT);
8968 if (!slot)
8969 slot = htab->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT);
8970 if (!slot)
8971 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv),
8972 NO_INSERT);
8973 var = *slot;
8975 while ((led = VAR_LOC_DEP_LST (var)))
8977 decl_or_value ldv = led->dv;
8978 variable *ivar;
8980 /* Deactivate and remove the backlink, as it was “used up”. It
8981 makes no sense to attempt to notify the same entity again:
8982 either it will be recomputed and re-register an active
8983 dependency, or it will still have the changed mark. */
8984 if (led->next)
8985 led->next->pprev = led->pprev;
8986 if (led->pprev)
8987 *led->pprev = led->next;
8988 led->next = NULL;
8989 led->pprev = NULL;
8991 if (dv_changed_p (ldv))
8992 continue;
8994 switch (dv_onepart_p (ldv))
8996 case ONEPART_VALUE:
8997 case ONEPART_DEXPR:
8998 set_dv_changed (ldv, true);
8999 changed_values_stack->safe_push (dv_as_rtx (ldv));
9000 break;
9002 case ONEPART_VDECL:
9003 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
9004 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar));
9005 variable_was_changed (ivar, NULL);
9006 break;
9008 case NOT_ONEPART:
9009 delete led;
9010 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
9011 if (ivar)
9013 int i = ivar->n_var_parts;
9014 while (i--)
9016 rtx loc = ivar->var_part[i].cur_loc;
9018 if (loc && GET_CODE (loc) == MEM
9019 && XEXP (loc, 0) == val)
9021 variable_was_changed (ivar, NULL);
9022 break;
9026 break;
9028 default:
9029 gcc_unreachable ();
9034 /* Take out of changed_variables any entries that don't refer to use
9035 variables. Back-propagate change notifications from values and
9036 debug_exprs to their active dependencies in HTAB or in
9037 CHANGED_VARIABLES. */
9039 static void
9040 process_changed_values (variable_table_type *htab)
9042 int i, n;
9043 rtx val;
9044 auto_vec<rtx, 20> changed_values_stack;
9046 /* Move values from changed_variables to changed_values_stack. */
9047 changed_variables
9048 ->traverse <vec<rtx, va_heap>*, var_track_values_to_stack>
9049 (&changed_values_stack);
9051 /* Back-propagate change notifications in values while popping
9052 them from the stack. */
9053 for (n = i = changed_values_stack.length ();
9054 i > 0; i = changed_values_stack.length ())
9056 val = changed_values_stack.pop ();
9057 notify_dependents_of_changed_value (val, htab, &changed_values_stack);
9059 /* This condition will hold when visiting each of the entries
9060 originally in changed_variables. We can't remove them
9061 earlier because this could drop the backlinks before we got a
9062 chance to use them. */
9063 if (i == n)
9065 remove_value_from_changed_variables (val);
9066 n--;
9071 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
9072 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
9073 the notes shall be emitted before of after instruction INSN. */
9075 static void
9076 emit_notes_for_changes (rtx_insn *insn, enum emit_note_where where,
9077 shared_hash *vars)
9079 emit_note_data data;
9080 variable_table_type *htab = shared_hash_htab (vars);
9082 if (changed_variables->is_empty ())
9083 return;
9085 if (MAY_HAVE_DEBUG_BIND_INSNS)
9086 process_changed_values (htab);
9088 data.insn = insn;
9089 data.where = where;
9090 data.vars = htab;
9092 changed_variables
9093 ->traverse <emit_note_data*, emit_note_insn_var_location> (&data);
9096 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9097 same variable in hash table DATA or is not there at all. */
9100 emit_notes_for_differences_1 (variable **slot, variable_table_type *new_vars)
9102 variable *old_var, *new_var;
9104 old_var = *slot;
9105 new_var = new_vars->find_with_hash (old_var->dv, dv_htab_hash (old_var->dv));
9107 if (!new_var)
9109 /* Variable has disappeared. */
9110 variable *empty_var = NULL;
9112 if (old_var->onepart == ONEPART_VALUE
9113 || old_var->onepart == ONEPART_DEXPR)
9115 empty_var = variable_from_dropped (old_var->dv, NO_INSERT);
9116 if (empty_var)
9118 gcc_checking_assert (!empty_var->in_changed_variables);
9119 if (!VAR_LOC_1PAUX (old_var))
9121 VAR_LOC_1PAUX (old_var) = VAR_LOC_1PAUX (empty_var);
9122 VAR_LOC_1PAUX (empty_var) = NULL;
9124 else
9125 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
9129 if (!empty_var)
9131 empty_var = onepart_pool_allocate (old_var->onepart);
9132 empty_var->dv = old_var->dv;
9133 empty_var->refcount = 0;
9134 empty_var->n_var_parts = 0;
9135 empty_var->onepart = old_var->onepart;
9136 empty_var->in_changed_variables = false;
9139 if (empty_var->onepart)
9141 /* Propagate the auxiliary data to (ultimately)
9142 changed_variables. */
9143 empty_var->var_part[0].loc_chain = NULL;
9144 empty_var->var_part[0].cur_loc = NULL;
9145 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (old_var);
9146 VAR_LOC_1PAUX (old_var) = NULL;
9148 variable_was_changed (empty_var, NULL);
9149 /* Continue traversing the hash table. */
9150 return 1;
9152 /* Update cur_loc and one-part auxiliary data, before new_var goes
9153 through variable_was_changed. */
9154 if (old_var != new_var && new_var->onepart)
9156 gcc_checking_assert (VAR_LOC_1PAUX (new_var) == NULL);
9157 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (old_var);
9158 VAR_LOC_1PAUX (old_var) = NULL;
9159 new_var->var_part[0].cur_loc = old_var->var_part[0].cur_loc;
9161 if (variable_different_p (old_var, new_var))
9162 variable_was_changed (new_var, NULL);
9164 /* Continue traversing the hash table. */
9165 return 1;
9168 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9169 table DATA. */
9172 emit_notes_for_differences_2 (variable **slot, variable_table_type *old_vars)
9174 variable *old_var, *new_var;
9176 new_var = *slot;
9177 old_var = old_vars->find_with_hash (new_var->dv, dv_htab_hash (new_var->dv));
9178 if (!old_var)
9180 int i;
9181 for (i = 0; i < new_var->n_var_parts; i++)
9182 new_var->var_part[i].cur_loc = NULL;
9183 variable_was_changed (new_var, NULL);
9186 /* Continue traversing the hash table. */
9187 return 1;
9190 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9191 NEW_SET. */
9193 static void
9194 emit_notes_for_differences (rtx_insn *insn, dataflow_set *old_set,
9195 dataflow_set *new_set)
9197 shared_hash_htab (old_set->vars)
9198 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9199 (shared_hash_htab (new_set->vars));
9200 shared_hash_htab (new_set->vars)
9201 ->traverse <variable_table_type *, emit_notes_for_differences_2>
9202 (shared_hash_htab (old_set->vars));
9203 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
9206 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9208 static rtx_insn *
9209 next_non_note_insn_var_location (rtx_insn *insn)
9211 while (insn)
9213 insn = NEXT_INSN (insn);
9214 if (insn == 0
9215 || !NOTE_P (insn)
9216 || NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION)
9217 break;
9220 return insn;
9223 /* Emit the notes for changes of location parts in the basic block BB. */
9225 static void
9226 emit_notes_in_bb (basic_block bb, dataflow_set *set)
9228 unsigned int i;
9229 micro_operation *mo;
9231 dataflow_set_clear (set);
9232 dataflow_set_copy (set, &VTI (bb)->in);
9234 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
9236 rtx_insn *insn = mo->insn;
9237 rtx_insn *next_insn = next_non_note_insn_var_location (insn);
9239 switch (mo->type)
9241 case MO_CALL:
9242 dataflow_set_clear_at_call (set, insn);
9243 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
9245 rtx arguments = mo->u.loc, *p = &arguments;
9246 while (*p)
9248 XEXP (XEXP (*p, 0), 1)
9249 = vt_expand_loc (XEXP (XEXP (*p, 0), 1),
9250 shared_hash_htab (set->vars));
9251 /* If expansion is successful, keep it in the list. */
9252 if (XEXP (XEXP (*p, 0), 1))
9254 XEXP (XEXP (*p, 0), 1)
9255 = copy_rtx_if_shared (XEXP (XEXP (*p, 0), 1));
9256 p = &XEXP (*p, 1);
9258 /* Otherwise, if the following item is data_value for it,
9259 drop it too too. */
9260 else if (XEXP (*p, 1)
9261 && REG_P (XEXP (XEXP (*p, 0), 0))
9262 && MEM_P (XEXP (XEXP (XEXP (*p, 1), 0), 0))
9263 && REG_P (XEXP (XEXP (XEXP (XEXP (*p, 1), 0), 0),
9265 && REGNO (XEXP (XEXP (*p, 0), 0))
9266 == REGNO (XEXP (XEXP (XEXP (XEXP (*p, 1), 0),
9267 0), 0)))
9268 *p = XEXP (XEXP (*p, 1), 1);
9269 /* Just drop this item. */
9270 else
9271 *p = XEXP (*p, 1);
9273 add_reg_note (insn, REG_CALL_ARG_LOCATION, arguments);
9275 break;
9277 case MO_USE:
9279 rtx loc = mo->u.loc;
9281 if (REG_P (loc))
9282 var_reg_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9283 else
9284 var_mem_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9286 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9288 break;
9290 case MO_VAL_LOC:
9292 rtx loc = mo->u.loc;
9293 rtx val, vloc;
9294 tree var;
9296 if (GET_CODE (loc) == CONCAT)
9298 val = XEXP (loc, 0);
9299 vloc = XEXP (loc, 1);
9301 else
9303 val = NULL_RTX;
9304 vloc = loc;
9307 var = PAT_VAR_LOCATION_DECL (vloc);
9309 clobber_variable_part (set, NULL_RTX,
9310 dv_from_decl (var), 0, NULL_RTX);
9311 if (val)
9313 if (VAL_NEEDS_RESOLUTION (loc))
9314 val_resolve (set, val, PAT_VAR_LOCATION_LOC (vloc), insn);
9315 set_variable_part (set, val, dv_from_decl (var), 0,
9316 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9317 INSERT);
9319 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
9320 set_variable_part (set, PAT_VAR_LOCATION_LOC (vloc),
9321 dv_from_decl (var), 0,
9322 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9323 INSERT);
9325 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9327 break;
9329 case MO_VAL_USE:
9331 rtx loc = mo->u.loc;
9332 rtx val, vloc, uloc;
9334 vloc = uloc = XEXP (loc, 1);
9335 val = XEXP (loc, 0);
9337 if (GET_CODE (val) == CONCAT)
9339 uloc = XEXP (val, 1);
9340 val = XEXP (val, 0);
9343 if (VAL_NEEDS_RESOLUTION (loc))
9344 val_resolve (set, val, vloc, insn);
9345 else
9346 val_store (set, val, uloc, insn, false);
9348 if (VAL_HOLDS_TRACK_EXPR (loc))
9350 if (GET_CODE (uloc) == REG)
9351 var_reg_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9352 NULL);
9353 else if (GET_CODE (uloc) == MEM)
9354 var_mem_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9355 NULL);
9358 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9360 break;
9362 case MO_VAL_SET:
9364 rtx loc = mo->u.loc;
9365 rtx val, vloc, uloc;
9366 rtx dstv, srcv;
9368 vloc = loc;
9369 uloc = XEXP (vloc, 1);
9370 val = XEXP (vloc, 0);
9371 vloc = uloc;
9373 if (GET_CODE (uloc) == SET)
9375 dstv = SET_DEST (uloc);
9376 srcv = SET_SRC (uloc);
9378 else
9380 dstv = uloc;
9381 srcv = NULL;
9384 if (GET_CODE (val) == CONCAT)
9386 dstv = vloc = XEXP (val, 1);
9387 val = XEXP (val, 0);
9390 if (GET_CODE (vloc) == SET)
9392 srcv = SET_SRC (vloc);
9394 gcc_assert (val != srcv);
9395 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
9397 dstv = vloc = SET_DEST (vloc);
9399 if (VAL_NEEDS_RESOLUTION (loc))
9400 val_resolve (set, val, srcv, insn);
9402 else if (VAL_NEEDS_RESOLUTION (loc))
9404 gcc_assert (GET_CODE (uloc) == SET
9405 && GET_CODE (SET_SRC (uloc)) == REG);
9406 val_resolve (set, val, SET_SRC (uloc), insn);
9409 if (VAL_HOLDS_TRACK_EXPR (loc))
9411 if (VAL_EXPR_IS_CLOBBERED (loc))
9413 if (REG_P (uloc))
9414 var_reg_delete (set, uloc, true);
9415 else if (MEM_P (uloc))
9417 gcc_assert (MEM_P (dstv));
9418 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
9419 var_mem_delete (set, dstv, true);
9422 else
9424 bool copied_p = VAL_EXPR_IS_COPIED (loc);
9425 rtx src = NULL, dst = uloc;
9426 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
9428 if (GET_CODE (uloc) == SET)
9430 src = SET_SRC (uloc);
9431 dst = SET_DEST (uloc);
9434 if (copied_p)
9436 status = find_src_status (set, src);
9438 src = find_src_set_src (set, src);
9441 if (REG_P (dst))
9442 var_reg_delete_and_set (set, dst, !copied_p,
9443 status, srcv);
9444 else if (MEM_P (dst))
9446 gcc_assert (MEM_P (dstv));
9447 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
9448 var_mem_delete_and_set (set, dstv, !copied_p,
9449 status, srcv);
9453 else if (REG_P (uloc))
9454 var_regno_delete (set, REGNO (uloc));
9455 else if (MEM_P (uloc))
9457 gcc_checking_assert (GET_CODE (vloc) == MEM);
9458 gcc_checking_assert (vloc == dstv);
9459 if (vloc != dstv)
9460 clobber_overlapping_mems (set, vloc);
9463 val_store (set, val, dstv, insn, true);
9465 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9466 set->vars);
9468 break;
9470 case MO_SET:
9472 rtx loc = mo->u.loc;
9473 rtx set_src = NULL;
9475 if (GET_CODE (loc) == SET)
9477 set_src = SET_SRC (loc);
9478 loc = SET_DEST (loc);
9481 if (REG_P (loc))
9482 var_reg_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9483 set_src);
9484 else
9485 var_mem_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9486 set_src);
9488 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9489 set->vars);
9491 break;
9493 case MO_COPY:
9495 rtx loc = mo->u.loc;
9496 enum var_init_status src_status;
9497 rtx set_src = NULL;
9499 if (GET_CODE (loc) == SET)
9501 set_src = SET_SRC (loc);
9502 loc = SET_DEST (loc);
9505 src_status = find_src_status (set, set_src);
9506 set_src = find_src_set_src (set, set_src);
9508 if (REG_P (loc))
9509 var_reg_delete_and_set (set, loc, false, src_status, set_src);
9510 else
9511 var_mem_delete_and_set (set, loc, false, src_status, set_src);
9513 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9514 set->vars);
9516 break;
9518 case MO_USE_NO_VAR:
9520 rtx loc = mo->u.loc;
9522 if (REG_P (loc))
9523 var_reg_delete (set, loc, false);
9524 else
9525 var_mem_delete (set, loc, false);
9527 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9529 break;
9531 case MO_CLOBBER:
9533 rtx loc = mo->u.loc;
9535 if (REG_P (loc))
9536 var_reg_delete (set, loc, true);
9537 else
9538 var_mem_delete (set, loc, true);
9540 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9541 set->vars);
9543 break;
9545 case MO_ADJUST:
9546 set->stack_adjust += mo->u.adjust;
9547 break;
9552 /* Emit notes for the whole function. */
9554 static void
9555 vt_emit_notes (void)
9557 basic_block bb;
9558 dataflow_set cur;
9560 gcc_assert (changed_variables->is_empty ());
9562 /* Free memory occupied by the out hash tables, as they aren't used
9563 anymore. */
9564 FOR_EACH_BB_FN (bb, cfun)
9565 dataflow_set_clear (&VTI (bb)->out);
9567 /* Enable emitting notes by functions (mainly by set_variable_part and
9568 delete_variable_part). */
9569 emit_notes = true;
9571 if (MAY_HAVE_DEBUG_BIND_INSNS)
9572 dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
9574 dataflow_set_init (&cur);
9576 FOR_EACH_BB_FN (bb, cfun)
9578 /* Emit the notes for changes of variable locations between two
9579 subsequent basic blocks. */
9580 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
9582 if (MAY_HAVE_DEBUG_BIND_INSNS)
9583 local_get_addr_cache = new hash_map<rtx, rtx>;
9585 /* Emit the notes for the changes in the basic block itself. */
9586 emit_notes_in_bb (bb, &cur);
9588 if (MAY_HAVE_DEBUG_BIND_INSNS)
9589 delete local_get_addr_cache;
9590 local_get_addr_cache = NULL;
9592 /* Free memory occupied by the in hash table, we won't need it
9593 again. */
9594 dataflow_set_clear (&VTI (bb)->in);
9597 if (flag_checking)
9598 shared_hash_htab (cur.vars)
9599 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9600 (shared_hash_htab (empty_shared_hash));
9602 dataflow_set_destroy (&cur);
9604 if (MAY_HAVE_DEBUG_BIND_INSNS)
9605 delete dropped_values;
9606 dropped_values = NULL;
9608 emit_notes = false;
9611 /* If there is a declaration and offset associated with register/memory RTL
9612 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9614 static bool
9615 vt_get_decl_and_offset (rtx rtl, tree *declp, poly_int64 *offsetp)
9617 if (REG_P (rtl))
9619 if (REG_ATTRS (rtl))
9621 *declp = REG_EXPR (rtl);
9622 *offsetp = REG_OFFSET (rtl);
9623 return true;
9626 else if (GET_CODE (rtl) == PARALLEL)
9628 tree decl = NULL_TREE;
9629 HOST_WIDE_INT offset = MAX_VAR_PARTS;
9630 int len = XVECLEN (rtl, 0), i;
9632 for (i = 0; i < len; i++)
9634 rtx reg = XEXP (XVECEXP (rtl, 0, i), 0);
9635 if (!REG_P (reg) || !REG_ATTRS (reg))
9636 break;
9637 if (!decl)
9638 decl = REG_EXPR (reg);
9639 if (REG_EXPR (reg) != decl)
9640 break;
9641 HOST_WIDE_INT this_offset;
9642 if (!track_offset_p (REG_OFFSET (reg), &this_offset))
9643 break;
9644 offset = MIN (offset, this_offset);
9647 if (i == len)
9649 *declp = decl;
9650 *offsetp = offset;
9651 return true;
9654 else if (MEM_P (rtl))
9656 if (MEM_ATTRS (rtl))
9658 *declp = MEM_EXPR (rtl);
9659 *offsetp = int_mem_offset (rtl);
9660 return true;
9663 return false;
9666 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9667 of VAL. */
9669 static void
9670 record_entry_value (cselib_val *val, rtx rtl)
9672 rtx ev = gen_rtx_ENTRY_VALUE (GET_MODE (rtl));
9674 ENTRY_VALUE_EXP (ev) = rtl;
9676 cselib_add_permanent_equiv (val, ev, get_insns ());
9679 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9681 static void
9682 vt_add_function_parameter (tree parm)
9684 rtx decl_rtl = DECL_RTL_IF_SET (parm);
9685 rtx incoming = DECL_INCOMING_RTL (parm);
9686 tree decl;
9687 machine_mode mode;
9688 poly_int64 offset;
9689 dataflow_set *out;
9690 decl_or_value dv;
9691 bool incoming_ok = true;
9693 if (TREE_CODE (parm) != PARM_DECL)
9694 return;
9696 if (!decl_rtl || !incoming)
9697 return;
9699 if (GET_MODE (decl_rtl) == BLKmode || GET_MODE (incoming) == BLKmode)
9700 return;
9702 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9703 rewrite the incoming location of parameters passed on the stack
9704 into MEMs based on the argument pointer, so that incoming doesn't
9705 depend on a pseudo. */
9706 poly_int64 incoming_offset = 0;
9707 if (MEM_P (incoming)
9708 && (strip_offset (XEXP (incoming, 0), &incoming_offset)
9709 == crtl->args.internal_arg_pointer))
9711 HOST_WIDE_INT off = -FIRST_PARM_OFFSET (current_function_decl);
9712 incoming
9713 = replace_equiv_address_nv (incoming,
9714 plus_constant (Pmode,
9715 arg_pointer_rtx,
9716 off + incoming_offset));
9719 #ifdef HAVE_window_save
9720 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9721 If the target machine has an explicit window save instruction, the
9722 actual entry value is the corresponding OUTGOING_REGNO instead. */
9723 if (HAVE_window_save && !crtl->uses_only_leaf_regs)
9725 if (REG_P (incoming)
9726 && HARD_REGISTER_P (incoming)
9727 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
9729 parm_reg p;
9730 p.incoming = incoming;
9731 incoming
9732 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
9733 OUTGOING_REGNO (REGNO (incoming)), 0);
9734 p.outgoing = incoming;
9735 vec_safe_push (windowed_parm_regs, p);
9737 else if (GET_CODE (incoming) == PARALLEL)
9739 rtx outgoing
9740 = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (XVECLEN (incoming, 0)));
9741 int i;
9743 for (i = 0; i < XVECLEN (incoming, 0); i++)
9745 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9746 parm_reg p;
9747 p.incoming = reg;
9748 reg = gen_rtx_REG_offset (reg, GET_MODE (reg),
9749 OUTGOING_REGNO (REGNO (reg)), 0);
9750 p.outgoing = reg;
9751 XVECEXP (outgoing, 0, i)
9752 = gen_rtx_EXPR_LIST (VOIDmode, reg,
9753 XEXP (XVECEXP (incoming, 0, i), 1));
9754 vec_safe_push (windowed_parm_regs, p);
9757 incoming = outgoing;
9759 else if (MEM_P (incoming)
9760 && REG_P (XEXP (incoming, 0))
9761 && HARD_REGISTER_P (XEXP (incoming, 0)))
9763 rtx reg = XEXP (incoming, 0);
9764 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
9766 parm_reg p;
9767 p.incoming = reg;
9768 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
9769 p.outgoing = reg;
9770 vec_safe_push (windowed_parm_regs, p);
9771 incoming = replace_equiv_address_nv (incoming, reg);
9775 #endif
9777 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
9779 incoming_ok = false;
9780 if (MEM_P (incoming))
9782 /* This means argument is passed by invisible reference. */
9783 offset = 0;
9784 decl = parm;
9786 else
9788 if (!vt_get_decl_and_offset (decl_rtl, &decl, &offset))
9789 return;
9790 offset += byte_lowpart_offset (GET_MODE (incoming),
9791 GET_MODE (decl_rtl));
9795 if (!decl)
9796 return;
9798 if (parm != decl)
9800 /* If that DECL_RTL wasn't a pseudo that got spilled to
9801 memory, bail out. Otherwise, the spill slot sharing code
9802 will force the memory to reference spill_slot_decl (%sfp),
9803 so we don't match above. That's ok, the pseudo must have
9804 referenced the entire parameter, so just reset OFFSET. */
9805 if (decl != get_spill_slot_decl (false))
9806 return;
9807 offset = 0;
9810 HOST_WIDE_INT const_offset;
9811 if (!track_loc_p (incoming, parm, offset, false, &mode, &const_offset))
9812 return;
9814 out = &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out;
9816 dv = dv_from_decl (parm);
9818 if (target_for_debug_bind (parm)
9819 /* We can't deal with these right now, because this kind of
9820 variable is single-part. ??? We could handle parallels
9821 that describe multiple locations for the same single
9822 value, but ATM we don't. */
9823 && GET_CODE (incoming) != PARALLEL)
9825 cselib_val *val;
9826 rtx lowpart;
9828 /* ??? We shouldn't ever hit this, but it may happen because
9829 arguments passed by invisible reference aren't dealt with
9830 above: incoming-rtl will have Pmode rather than the
9831 expected mode for the type. */
9832 if (const_offset)
9833 return;
9835 lowpart = var_lowpart (mode, incoming);
9836 if (!lowpart)
9837 return;
9839 val = cselib_lookup_from_insn (lowpart, mode, true,
9840 VOIDmode, get_insns ());
9842 /* ??? Float-typed values in memory are not handled by
9843 cselib. */
9844 if (val)
9846 preserve_value (val);
9847 set_variable_part (out, val->val_rtx, dv, const_offset,
9848 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9849 dv = dv_from_value (val->val_rtx);
9852 if (MEM_P (incoming))
9854 val = cselib_lookup_from_insn (XEXP (incoming, 0), mode, true,
9855 VOIDmode, get_insns ());
9856 if (val)
9858 preserve_value (val);
9859 incoming = replace_equiv_address_nv (incoming, val->val_rtx);
9864 if (REG_P (incoming))
9866 incoming = var_lowpart (mode, incoming);
9867 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
9868 attrs_list_insert (&out->regs[REGNO (incoming)], dv, const_offset,
9869 incoming);
9870 set_variable_part (out, incoming, dv, const_offset,
9871 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9872 if (dv_is_value_p (dv))
9874 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv)), incoming);
9875 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
9876 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm))))
9878 machine_mode indmode
9879 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm)));
9880 rtx mem = gen_rtx_MEM (indmode, incoming);
9881 cselib_val *val = cselib_lookup_from_insn (mem, indmode, true,
9882 VOIDmode,
9883 get_insns ());
9884 if (val)
9886 preserve_value (val);
9887 record_entry_value (val, mem);
9888 set_variable_part (out, mem, dv_from_value (val->val_rtx), 0,
9889 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9893 if (GET_MODE_CLASS (mode) == MODE_INT)
9895 machine_mode wider_mode_iter;
9896 FOR_EACH_WIDER_MODE (wider_mode_iter, mode)
9898 if (!HWI_COMPUTABLE_MODE_P (wider_mode_iter))
9899 break;
9900 rtx wider_reg
9901 = gen_rtx_REG (wider_mode_iter, REGNO (incoming));
9902 cselib_val *wider_val
9903 = cselib_lookup_from_insn (wider_reg, wider_mode_iter, 1,
9904 VOIDmode, get_insns ());
9905 preserve_value (wider_val);
9906 record_entry_value (wider_val, wider_reg);
9911 else if (GET_CODE (incoming) == PARALLEL && !dv_onepart_p (dv))
9913 int i;
9915 /* The following code relies on vt_get_decl_and_offset returning true for
9916 incoming, which might not be always the case. */
9917 if (!incoming_ok)
9918 return;
9919 for (i = 0; i < XVECLEN (incoming, 0); i++)
9921 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9922 /* vt_get_decl_and_offset has already checked that the offset
9923 is a valid variable part. */
9924 const_offset = get_tracked_reg_offset (reg);
9925 gcc_assert (REGNO (reg) < FIRST_PSEUDO_REGISTER);
9926 attrs_list_insert (&out->regs[REGNO (reg)], dv, const_offset, reg);
9927 set_variable_part (out, reg, dv, const_offset,
9928 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9931 else if (MEM_P (incoming))
9933 incoming = var_lowpart (mode, incoming);
9934 set_variable_part (out, incoming, dv, const_offset,
9935 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9939 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9941 static void
9942 vt_add_function_parameters (void)
9944 tree parm;
9946 for (parm = DECL_ARGUMENTS (current_function_decl);
9947 parm; parm = DECL_CHAIN (parm))
9948 vt_add_function_parameter (parm);
9950 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl)))
9952 tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
9954 if (INDIRECT_REF_P (vexpr))
9955 vexpr = TREE_OPERAND (vexpr, 0);
9957 if (TREE_CODE (vexpr) == PARM_DECL
9958 && DECL_ARTIFICIAL (vexpr)
9959 && !DECL_IGNORED_P (vexpr)
9960 && DECL_NAMELESS (vexpr))
9961 vt_add_function_parameter (vexpr);
9965 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9966 ensure it isn't flushed during cselib_reset_table.
9967 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9968 has been eliminated. */
9970 static void
9971 vt_init_cfa_base (void)
9973 cselib_val *val;
9975 #ifdef FRAME_POINTER_CFA_OFFSET
9976 cfa_base_rtx = frame_pointer_rtx;
9977 cfa_base_offset = -FRAME_POINTER_CFA_OFFSET (current_function_decl);
9978 #else
9979 cfa_base_rtx = arg_pointer_rtx;
9980 cfa_base_offset = -ARG_POINTER_CFA_OFFSET (current_function_decl);
9981 #endif
9982 if (cfa_base_rtx == hard_frame_pointer_rtx
9983 || !fixed_regs[REGNO (cfa_base_rtx)])
9985 cfa_base_rtx = NULL_RTX;
9986 return;
9988 if (!MAY_HAVE_DEBUG_BIND_INSNS)
9989 return;
9991 /* Tell alias analysis that cfa_base_rtx should share
9992 find_base_term value with stack pointer or hard frame pointer. */
9993 if (!frame_pointer_needed)
9994 vt_equate_reg_base_value (cfa_base_rtx, stack_pointer_rtx);
9995 else if (!crtl->stack_realign_tried)
9996 vt_equate_reg_base_value (cfa_base_rtx, hard_frame_pointer_rtx);
9998 val = cselib_lookup_from_insn (cfa_base_rtx, GET_MODE (cfa_base_rtx), 1,
9999 VOIDmode, get_insns ());
10000 preserve_value (val);
10001 cselib_preserve_cfa_base_value (val, REGNO (cfa_base_rtx));
10004 /* Reemit INSN, a MARKER_DEBUG_INSN, as a note. */
10006 static rtx_insn *
10007 reemit_marker_as_note (rtx_insn *insn)
10009 gcc_checking_assert (DEBUG_MARKER_INSN_P (insn));
10011 enum insn_note kind = INSN_DEBUG_MARKER_KIND (insn);
10013 switch (kind)
10015 case NOTE_INSN_BEGIN_STMT:
10016 case NOTE_INSN_INLINE_ENTRY:
10018 rtx_insn *note = NULL;
10019 if (cfun->debug_nonbind_markers)
10021 note = emit_note_before (kind, insn);
10022 NOTE_MARKER_LOCATION (note) = INSN_LOCATION (insn);
10024 delete_insn (insn);
10025 return note;
10028 default:
10029 gcc_unreachable ();
10033 /* Allocate and initialize the data structures for variable tracking
10034 and parse the RTL to get the micro operations. */
10036 static bool
10037 vt_initialize (void)
10039 basic_block bb;
10040 poly_int64 fp_cfa_offset = -1;
10042 alloc_aux_for_blocks (sizeof (variable_tracking_info));
10044 empty_shared_hash = shared_hash_pool.allocate ();
10045 empty_shared_hash->refcount = 1;
10046 empty_shared_hash->htab = new variable_table_type (1);
10047 changed_variables = new variable_table_type (10);
10049 /* Init the IN and OUT sets. */
10050 FOR_ALL_BB_FN (bb, cfun)
10052 VTI (bb)->visited = false;
10053 VTI (bb)->flooded = false;
10054 dataflow_set_init (&VTI (bb)->in);
10055 dataflow_set_init (&VTI (bb)->out);
10056 VTI (bb)->permp = NULL;
10059 if (MAY_HAVE_DEBUG_BIND_INSNS)
10061 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
10062 scratch_regs = BITMAP_ALLOC (NULL);
10063 preserved_values.create (256);
10064 global_get_addr_cache = new hash_map<rtx, rtx>;
10066 else
10068 scratch_regs = NULL;
10069 global_get_addr_cache = NULL;
10072 if (MAY_HAVE_DEBUG_BIND_INSNS)
10074 rtx reg, expr;
10075 int ofst;
10076 cselib_val *val;
10078 #ifdef FRAME_POINTER_CFA_OFFSET
10079 reg = frame_pointer_rtx;
10080 ofst = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10081 #else
10082 reg = arg_pointer_rtx;
10083 ofst = ARG_POINTER_CFA_OFFSET (current_function_decl);
10084 #endif
10086 ofst -= INCOMING_FRAME_SP_OFFSET;
10088 val = cselib_lookup_from_insn (reg, GET_MODE (reg), 1,
10089 VOIDmode, get_insns ());
10090 preserve_value (val);
10091 if (reg != hard_frame_pointer_rtx && fixed_regs[REGNO (reg)])
10092 cselib_preserve_cfa_base_value (val, REGNO (reg));
10093 if (ofst)
10095 cselib_val *valsp
10096 = cselib_lookup_from_insn (stack_pointer_rtx,
10097 GET_MODE (stack_pointer_rtx), 1,
10098 VOIDmode, get_insns ());
10099 preserve_value (valsp);
10100 expr = plus_constant (GET_MODE (reg), reg, ofst);
10101 /* This cselib_add_permanent_equiv call needs to be done before
10102 the other cselib_add_permanent_equiv a few lines later,
10103 because after that one is done, cselib_lookup on this expr
10104 will due to the cselib SP_DERIVED_VALUE_P optimizations
10105 return valsp and so no permanent equivalency will be added. */
10106 cselib_add_permanent_equiv (valsp, expr, get_insns ());
10109 expr = plus_constant (GET_MODE (stack_pointer_rtx),
10110 stack_pointer_rtx, -ofst);
10111 cselib_add_permanent_equiv (val, expr, get_insns ());
10114 /* In order to factor out the adjustments made to the stack pointer or to
10115 the hard frame pointer and thus be able to use DW_OP_fbreg operations
10116 instead of individual location lists, we're going to rewrite MEMs based
10117 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
10118 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
10119 resp. arg_pointer_rtx. We can do this either when there is no frame
10120 pointer in the function and stack adjustments are consistent for all
10121 basic blocks or when there is a frame pointer and no stack realignment.
10122 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
10123 has been eliminated. */
10124 if (!frame_pointer_needed)
10126 rtx reg, elim;
10128 if (!vt_stack_adjustments ())
10129 return false;
10131 #ifdef FRAME_POINTER_CFA_OFFSET
10132 reg = frame_pointer_rtx;
10133 #else
10134 reg = arg_pointer_rtx;
10135 #endif
10136 elim = (ira_use_lra_p
10137 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
10138 : eliminate_regs (reg, VOIDmode, NULL_RTX));
10139 if (elim != reg)
10141 if (GET_CODE (elim) == PLUS)
10142 elim = XEXP (elim, 0);
10143 if (elim == stack_pointer_rtx)
10144 vt_init_cfa_base ();
10147 else if (!crtl->stack_realign_tried)
10149 rtx reg, elim;
10151 #ifdef FRAME_POINTER_CFA_OFFSET
10152 reg = frame_pointer_rtx;
10153 fp_cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10154 #else
10155 reg = arg_pointer_rtx;
10156 fp_cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10157 #endif
10158 elim = (ira_use_lra_p
10159 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
10160 : eliminate_regs (reg, VOIDmode, NULL_RTX));
10161 if (elim != reg)
10163 if (GET_CODE (elim) == PLUS)
10165 fp_cfa_offset -= rtx_to_poly_int64 (XEXP (elim, 1));
10166 elim = XEXP (elim, 0);
10168 if (elim != hard_frame_pointer_rtx)
10169 fp_cfa_offset = -1;
10171 else
10172 fp_cfa_offset = -1;
10175 /* If the stack is realigned and a DRAP register is used, we're going to
10176 rewrite MEMs based on it representing incoming locations of parameters
10177 passed on the stack into MEMs based on the argument pointer. Although
10178 we aren't going to rewrite other MEMs, we still need to initialize the
10179 virtual CFA pointer in order to ensure that the argument pointer will
10180 be seen as a constant throughout the function.
10182 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10183 else if (stack_realign_drap)
10185 rtx reg, elim;
10187 #ifdef FRAME_POINTER_CFA_OFFSET
10188 reg = frame_pointer_rtx;
10189 #else
10190 reg = arg_pointer_rtx;
10191 #endif
10192 elim = (ira_use_lra_p
10193 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
10194 : eliminate_regs (reg, VOIDmode, NULL_RTX));
10195 if (elim != reg)
10197 if (GET_CODE (elim) == PLUS)
10198 elim = XEXP (elim, 0);
10199 if (elim == hard_frame_pointer_rtx)
10200 vt_init_cfa_base ();
10204 hard_frame_pointer_adjustment = -1;
10206 vt_add_function_parameters ();
10208 bool record_sp_value = false;
10209 FOR_EACH_BB_FN (bb, cfun)
10211 rtx_insn *insn;
10212 basic_block first_bb, last_bb;
10214 if (MAY_HAVE_DEBUG_BIND_INSNS)
10216 cselib_record_sets_hook = add_with_sets;
10217 if (dump_file && (dump_flags & TDF_DETAILS))
10218 fprintf (dump_file, "first value: %i\n",
10219 cselib_get_next_uid ());
10222 if (MAY_HAVE_DEBUG_BIND_INSNS
10223 && cfa_base_rtx
10224 && !frame_pointer_needed
10225 && record_sp_value)
10226 cselib_record_sp_cfa_base_equiv (-cfa_base_offset
10227 - VTI (bb)->in.stack_adjust,
10228 BB_HEAD (bb));
10229 record_sp_value = true;
10231 first_bb = bb;
10232 for (;;)
10234 edge e;
10235 if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
10236 || ! single_pred_p (bb->next_bb))
10237 break;
10238 e = find_edge (bb, bb->next_bb);
10239 if (! e || (e->flags & EDGE_FALLTHRU) == 0)
10240 break;
10241 bb = bb->next_bb;
10243 last_bb = bb;
10245 /* Add the micro-operations to the vector. */
10246 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
10248 HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
10249 VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
10251 rtx_insn *next;
10252 FOR_BB_INSNS_SAFE (bb, insn, next)
10254 if (INSN_P (insn))
10256 HOST_WIDE_INT pre = 0, post = 0;
10258 if (!frame_pointer_needed)
10260 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
10261 if (pre)
10263 micro_operation mo;
10264 mo.type = MO_ADJUST;
10265 mo.u.adjust = pre;
10266 mo.insn = insn;
10267 if (dump_file && (dump_flags & TDF_DETAILS))
10268 log_op_type (PATTERN (insn), bb, insn,
10269 MO_ADJUST, dump_file);
10270 VTI (bb)->mos.safe_push (mo);
10274 cselib_hook_called = false;
10275 adjust_insn (bb, insn);
10277 if (pre)
10278 VTI (bb)->out.stack_adjust += pre;
10280 if (DEBUG_MARKER_INSN_P (insn))
10282 reemit_marker_as_note (insn);
10283 continue;
10286 if (MAY_HAVE_DEBUG_BIND_INSNS)
10288 if (CALL_P (insn))
10289 prepare_call_arguments (bb, insn);
10290 cselib_process_insn (insn);
10291 if (dump_file && (dump_flags & TDF_DETAILS))
10293 if (dump_flags & TDF_SLIM)
10294 dump_insn_slim (dump_file, insn);
10295 else
10296 print_rtl_single (dump_file, insn);
10297 dump_cselib_table (dump_file);
10300 if (!cselib_hook_called)
10301 add_with_sets (insn, 0, 0);
10302 cancel_changes (0);
10304 if (post)
10306 micro_operation mo;
10307 mo.type = MO_ADJUST;
10308 mo.u.adjust = post;
10309 mo.insn = insn;
10310 if (dump_file && (dump_flags & TDF_DETAILS))
10311 log_op_type (PATTERN (insn), bb, insn,
10312 MO_ADJUST, dump_file);
10313 VTI (bb)->mos.safe_push (mo);
10314 VTI (bb)->out.stack_adjust += post;
10317 if (maybe_ne (fp_cfa_offset, -1)
10318 && known_eq (hard_frame_pointer_adjustment, -1)
10319 && fp_setter_insn (insn))
10321 vt_init_cfa_base ();
10322 hard_frame_pointer_adjustment = fp_cfa_offset;
10323 /* Disassociate sp from fp now. */
10324 if (MAY_HAVE_DEBUG_BIND_INSNS)
10326 cselib_val *v;
10327 cselib_invalidate_rtx (stack_pointer_rtx);
10328 v = cselib_lookup (stack_pointer_rtx, Pmode, 1,
10329 VOIDmode);
10330 if (v && !cselib_preserved_value_p (v))
10332 cselib_set_value_sp_based (v);
10333 preserve_value (v);
10339 gcc_assert (offset == VTI (bb)->out.stack_adjust);
10342 bb = last_bb;
10344 if (MAY_HAVE_DEBUG_BIND_INSNS)
10346 cselib_preserve_only_values ();
10347 cselib_reset_table (cselib_get_next_uid ());
10348 cselib_record_sets_hook = NULL;
10352 hard_frame_pointer_adjustment = -1;
10353 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flooded = true;
10354 cfa_base_rtx = NULL_RTX;
10355 return true;
10358 /* This is *not* reset after each function. It gives each
10359 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10360 a unique label number. */
10362 static int debug_label_num = 1;
10364 /* Remove from the insn stream a single debug insn used for
10365 variable tracking at assignments. */
10367 static inline void
10368 delete_vta_debug_insn (rtx_insn *insn)
10370 if (DEBUG_MARKER_INSN_P (insn))
10372 reemit_marker_as_note (insn);
10373 return;
10376 tree decl = INSN_VAR_LOCATION_DECL (insn);
10377 if (TREE_CODE (decl) == LABEL_DECL
10378 && DECL_NAME (decl)
10379 && !DECL_RTL_SET_P (decl))
10381 PUT_CODE (insn, NOTE);
10382 NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
10383 NOTE_DELETED_LABEL_NAME (insn)
10384 = IDENTIFIER_POINTER (DECL_NAME (decl));
10385 SET_DECL_RTL (decl, insn);
10386 CODE_LABEL_NUMBER (insn) = debug_label_num++;
10388 else
10389 delete_insn (insn);
10392 /* Remove from the insn stream all debug insns used for variable
10393 tracking at assignments. USE_CFG should be false if the cfg is no
10394 longer usable. */
10396 void
10397 delete_vta_debug_insns (bool use_cfg)
10399 basic_block bb;
10400 rtx_insn *insn, *next;
10402 if (!MAY_HAVE_DEBUG_INSNS)
10403 return;
10405 if (use_cfg)
10406 FOR_EACH_BB_FN (bb, cfun)
10408 FOR_BB_INSNS_SAFE (bb, insn, next)
10409 if (DEBUG_INSN_P (insn))
10410 delete_vta_debug_insn (insn);
10412 else
10413 for (insn = get_insns (); insn; insn = next)
10415 next = NEXT_INSN (insn);
10416 if (DEBUG_INSN_P (insn))
10417 delete_vta_debug_insn (insn);
10421 /* Run a fast, BB-local only version of var tracking, to take care of
10422 information that we don't do global analysis on, such that not all
10423 information is lost. If SKIPPED holds, we're skipping the global
10424 pass entirely, so we should try to use information it would have
10425 handled as well.. */
10427 static void
10428 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
10430 /* ??? Just skip it all for now. */
10431 delete_vta_debug_insns (true);
10434 /* Free the data structures needed for variable tracking. */
10436 static void
10437 vt_finalize (void)
10439 basic_block bb;
10441 FOR_EACH_BB_FN (bb, cfun)
10443 VTI (bb)->mos.release ();
10446 FOR_ALL_BB_FN (bb, cfun)
10448 dataflow_set_destroy (&VTI (bb)->in);
10449 dataflow_set_destroy (&VTI (bb)->out);
10450 if (VTI (bb)->permp)
10452 dataflow_set_destroy (VTI (bb)->permp);
10453 XDELETE (VTI (bb)->permp);
10456 free_aux_for_blocks ();
10457 delete empty_shared_hash->htab;
10458 empty_shared_hash->htab = NULL;
10459 delete changed_variables;
10460 changed_variables = NULL;
10461 attrs_pool.release ();
10462 var_pool.release ();
10463 location_chain_pool.release ();
10464 shared_hash_pool.release ();
10466 if (MAY_HAVE_DEBUG_BIND_INSNS)
10468 if (global_get_addr_cache)
10469 delete global_get_addr_cache;
10470 global_get_addr_cache = NULL;
10471 loc_exp_dep_pool.release ();
10472 valvar_pool.release ();
10473 preserved_values.release ();
10474 cselib_finish ();
10475 BITMAP_FREE (scratch_regs);
10476 scratch_regs = NULL;
10479 #ifdef HAVE_window_save
10480 vec_free (windowed_parm_regs);
10481 #endif
10483 if (vui_vec)
10484 XDELETEVEC (vui_vec);
10485 vui_vec = NULL;
10486 vui_allocated = 0;
10489 /* The entry point to variable tracking pass. */
10491 static inline unsigned int
10492 variable_tracking_main_1 (void)
10494 bool success;
10496 /* We won't be called as a separate pass if flag_var_tracking is not
10497 set, but final may call us to turn debug markers into notes. */
10498 if ((!flag_var_tracking && MAY_HAVE_DEBUG_INSNS)
10499 || flag_var_tracking_assignments < 0
10500 /* Var-tracking right now assumes the IR doesn't contain
10501 any pseudos at this point. */
10502 || targetm.no_register_allocation)
10504 delete_vta_debug_insns (true);
10505 return 0;
10508 if (!flag_var_tracking)
10509 return 0;
10511 if (n_basic_blocks_for_fn (cfun) > 500
10512 && n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
10514 vt_debug_insns_local (true);
10515 return 0;
10518 if (!vt_initialize ())
10520 vt_finalize ();
10521 vt_debug_insns_local (true);
10522 return 0;
10525 success = vt_find_locations ();
10527 if (!success && flag_var_tracking_assignments > 0)
10529 vt_finalize ();
10531 delete_vta_debug_insns (true);
10533 /* This is later restored by our caller. */
10534 flag_var_tracking_assignments = 0;
10536 success = vt_initialize ();
10537 gcc_assert (success);
10539 success = vt_find_locations ();
10542 if (!success)
10544 vt_finalize ();
10545 vt_debug_insns_local (false);
10546 return 0;
10549 if (dump_file && (dump_flags & TDF_DETAILS))
10551 dump_dataflow_sets ();
10552 dump_reg_info (dump_file);
10553 dump_flow_info (dump_file, dump_flags);
10556 timevar_push (TV_VAR_TRACKING_EMIT);
10557 vt_emit_notes ();
10558 timevar_pop (TV_VAR_TRACKING_EMIT);
10560 vt_finalize ();
10561 vt_debug_insns_local (false);
10562 return 0;
10565 unsigned int
10566 variable_tracking_main (void)
10568 unsigned int ret;
10569 int save = flag_var_tracking_assignments;
10571 ret = variable_tracking_main_1 ();
10573 flag_var_tracking_assignments = save;
10575 return ret;
10578 namespace {
10580 const pass_data pass_data_variable_tracking =
10582 RTL_PASS, /* type */
10583 "vartrack", /* name */
10584 OPTGROUP_NONE, /* optinfo_flags */
10585 TV_VAR_TRACKING, /* tv_id */
10586 0, /* properties_required */
10587 0, /* properties_provided */
10588 0, /* properties_destroyed */
10589 0, /* todo_flags_start */
10590 0, /* todo_flags_finish */
10593 class pass_variable_tracking : public rtl_opt_pass
10595 public:
10596 pass_variable_tracking (gcc::context *ctxt)
10597 : rtl_opt_pass (pass_data_variable_tracking, ctxt)
10600 /* opt_pass methods: */
10601 bool gate (function *) final override
10603 return (flag_var_tracking && !targetm.delay_vartrack);
10606 unsigned int execute (function *) final override
10608 return variable_tracking_main ();
10611 }; // class pass_variable_tracking
10613 } // anon namespace
10615 rtl_opt_pass *
10616 make_pass_variable_tracking (gcc::context *ctxt)
10618 return new pass_variable_tracking (ctxt);