poly_int: expand_vector_ubsan_overflow
[official-gcc.git] / gcc / var-tracking.c
blob77281fb45ee228e8cb802bcf61aff989c9b2c580
1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2017 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 "calls.h"
111 #include "tree-dfa.h"
112 #include "tree-ssa.h"
113 #include "cselib.h"
114 #include "params.h"
115 #include "tree-pretty-print.h"
116 #include "rtl-iter.h"
117 #include "fibonacci_heap.h"
119 typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
120 typedef fibonacci_node <long, basic_block_def> bb_heap_node_t;
122 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
123 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
124 Currently the value is the same as IDENTIFIER_NODE, which has such
125 a property. If this compile time assertion ever fails, make sure that
126 the new tree code that equals (int) VALUE has the same property. */
127 extern char check_value_val[(int) VALUE == (int) IDENTIFIER_NODE ? 1 : -1];
129 /* Type of micro operation. */
130 enum micro_operation_type
132 MO_USE, /* Use location (REG or MEM). */
133 MO_USE_NO_VAR,/* Use location which is not associated with a variable
134 or the variable is not trackable. */
135 MO_VAL_USE, /* Use location which is associated with a value. */
136 MO_VAL_LOC, /* Use location which appears in a debug insn. */
137 MO_VAL_SET, /* Set location associated with a value. */
138 MO_SET, /* Set location. */
139 MO_COPY, /* Copy the same portion of a variable from one
140 location to another. */
141 MO_CLOBBER, /* Clobber location. */
142 MO_CALL, /* Call insn. */
143 MO_ADJUST /* Adjust stack pointer. */
147 static const char * const ATTRIBUTE_UNUSED
148 micro_operation_type_name[] = {
149 "MO_USE",
150 "MO_USE_NO_VAR",
151 "MO_VAL_USE",
152 "MO_VAL_LOC",
153 "MO_VAL_SET",
154 "MO_SET",
155 "MO_COPY",
156 "MO_CLOBBER",
157 "MO_CALL",
158 "MO_ADJUST"
161 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
162 Notes emitted as AFTER_CALL are to take effect during the call,
163 rather than after the call. */
164 enum emit_note_where
166 EMIT_NOTE_BEFORE_INSN,
167 EMIT_NOTE_AFTER_INSN,
168 EMIT_NOTE_AFTER_CALL_INSN
171 /* Structure holding information about micro operation. */
172 struct micro_operation
174 /* Type of micro operation. */
175 enum micro_operation_type type;
177 /* The instruction which the micro operation is in, for MO_USE,
178 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
179 instruction or note in the original flow (before any var-tracking
180 notes are inserted, to simplify emission of notes), for MO_SET
181 and MO_CLOBBER. */
182 rtx_insn *insn;
184 union {
185 /* Location. For MO_SET and MO_COPY, this is the SET that
186 performs the assignment, if known, otherwise it is the target
187 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
188 CONCAT of the VALUE and the LOC associated with it. For
189 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
190 associated with it. */
191 rtx loc;
193 /* Stack adjustment. */
194 HOST_WIDE_INT adjust;
195 } u;
199 /* A declaration of a variable, or an RTL value being handled like a
200 declaration. */
201 typedef void *decl_or_value;
203 /* Return true if a decl_or_value DV is a DECL or NULL. */
204 static inline bool
205 dv_is_decl_p (decl_or_value dv)
207 return !dv || (int) TREE_CODE ((tree) dv) != (int) VALUE;
210 /* Return true if a decl_or_value is a VALUE rtl. */
211 static inline bool
212 dv_is_value_p (decl_or_value dv)
214 return dv && !dv_is_decl_p (dv);
217 /* Return the decl in the decl_or_value. */
218 static inline tree
219 dv_as_decl (decl_or_value dv)
221 gcc_checking_assert (dv_is_decl_p (dv));
222 return (tree) dv;
225 /* Return the value in the decl_or_value. */
226 static inline rtx
227 dv_as_value (decl_or_value dv)
229 gcc_checking_assert (dv_is_value_p (dv));
230 return (rtx)dv;
233 /* Return the opaque pointer in the decl_or_value. */
234 static inline void *
235 dv_as_opaque (decl_or_value dv)
237 return dv;
241 /* Description of location of a part of a variable. The content of a physical
242 register is described by a chain of these structures.
243 The chains are pretty short (usually 1 or 2 elements) and thus
244 chain is the best data structure. */
245 struct attrs
247 /* Pointer to next member of the list. */
248 attrs *next;
250 /* The rtx of register. */
251 rtx loc;
253 /* The declaration corresponding to LOC. */
254 decl_or_value dv;
256 /* Offset from start of DECL. */
257 HOST_WIDE_INT offset;
260 /* Structure for chaining the locations. */
261 struct location_chain
263 /* Next element in the chain. */
264 location_chain *next;
266 /* The location (REG, MEM or VALUE). */
267 rtx loc;
269 /* The "value" stored in this location. */
270 rtx set_src;
272 /* Initialized? */
273 enum var_init_status init;
276 /* A vector of loc_exp_dep holds the active dependencies of a one-part
277 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
278 location of DV. Each entry is also part of VALUE' s linked-list of
279 backlinks back to DV. */
280 struct loc_exp_dep
282 /* The dependent DV. */
283 decl_or_value dv;
284 /* The dependency VALUE or DECL_DEBUG. */
285 rtx value;
286 /* The next entry in VALUE's backlinks list. */
287 struct loc_exp_dep *next;
288 /* A pointer to the pointer to this entry (head or prev's next) in
289 the doubly-linked list. */
290 struct loc_exp_dep **pprev;
294 /* This data structure holds information about the depth of a variable
295 expansion. */
296 struct expand_depth
298 /* This measures the complexity of the expanded expression. It
299 grows by one for each level of expansion that adds more than one
300 operand. */
301 int complexity;
302 /* This counts the number of ENTRY_VALUE expressions in an
303 expansion. We want to minimize their use. */
304 int entryvals;
307 /* This data structure is allocated for one-part variables at the time
308 of emitting notes. */
309 struct onepart_aux
311 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
312 computation used the expansion of this variable, and that ought
313 to be notified should this variable change. If the DV's cur_loc
314 expanded to NULL, all components of the loc list are regarded as
315 active, so that any changes in them give us a chance to get a
316 location. Otherwise, only components of the loc that expanded to
317 non-NULL are regarded as active dependencies. */
318 loc_exp_dep *backlinks;
319 /* This holds the LOC that was expanded into cur_loc. We need only
320 mark a one-part variable as changed if the FROM loc is removed,
321 or if it has no known location and a loc is added, or if it gets
322 a change notification from any of its active dependencies. */
323 rtx from;
324 /* The depth of the cur_loc expression. */
325 expand_depth depth;
326 /* Dependencies actively used when expand FROM into cur_loc. */
327 vec<loc_exp_dep, va_heap, vl_embed> deps;
330 /* Structure describing one part of variable. */
331 struct variable_part
333 /* Chain of locations of the part. */
334 location_chain *loc_chain;
336 /* Location which was last emitted to location list. */
337 rtx cur_loc;
339 union variable_aux
341 /* The offset in the variable, if !var->onepart. */
342 HOST_WIDE_INT offset;
344 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
345 struct onepart_aux *onepaux;
346 } aux;
349 /* Maximum number of location parts. */
350 #define MAX_VAR_PARTS 16
352 /* Enumeration type used to discriminate various types of one-part
353 variables. */
354 enum onepart_enum
356 /* Not a one-part variable. */
357 NOT_ONEPART = 0,
358 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
359 ONEPART_VDECL = 1,
360 /* A DEBUG_EXPR_DECL. */
361 ONEPART_DEXPR = 2,
362 /* A VALUE. */
363 ONEPART_VALUE = 3
366 /* Structure describing where the variable is located. */
367 struct variable
369 /* The declaration of the variable, or an RTL value being handled
370 like a declaration. */
371 decl_or_value dv;
373 /* Reference count. */
374 int refcount;
376 /* Number of variable parts. */
377 char n_var_parts;
379 /* What type of DV this is, according to enum onepart_enum. */
380 ENUM_BITFIELD (onepart_enum) onepart : CHAR_BIT;
382 /* True if this variable_def struct is currently in the
383 changed_variables hash table. */
384 bool in_changed_variables;
386 /* The variable parts. */
387 variable_part var_part[1];
390 /* Pointer to the BB's information specific to variable tracking pass. */
391 #define VTI(BB) ((variable_tracking_info *) (BB)->aux)
393 /* Return MEM_OFFSET (MEM) as a HOST_WIDE_INT, or 0 if we can't. */
395 static inline HOST_WIDE_INT
396 int_mem_offset (const_rtx mem)
398 HOST_WIDE_INT offset;
399 if (MEM_OFFSET_KNOWN_P (mem) && MEM_OFFSET (mem).is_constant (&offset))
400 return offset;
401 return 0;
404 #if CHECKING_P && (GCC_VERSION >= 2007)
406 /* Access VAR's Ith part's offset, checking that it's not a one-part
407 variable. */
408 #define VAR_PART_OFFSET(var, i) __extension__ \
409 (*({ variable *const __v = (var); \
410 gcc_checking_assert (!__v->onepart); \
411 &__v->var_part[(i)].aux.offset; }))
413 /* Access VAR's one-part auxiliary data, checking that it is a
414 one-part variable. */
415 #define VAR_LOC_1PAUX(var) __extension__ \
416 (*({ variable *const __v = (var); \
417 gcc_checking_assert (__v->onepart); \
418 &__v->var_part[0].aux.onepaux; }))
420 #else
421 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
422 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
423 #endif
425 /* These are accessor macros for the one-part auxiliary data. When
426 convenient for users, they're guarded by tests that the data was
427 allocated. */
428 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
429 ? VAR_LOC_1PAUX (var)->backlinks \
430 : NULL)
431 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
432 ? &VAR_LOC_1PAUX (var)->backlinks \
433 : NULL)
434 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
435 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
436 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
437 ? &VAR_LOC_1PAUX (var)->deps \
438 : NULL)
442 typedef unsigned int dvuid;
444 /* Return the uid of DV. */
446 static inline dvuid
447 dv_uid (decl_or_value dv)
449 if (dv_is_value_p (dv))
450 return CSELIB_VAL_PTR (dv_as_value (dv))->uid;
451 else
452 return DECL_UID (dv_as_decl (dv));
455 /* Compute the hash from the uid. */
457 static inline hashval_t
458 dv_uid2hash (dvuid uid)
460 return uid;
463 /* The hash function for a mask table in a shared_htab chain. */
465 static inline hashval_t
466 dv_htab_hash (decl_or_value dv)
468 return dv_uid2hash (dv_uid (dv));
471 static void variable_htab_free (void *);
473 /* Variable hashtable helpers. */
475 struct variable_hasher : pointer_hash <variable>
477 typedef void *compare_type;
478 static inline hashval_t hash (const variable *);
479 static inline bool equal (const variable *, const void *);
480 static inline void remove (variable *);
483 /* The hash function for variable_htab, computes the hash value
484 from the declaration of variable X. */
486 inline hashval_t
487 variable_hasher::hash (const variable *v)
489 return dv_htab_hash (v->dv);
492 /* Compare the declaration of variable X with declaration Y. */
494 inline bool
495 variable_hasher::equal (const variable *v, const void *y)
497 decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y);
499 return (dv_as_opaque (v->dv) == dv_as_opaque (dv));
502 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
504 inline void
505 variable_hasher::remove (variable *var)
507 variable_htab_free (var);
510 typedef hash_table<variable_hasher> variable_table_type;
511 typedef variable_table_type::iterator variable_iterator_type;
513 /* Structure for passing some other parameters to function
514 emit_note_insn_var_location. */
515 struct emit_note_data
517 /* The instruction which the note will be emitted before/after. */
518 rtx_insn *insn;
520 /* Where the note will be emitted (before/after insn)? */
521 enum emit_note_where where;
523 /* The variables and values active at this point. */
524 variable_table_type *vars;
527 /* Structure holding a refcounted hash table. If refcount > 1,
528 it must be first unshared before modified. */
529 struct shared_hash
531 /* Reference count. */
532 int refcount;
534 /* Actual hash table. */
535 variable_table_type *htab;
538 /* Structure holding the IN or OUT set for a basic block. */
539 struct dataflow_set
541 /* Adjustment of stack offset. */
542 HOST_WIDE_INT stack_adjust;
544 /* Attributes for registers (lists of attrs). */
545 attrs *regs[FIRST_PSEUDO_REGISTER];
547 /* Variable locations. */
548 shared_hash *vars;
550 /* Vars that is being traversed. */
551 shared_hash *traversed_vars;
554 /* The structure (one for each basic block) containing the information
555 needed for variable tracking. */
556 struct variable_tracking_info
558 /* The vector of micro operations. */
559 vec<micro_operation> mos;
561 /* The IN and OUT set for dataflow analysis. */
562 dataflow_set in;
563 dataflow_set out;
565 /* The permanent-in dataflow set for this block. This is used to
566 hold values for which we had to compute entry values. ??? This
567 should probably be dynamically allocated, to avoid using more
568 memory in non-debug builds. */
569 dataflow_set *permp;
571 /* Has the block been visited in DFS? */
572 bool visited;
574 /* Has the block been flooded in VTA? */
575 bool flooded;
579 /* Alloc pool for struct attrs_def. */
580 object_allocator<attrs> attrs_pool ("attrs pool");
582 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
584 static pool_allocator var_pool
585 ("variable_def pool", sizeof (variable) +
586 (MAX_VAR_PARTS - 1) * sizeof (((variable *)NULL)->var_part[0]));
588 /* Alloc pool for struct variable_def with a single var_part entry. */
589 static pool_allocator valvar_pool
590 ("small variable_def pool", sizeof (variable));
592 /* Alloc pool for struct location_chain. */
593 static object_allocator<location_chain> location_chain_pool
594 ("location_chain pool");
596 /* Alloc pool for struct shared_hash. */
597 static object_allocator<shared_hash> shared_hash_pool ("shared_hash pool");
599 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
600 object_allocator<loc_exp_dep> loc_exp_dep_pool ("loc_exp_dep pool");
602 /* Changed variables, notes will be emitted for them. */
603 static variable_table_type *changed_variables;
605 /* Shall notes be emitted? */
606 static bool emit_notes;
608 /* Values whose dynamic location lists have gone empty, but whose
609 cselib location lists are still usable. Use this to hold the
610 current location, the backlinks, etc, during emit_notes. */
611 static variable_table_type *dropped_values;
613 /* Empty shared hashtable. */
614 static shared_hash *empty_shared_hash;
616 /* Scratch register bitmap used by cselib_expand_value_rtx. */
617 static bitmap scratch_regs = NULL;
619 #ifdef HAVE_window_save
620 struct GTY(()) parm_reg {
621 rtx outgoing;
622 rtx incoming;
626 /* Vector of windowed parameter registers, if any. */
627 static vec<parm_reg, va_gc> *windowed_parm_regs = NULL;
628 #endif
630 /* Variable used to tell whether cselib_process_insn called our hook. */
631 static bool cselib_hook_called;
633 /* Local function prototypes. */
634 static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,
635 HOST_WIDE_INT *);
636 static void insn_stack_adjust_offset_pre_post (rtx_insn *, HOST_WIDE_INT *,
637 HOST_WIDE_INT *);
638 static bool vt_stack_adjustments (void);
640 static void init_attrs_list_set (attrs **);
641 static void attrs_list_clear (attrs **);
642 static attrs *attrs_list_member (attrs *, decl_or_value, HOST_WIDE_INT);
643 static void attrs_list_insert (attrs **, decl_or_value, HOST_WIDE_INT, rtx);
644 static void attrs_list_copy (attrs **, attrs *);
645 static void attrs_list_union (attrs **, attrs *);
647 static variable **unshare_variable (dataflow_set *set, variable **slot,
648 variable *var, enum var_init_status);
649 static void vars_copy (variable_table_type *, variable_table_type *);
650 static tree var_debug_decl (tree);
651 static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx);
652 static void var_reg_delete_and_set (dataflow_set *, rtx, bool,
653 enum var_init_status, rtx);
654 static void var_reg_delete (dataflow_set *, rtx, bool);
655 static void var_regno_delete (dataflow_set *, int);
656 static void var_mem_set (dataflow_set *, rtx, enum var_init_status, rtx);
657 static void var_mem_delete_and_set (dataflow_set *, rtx, bool,
658 enum var_init_status, rtx);
659 static void var_mem_delete (dataflow_set *, rtx, bool);
661 static void dataflow_set_init (dataflow_set *);
662 static void dataflow_set_clear (dataflow_set *);
663 static void dataflow_set_copy (dataflow_set *, dataflow_set *);
664 static int variable_union_info_cmp_pos (const void *, const void *);
665 static void dataflow_set_union (dataflow_set *, dataflow_set *);
666 static location_chain *find_loc_in_1pdv (rtx, variable *,
667 variable_table_type *);
668 static bool canon_value_cmp (rtx, rtx);
669 static int loc_cmp (rtx, rtx);
670 static bool variable_part_different_p (variable_part *, variable_part *);
671 static bool onepart_variable_different_p (variable *, variable *);
672 static bool variable_different_p (variable *, variable *);
673 static bool dataflow_set_different (dataflow_set *, dataflow_set *);
674 static void dataflow_set_destroy (dataflow_set *);
676 static bool track_expr_p (tree, bool);
677 static void add_uses_1 (rtx *, void *);
678 static void add_stores (rtx, const_rtx, void *);
679 static bool compute_bb_dataflow (basic_block);
680 static bool vt_find_locations (void);
682 static void dump_attrs_list (attrs *);
683 static void dump_var (variable *);
684 static void dump_vars (variable_table_type *);
685 static void dump_dataflow_set (dataflow_set *);
686 static void dump_dataflow_sets (void);
688 static void set_dv_changed (decl_or_value, bool);
689 static void variable_was_changed (variable *, dataflow_set *);
690 static variable **set_slot_part (dataflow_set *, rtx, variable **,
691 decl_or_value, HOST_WIDE_INT,
692 enum var_init_status, rtx);
693 static void set_variable_part (dataflow_set *, rtx,
694 decl_or_value, HOST_WIDE_INT,
695 enum var_init_status, rtx, enum insert_option);
696 static variable **clobber_slot_part (dataflow_set *, rtx,
697 variable **, HOST_WIDE_INT, rtx);
698 static void clobber_variable_part (dataflow_set *, rtx,
699 decl_or_value, HOST_WIDE_INT, rtx);
700 static variable **delete_slot_part (dataflow_set *, rtx, variable **,
701 HOST_WIDE_INT);
702 static void delete_variable_part (dataflow_set *, rtx,
703 decl_or_value, HOST_WIDE_INT);
704 static void emit_notes_in_bb (basic_block, dataflow_set *);
705 static void vt_emit_notes (void);
707 static void vt_add_function_parameters (void);
708 static bool vt_initialize (void);
709 static void vt_finalize (void);
711 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
713 static int
714 stack_adjust_offset_pre_post_cb (rtx, rtx op, rtx dest, rtx src, rtx srcoff,
715 void *arg)
717 if (dest != stack_pointer_rtx)
718 return 0;
720 switch (GET_CODE (op))
722 case PRE_INC:
723 case PRE_DEC:
724 ((HOST_WIDE_INT *)arg)[0] -= INTVAL (srcoff);
725 return 0;
726 case POST_INC:
727 case POST_DEC:
728 ((HOST_WIDE_INT *)arg)[1] -= INTVAL (srcoff);
729 return 0;
730 case PRE_MODIFY:
731 case POST_MODIFY:
732 /* We handle only adjustments by constant amount. */
733 gcc_assert (GET_CODE (src) == PLUS
734 && CONST_INT_P (XEXP (src, 1))
735 && XEXP (src, 0) == stack_pointer_rtx);
736 ((HOST_WIDE_INT *)arg)[GET_CODE (op) == POST_MODIFY]
737 -= INTVAL (XEXP (src, 1));
738 return 0;
739 default:
740 gcc_unreachable ();
744 /* Given a SET, calculate the amount of stack adjustment it contains
745 PRE- and POST-modifying stack pointer.
746 This function is similar to stack_adjust_offset. */
748 static void
749 stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INT *pre,
750 HOST_WIDE_INT *post)
752 rtx src = SET_SRC (pattern);
753 rtx dest = SET_DEST (pattern);
754 enum rtx_code code;
756 if (dest == stack_pointer_rtx)
758 /* (set (reg sp) (plus (reg sp) (const_int))) */
759 code = GET_CODE (src);
760 if (! (code == PLUS || code == MINUS)
761 || XEXP (src, 0) != stack_pointer_rtx
762 || !CONST_INT_P (XEXP (src, 1)))
763 return;
765 if (code == MINUS)
766 *post += INTVAL (XEXP (src, 1));
767 else
768 *post -= INTVAL (XEXP (src, 1));
769 return;
771 HOST_WIDE_INT res[2] = { 0, 0 };
772 for_each_inc_dec (pattern, stack_adjust_offset_pre_post_cb, res);
773 *pre += res[0];
774 *post += res[1];
777 /* Given an INSN, calculate the amount of stack adjustment it contains
778 PRE- and POST-modifying stack pointer. */
780 static void
781 insn_stack_adjust_offset_pre_post (rtx_insn *insn, HOST_WIDE_INT *pre,
782 HOST_WIDE_INT *post)
784 rtx pattern;
786 *pre = 0;
787 *post = 0;
789 pattern = PATTERN (insn);
790 if (RTX_FRAME_RELATED_P (insn))
792 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
793 if (expr)
794 pattern = XEXP (expr, 0);
797 if (GET_CODE (pattern) == SET)
798 stack_adjust_offset_pre_post (pattern, pre, post);
799 else if (GET_CODE (pattern) == PARALLEL
800 || GET_CODE (pattern) == SEQUENCE)
802 int i;
804 /* There may be stack adjustments inside compound insns. Search
805 for them. */
806 for ( i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
807 if (GET_CODE (XVECEXP (pattern, 0, i)) == SET)
808 stack_adjust_offset_pre_post (XVECEXP (pattern, 0, i), pre, post);
812 /* Compute stack adjustments for all blocks by traversing DFS tree.
813 Return true when the adjustments on all incoming edges are consistent.
814 Heavily borrowed from pre_and_rev_post_order_compute. */
816 static bool
817 vt_stack_adjustments (void)
819 edge_iterator *stack;
820 int sp;
822 /* Initialize entry block. */
823 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->visited = true;
824 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->in.stack_adjust
825 = INCOMING_FRAME_SP_OFFSET;
826 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out.stack_adjust
827 = INCOMING_FRAME_SP_OFFSET;
829 /* Allocate stack for back-tracking up CFG. */
830 stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
831 sp = 0;
833 /* Push the first edge on to the stack. */
834 stack[sp++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
836 while (sp)
838 edge_iterator ei;
839 basic_block src;
840 basic_block dest;
842 /* Look at the edge on the top of the stack. */
843 ei = stack[sp - 1];
844 src = ei_edge (ei)->src;
845 dest = ei_edge (ei)->dest;
847 /* Check if the edge destination has been visited yet. */
848 if (!VTI (dest)->visited)
850 rtx_insn *insn;
851 HOST_WIDE_INT pre, post, offset;
852 VTI (dest)->visited = true;
853 VTI (dest)->in.stack_adjust = offset = VTI (src)->out.stack_adjust;
855 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
856 for (insn = BB_HEAD (dest);
857 insn != NEXT_INSN (BB_END (dest));
858 insn = NEXT_INSN (insn))
859 if (INSN_P (insn))
861 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
862 offset += pre + post;
865 VTI (dest)->out.stack_adjust = offset;
867 if (EDGE_COUNT (dest->succs) > 0)
868 /* Since the DEST node has been visited for the first
869 time, check its successors. */
870 stack[sp++] = ei_start (dest->succs);
872 else
874 /* We can end up with different stack adjustments for the exit block
875 of a shrink-wrapped function if stack_adjust_offset_pre_post
876 doesn't understand the rtx pattern used to restore the stack
877 pointer in the epilogue. For example, on s390(x), the stack
878 pointer is often restored via a load-multiple instruction
879 and so no stack_adjust offset is recorded for it. This means
880 that the stack offset at the end of the epilogue block is the
881 same as the offset before the epilogue, whereas other paths
882 to the exit block will have the correct stack_adjust.
884 It is safe to ignore these differences because (a) we never
885 use the stack_adjust for the exit block in this pass and
886 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
887 function are correct.
889 We must check whether the adjustments on other edges are
890 the same though. */
891 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
892 && VTI (dest)->in.stack_adjust != VTI (src)->out.stack_adjust)
894 free (stack);
895 return false;
898 if (! ei_one_before_end_p (ei))
899 /* Go to the next edge. */
900 ei_next (&stack[sp - 1]);
901 else
902 /* Return to previous level if there are no more edges. */
903 sp--;
907 free (stack);
908 return true;
911 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
912 hard_frame_pointer_rtx is being mapped to it and offset for it. */
913 static rtx cfa_base_rtx;
914 static HOST_WIDE_INT cfa_base_offset;
916 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
917 or hard_frame_pointer_rtx. */
919 static inline rtx
920 compute_cfa_pointer (HOST_WIDE_INT adjustment)
922 return plus_constant (Pmode, cfa_base_rtx, adjustment + cfa_base_offset);
925 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
926 or -1 if the replacement shouldn't be done. */
927 static HOST_WIDE_INT hard_frame_pointer_adjustment = -1;
929 /* Data for adjust_mems callback. */
931 struct adjust_mem_data
933 bool store;
934 machine_mode mem_mode;
935 HOST_WIDE_INT stack_adjust;
936 auto_vec<rtx> side_effects;
939 /* Helper for adjust_mems. Return true if X is suitable for
940 transformation of wider mode arithmetics to narrower mode. */
942 static bool
943 use_narrower_mode_test (rtx x, const_rtx subreg)
945 subrtx_var_iterator::array_type array;
946 FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST)
948 rtx x = *iter;
949 if (CONSTANT_P (x))
950 iter.skip_subrtxes ();
951 else
952 switch (GET_CODE (x))
954 case REG:
955 if (cselib_lookup (x, GET_MODE (SUBREG_REG (subreg)), 0, VOIDmode))
956 return false;
957 if (!validate_subreg (GET_MODE (subreg), GET_MODE (x), x,
958 subreg_lowpart_offset (GET_MODE (subreg),
959 GET_MODE (x))))
960 return false;
961 break;
962 case PLUS:
963 case MINUS:
964 case MULT:
965 break;
966 case ASHIFT:
967 iter.substitute (XEXP (x, 0));
968 break;
969 default:
970 return false;
973 return true;
976 /* Transform X into narrower mode MODE from wider mode WMODE. */
978 static rtx
979 use_narrower_mode (rtx x, scalar_int_mode mode, scalar_int_mode wmode)
981 rtx op0, op1;
982 if (CONSTANT_P (x))
983 return lowpart_subreg (mode, x, wmode);
984 switch (GET_CODE (x))
986 case REG:
987 return lowpart_subreg (mode, x, wmode);
988 case PLUS:
989 case MINUS:
990 case MULT:
991 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
992 op1 = use_narrower_mode (XEXP (x, 1), mode, wmode);
993 return simplify_gen_binary (GET_CODE (x), mode, op0, op1);
994 case ASHIFT:
995 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
996 op1 = XEXP (x, 1);
997 /* Ensure shift amount is not wider than mode. */
998 if (GET_MODE (op1) == VOIDmode)
999 op1 = lowpart_subreg (mode, op1, wmode);
1000 else if (GET_MODE_PRECISION (mode)
1001 < GET_MODE_PRECISION (as_a <scalar_int_mode> (GET_MODE (op1))))
1002 op1 = lowpart_subreg (mode, op1, GET_MODE (op1));
1003 return simplify_gen_binary (ASHIFT, mode, op0, op1);
1004 default:
1005 gcc_unreachable ();
1009 /* Helper function for adjusting used MEMs. */
1011 static rtx
1012 adjust_mems (rtx loc, const_rtx old_rtx, void *data)
1014 struct adjust_mem_data *amd = (struct adjust_mem_data *) data;
1015 rtx mem, addr = loc, tem;
1016 machine_mode mem_mode_save;
1017 bool store_save;
1018 scalar_int_mode tem_mode, tem_subreg_mode;
1019 switch (GET_CODE (loc))
1021 case REG:
1022 /* Don't do any sp or fp replacements outside of MEM addresses
1023 on the LHS. */
1024 if (amd->mem_mode == VOIDmode && amd->store)
1025 return loc;
1026 if (loc == stack_pointer_rtx
1027 && !frame_pointer_needed
1028 && cfa_base_rtx)
1029 return compute_cfa_pointer (amd->stack_adjust);
1030 else if (loc == hard_frame_pointer_rtx
1031 && frame_pointer_needed
1032 && hard_frame_pointer_adjustment != -1
1033 && cfa_base_rtx)
1034 return compute_cfa_pointer (hard_frame_pointer_adjustment);
1035 gcc_checking_assert (loc != virtual_incoming_args_rtx);
1036 return loc;
1037 case MEM:
1038 mem = loc;
1039 if (!amd->store)
1041 mem = targetm.delegitimize_address (mem);
1042 if (mem != loc && !MEM_P (mem))
1043 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
1046 addr = XEXP (mem, 0);
1047 mem_mode_save = amd->mem_mode;
1048 amd->mem_mode = GET_MODE (mem);
1049 store_save = amd->store;
1050 amd->store = false;
1051 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1052 amd->store = store_save;
1053 amd->mem_mode = mem_mode_save;
1054 if (mem == loc)
1055 addr = targetm.delegitimize_address (addr);
1056 if (addr != XEXP (mem, 0))
1057 mem = replace_equiv_address_nv (mem, addr);
1058 if (!amd->store)
1059 mem = avoid_constant_pool_reference (mem);
1060 return mem;
1061 case PRE_INC:
1062 case PRE_DEC:
1063 addr = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
1064 gen_int_mode (GET_CODE (loc) == PRE_INC
1065 ? GET_MODE_SIZE (amd->mem_mode)
1066 : -GET_MODE_SIZE (amd->mem_mode),
1067 GET_MODE (loc)));
1068 /* FALLTHRU */
1069 case POST_INC:
1070 case POST_DEC:
1071 if (addr == loc)
1072 addr = XEXP (loc, 0);
1073 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
1074 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1075 tem = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
1076 gen_int_mode ((GET_CODE (loc) == PRE_INC
1077 || GET_CODE (loc) == POST_INC)
1078 ? GET_MODE_SIZE (amd->mem_mode)
1079 : -GET_MODE_SIZE (amd->mem_mode),
1080 GET_MODE (loc)));
1081 store_save = amd->store;
1082 amd->store = false;
1083 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
1084 amd->store = store_save;
1085 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1086 return addr;
1087 case PRE_MODIFY:
1088 addr = XEXP (loc, 1);
1089 /* FALLTHRU */
1090 case POST_MODIFY:
1091 if (addr == loc)
1092 addr = XEXP (loc, 0);
1093 gcc_assert (amd->mem_mode != VOIDmode);
1094 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1095 store_save = amd->store;
1096 amd->store = false;
1097 tem = simplify_replace_fn_rtx (XEXP (loc, 1), old_rtx,
1098 adjust_mems, data);
1099 amd->store = store_save;
1100 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1101 return addr;
1102 case SUBREG:
1103 /* First try without delegitimization of whole MEMs and
1104 avoid_constant_pool_reference, which is more likely to succeed. */
1105 store_save = amd->store;
1106 amd->store = true;
1107 addr = simplify_replace_fn_rtx (SUBREG_REG (loc), old_rtx, adjust_mems,
1108 data);
1109 amd->store = store_save;
1110 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1111 if (mem == SUBREG_REG (loc))
1113 tem = loc;
1114 goto finish_subreg;
1116 tem = simplify_gen_subreg (GET_MODE (loc), mem,
1117 GET_MODE (SUBREG_REG (loc)),
1118 SUBREG_BYTE (loc));
1119 if (tem)
1120 goto finish_subreg;
1121 tem = simplify_gen_subreg (GET_MODE (loc), addr,
1122 GET_MODE (SUBREG_REG (loc)),
1123 SUBREG_BYTE (loc));
1124 if (tem == NULL_RTX)
1125 tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
1126 finish_subreg:
1127 if (MAY_HAVE_DEBUG_BIND_INSNS
1128 && GET_CODE (tem) == SUBREG
1129 && (GET_CODE (SUBREG_REG (tem)) == PLUS
1130 || GET_CODE (SUBREG_REG (tem)) == MINUS
1131 || GET_CODE (SUBREG_REG (tem)) == MULT
1132 || GET_CODE (SUBREG_REG (tem)) == ASHIFT)
1133 && is_a <scalar_int_mode> (GET_MODE (tem), &tem_mode)
1134 && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (tem)),
1135 &tem_subreg_mode)
1136 && (GET_MODE_PRECISION (tem_mode)
1137 < GET_MODE_PRECISION (tem_subreg_mode))
1138 && subreg_lowpart_p (tem)
1139 && use_narrower_mode_test (SUBREG_REG (tem), tem))
1140 return use_narrower_mode (SUBREG_REG (tem), tem_mode, tem_subreg_mode);
1141 return tem;
1142 case ASM_OPERANDS:
1143 /* Don't do any replacements in second and following
1144 ASM_OPERANDS of inline-asm with multiple sets.
1145 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1146 and ASM_OPERANDS_LABEL_VEC need to be equal between
1147 all the ASM_OPERANDs in the insn and adjust_insn will
1148 fix this up. */
1149 if (ASM_OPERANDS_OUTPUT_IDX (loc) != 0)
1150 return loc;
1151 break;
1152 default:
1153 break;
1155 return NULL_RTX;
1158 /* Helper function for replacement of uses. */
1160 static void
1161 adjust_mem_uses (rtx *x, void *data)
1163 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX, adjust_mems, data);
1164 if (new_x != *x)
1165 validate_change (NULL_RTX, x, new_x, true);
1168 /* Helper function for replacement of stores. */
1170 static void
1171 adjust_mem_stores (rtx loc, const_rtx expr, void *data)
1173 if (MEM_P (loc))
1175 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr), NULL_RTX,
1176 adjust_mems, data);
1177 if (new_dest != SET_DEST (expr))
1179 rtx xexpr = CONST_CAST_RTX (expr);
1180 validate_change (NULL_RTX, &SET_DEST (xexpr), new_dest, true);
1185 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1186 replace them with their value in the insn and add the side-effects
1187 as other sets to the insn. */
1189 static void
1190 adjust_insn (basic_block bb, rtx_insn *insn)
1192 rtx set;
1194 #ifdef HAVE_window_save
1195 /* If the target machine has an explicit window save instruction, the
1196 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1197 if (RTX_FRAME_RELATED_P (insn)
1198 && find_reg_note (insn, REG_CFA_WINDOW_SAVE, NULL_RTX))
1200 unsigned int i, nregs = vec_safe_length (windowed_parm_regs);
1201 rtx rtl = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs * 2));
1202 parm_reg *p;
1204 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)
1206 XVECEXP (rtl, 0, i * 2)
1207 = gen_rtx_SET (p->incoming, p->outgoing);
1208 /* Do not clobber the attached DECL, but only the REG. */
1209 XVECEXP (rtl, 0, i * 2 + 1)
1210 = gen_rtx_CLOBBER (GET_MODE (p->outgoing),
1211 gen_raw_REG (GET_MODE (p->outgoing),
1212 REGNO (p->outgoing)));
1215 validate_change (NULL_RTX, &PATTERN (insn), rtl, true);
1216 return;
1218 #endif
1220 adjust_mem_data amd;
1221 amd.mem_mode = VOIDmode;
1222 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
1224 amd.store = true;
1225 note_stores (PATTERN (insn), adjust_mem_stores, &amd);
1227 amd.store = false;
1228 if (GET_CODE (PATTERN (insn)) == PARALLEL
1229 && asm_noperands (PATTERN (insn)) > 0
1230 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1232 rtx body, set0;
1233 int i;
1235 /* inline-asm with multiple sets is tiny bit more complicated,
1236 because the 3 vectors in ASM_OPERANDS need to be shared between
1237 all ASM_OPERANDS in the instruction. adjust_mems will
1238 not touch ASM_OPERANDS other than the first one, asm_noperands
1239 test above needs to be called before that (otherwise it would fail)
1240 and afterwards this code fixes it up. */
1241 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1242 body = PATTERN (insn);
1243 set0 = XVECEXP (body, 0, 0);
1244 gcc_checking_assert (GET_CODE (set0) == SET
1245 && GET_CODE (SET_SRC (set0)) == ASM_OPERANDS
1246 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0)) == 0);
1247 for (i = 1; i < XVECLEN (body, 0); i++)
1248 if (GET_CODE (XVECEXP (body, 0, i)) != SET)
1249 break;
1250 else
1252 set = XVECEXP (body, 0, i);
1253 gcc_checking_assert (GET_CODE (SET_SRC (set)) == ASM_OPERANDS
1254 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set))
1255 == i);
1256 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set))
1257 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))
1258 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set))
1259 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))
1260 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set))
1261 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0)))
1263 rtx newsrc = shallow_copy_rtx (SET_SRC (set));
1264 ASM_OPERANDS_INPUT_VEC (newsrc)
1265 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0));
1266 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc)
1267 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0));
1268 ASM_OPERANDS_LABEL_VEC (newsrc)
1269 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0));
1270 validate_change (NULL_RTX, &SET_SRC (set), newsrc, true);
1274 else
1275 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1277 /* For read-only MEMs containing some constant, prefer those
1278 constants. */
1279 set = single_set (insn);
1280 if (set && MEM_P (SET_SRC (set)) && MEM_READONLY_P (SET_SRC (set)))
1282 rtx note = find_reg_equal_equiv_note (insn);
1284 if (note && CONSTANT_P (XEXP (note, 0)))
1285 validate_change (NULL_RTX, &SET_SRC (set), XEXP (note, 0), true);
1288 if (!amd.side_effects.is_empty ())
1290 rtx *pat, new_pat;
1291 int i, oldn;
1293 pat = &PATTERN (insn);
1294 if (GET_CODE (*pat) == COND_EXEC)
1295 pat = &COND_EXEC_CODE (*pat);
1296 if (GET_CODE (*pat) == PARALLEL)
1297 oldn = XVECLEN (*pat, 0);
1298 else
1299 oldn = 1;
1300 unsigned int newn = amd.side_effects.length ();
1301 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn));
1302 if (GET_CODE (*pat) == PARALLEL)
1303 for (i = 0; i < oldn; i++)
1304 XVECEXP (new_pat, 0, i) = XVECEXP (*pat, 0, i);
1305 else
1306 XVECEXP (new_pat, 0, 0) = *pat;
1308 rtx effect;
1309 unsigned int j;
1310 FOR_EACH_VEC_ELT_REVERSE (amd.side_effects, j, effect)
1311 XVECEXP (new_pat, 0, j + oldn) = effect;
1312 validate_change (NULL_RTX, pat, new_pat, true);
1316 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1317 static inline rtx
1318 dv_as_rtx (decl_or_value dv)
1320 tree decl;
1322 if (dv_is_value_p (dv))
1323 return dv_as_value (dv);
1325 decl = dv_as_decl (dv);
1327 gcc_checking_assert (TREE_CODE (decl) == DEBUG_EXPR_DECL);
1328 return DECL_RTL_KNOWN_SET (decl);
1331 /* Return nonzero if a decl_or_value must not have more than one
1332 variable part. The returned value discriminates among various
1333 kinds of one-part DVs ccording to enum onepart_enum. */
1334 static inline onepart_enum
1335 dv_onepart_p (decl_or_value dv)
1337 tree decl;
1339 if (!MAY_HAVE_DEBUG_BIND_INSNS)
1340 return NOT_ONEPART;
1342 if (dv_is_value_p (dv))
1343 return ONEPART_VALUE;
1345 decl = dv_as_decl (dv);
1347 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
1348 return ONEPART_DEXPR;
1350 if (target_for_debug_bind (decl) != NULL_TREE)
1351 return ONEPART_VDECL;
1353 return NOT_ONEPART;
1356 /* Return the variable pool to be used for a dv of type ONEPART. */
1357 static inline pool_allocator &
1358 onepart_pool (onepart_enum onepart)
1360 return onepart ? valvar_pool : var_pool;
1363 /* Allocate a variable_def from the corresponding variable pool. */
1364 static inline variable *
1365 onepart_pool_allocate (onepart_enum onepart)
1367 return (variable*) onepart_pool (onepart).allocate ();
1370 /* Build a decl_or_value out of a decl. */
1371 static inline decl_or_value
1372 dv_from_decl (tree decl)
1374 decl_or_value dv;
1375 dv = decl;
1376 gcc_checking_assert (dv_is_decl_p (dv));
1377 return dv;
1380 /* Build a decl_or_value out of a value. */
1381 static inline decl_or_value
1382 dv_from_value (rtx value)
1384 decl_or_value dv;
1385 dv = value;
1386 gcc_checking_assert (dv_is_value_p (dv));
1387 return dv;
1390 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1391 static inline decl_or_value
1392 dv_from_rtx (rtx x)
1394 decl_or_value dv;
1396 switch (GET_CODE (x))
1398 case DEBUG_EXPR:
1399 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x));
1400 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x)) == x);
1401 break;
1403 case VALUE:
1404 dv = dv_from_value (x);
1405 break;
1407 default:
1408 gcc_unreachable ();
1411 return dv;
1414 extern void debug_dv (decl_or_value dv);
1416 DEBUG_FUNCTION void
1417 debug_dv (decl_or_value dv)
1419 if (dv_is_value_p (dv))
1420 debug_rtx (dv_as_value (dv));
1421 else
1422 debug_generic_stmt (dv_as_decl (dv));
1425 static void loc_exp_dep_clear (variable *var);
1427 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1429 static void
1430 variable_htab_free (void *elem)
1432 int i;
1433 variable *var = (variable *) elem;
1434 location_chain *node, *next;
1436 gcc_checking_assert (var->refcount > 0);
1438 var->refcount--;
1439 if (var->refcount > 0)
1440 return;
1442 for (i = 0; i < var->n_var_parts; i++)
1444 for (node = var->var_part[i].loc_chain; node; node = next)
1446 next = node->next;
1447 delete node;
1449 var->var_part[i].loc_chain = NULL;
1451 if (var->onepart && VAR_LOC_1PAUX (var))
1453 loc_exp_dep_clear (var);
1454 if (VAR_LOC_DEP_LST (var))
1455 VAR_LOC_DEP_LST (var)->pprev = NULL;
1456 XDELETE (VAR_LOC_1PAUX (var));
1457 /* These may be reused across functions, so reset
1458 e.g. NO_LOC_P. */
1459 if (var->onepart == ONEPART_DEXPR)
1460 set_dv_changed (var->dv, true);
1462 onepart_pool (var->onepart).remove (var);
1465 /* Initialize the set (array) SET of attrs to empty lists. */
1467 static void
1468 init_attrs_list_set (attrs **set)
1470 int i;
1472 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1473 set[i] = NULL;
1476 /* Make the list *LISTP empty. */
1478 static void
1479 attrs_list_clear (attrs **listp)
1481 attrs *list, *next;
1483 for (list = *listp; list; list = next)
1485 next = list->next;
1486 delete list;
1488 *listp = NULL;
1491 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1493 static attrs *
1494 attrs_list_member (attrs *list, decl_or_value dv, HOST_WIDE_INT offset)
1496 for (; list; list = list->next)
1497 if (dv_as_opaque (list->dv) == dv_as_opaque (dv) && list->offset == offset)
1498 return list;
1499 return NULL;
1502 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1504 static void
1505 attrs_list_insert (attrs **listp, decl_or_value dv,
1506 HOST_WIDE_INT offset, rtx loc)
1508 attrs *list = new attrs;
1509 list->loc = loc;
1510 list->dv = dv;
1511 list->offset = offset;
1512 list->next = *listp;
1513 *listp = list;
1516 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1518 static void
1519 attrs_list_copy (attrs **dstp, attrs *src)
1521 attrs_list_clear (dstp);
1522 for (; src; src = src->next)
1524 attrs *n = new attrs;
1525 n->loc = src->loc;
1526 n->dv = src->dv;
1527 n->offset = src->offset;
1528 n->next = *dstp;
1529 *dstp = n;
1533 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1535 static void
1536 attrs_list_union (attrs **dstp, attrs *src)
1538 for (; src; src = src->next)
1540 if (!attrs_list_member (*dstp, src->dv, src->offset))
1541 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1545 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1546 *DSTP. */
1548 static void
1549 attrs_list_mpdv_union (attrs **dstp, attrs *src, attrs *src2)
1551 gcc_assert (!*dstp);
1552 for (; src; src = src->next)
1554 if (!dv_onepart_p (src->dv))
1555 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1557 for (src = src2; src; src = src->next)
1559 if (!dv_onepart_p (src->dv)
1560 && !attrs_list_member (*dstp, src->dv, src->offset))
1561 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1565 /* Shared hashtable support. */
1567 /* Return true if VARS is shared. */
1569 static inline bool
1570 shared_hash_shared (shared_hash *vars)
1572 return vars->refcount > 1;
1575 /* Return the hash table for VARS. */
1577 static inline variable_table_type *
1578 shared_hash_htab (shared_hash *vars)
1580 return vars->htab;
1583 /* Return true if VAR is shared, or maybe because VARS is shared. */
1585 static inline bool
1586 shared_var_p (variable *var, shared_hash *vars)
1588 /* Don't count an entry in the changed_variables table as a duplicate. */
1589 return ((var->refcount > 1 + (int) var->in_changed_variables)
1590 || shared_hash_shared (vars));
1593 /* Copy variables into a new hash table. */
1595 static shared_hash *
1596 shared_hash_unshare (shared_hash *vars)
1598 shared_hash *new_vars = new shared_hash;
1599 gcc_assert (vars->refcount > 1);
1600 new_vars->refcount = 1;
1601 new_vars->htab = new variable_table_type (vars->htab->elements () + 3);
1602 vars_copy (new_vars->htab, vars->htab);
1603 vars->refcount--;
1604 return new_vars;
1607 /* Increment reference counter on VARS and return it. */
1609 static inline shared_hash *
1610 shared_hash_copy (shared_hash *vars)
1612 vars->refcount++;
1613 return vars;
1616 /* Decrement reference counter and destroy hash table if not shared
1617 anymore. */
1619 static void
1620 shared_hash_destroy (shared_hash *vars)
1622 gcc_checking_assert (vars->refcount > 0);
1623 if (--vars->refcount == 0)
1625 delete vars->htab;
1626 delete vars;
1630 /* Unshare *PVARS if shared and return slot for DV. If INS is
1631 INSERT, insert it if not already present. */
1633 static inline variable **
1634 shared_hash_find_slot_unshare_1 (shared_hash **pvars, decl_or_value dv,
1635 hashval_t dvhash, enum insert_option ins)
1637 if (shared_hash_shared (*pvars))
1638 *pvars = shared_hash_unshare (*pvars);
1639 return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins);
1642 static inline variable **
1643 shared_hash_find_slot_unshare (shared_hash **pvars, decl_or_value dv,
1644 enum insert_option ins)
1646 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1649 /* Return slot for DV, if it is already present in the hash table.
1650 If it is not present, insert it only VARS is not shared, otherwise
1651 return NULL. */
1653 static inline variable **
1654 shared_hash_find_slot_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1656 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash,
1657 shared_hash_shared (vars)
1658 ? NO_INSERT : INSERT);
1661 static inline variable **
1662 shared_hash_find_slot (shared_hash *vars, decl_or_value dv)
1664 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1667 /* Return slot for DV only if it is already present in the hash table. */
1669 static inline variable **
1670 shared_hash_find_slot_noinsert_1 (shared_hash *vars, decl_or_value dv,
1671 hashval_t dvhash)
1673 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT);
1676 static inline variable **
1677 shared_hash_find_slot_noinsert (shared_hash *vars, decl_or_value dv)
1679 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1682 /* Return variable for DV or NULL if not already present in the hash
1683 table. */
1685 static inline variable *
1686 shared_hash_find_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1688 return shared_hash_htab (vars)->find_with_hash (dv, dvhash);
1691 static inline variable *
1692 shared_hash_find (shared_hash *vars, decl_or_value dv)
1694 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1697 /* Return true if TVAL is better than CVAL as a canonival value. We
1698 choose lowest-numbered VALUEs, using the RTX address as a
1699 tie-breaker. The idea is to arrange them into a star topology,
1700 such that all of them are at most one step away from the canonical
1701 value, and the canonical value has backlinks to all of them, in
1702 addition to all the actual locations. We don't enforce this
1703 topology throughout the entire dataflow analysis, though.
1706 static inline bool
1707 canon_value_cmp (rtx tval, rtx cval)
1709 return !cval
1710 || CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
1713 static bool dst_can_be_shared;
1715 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1717 static variable **
1718 unshare_variable (dataflow_set *set, variable **slot, variable *var,
1719 enum var_init_status initialized)
1721 variable *new_var;
1722 int i;
1724 new_var = onepart_pool_allocate (var->onepart);
1725 new_var->dv = var->dv;
1726 new_var->refcount = 1;
1727 var->refcount--;
1728 new_var->n_var_parts = var->n_var_parts;
1729 new_var->onepart = var->onepart;
1730 new_var->in_changed_variables = false;
1732 if (! flag_var_tracking_uninit)
1733 initialized = VAR_INIT_STATUS_INITIALIZED;
1735 for (i = 0; i < var->n_var_parts; i++)
1737 location_chain *node;
1738 location_chain **nextp;
1740 if (i == 0 && var->onepart)
1742 /* One-part auxiliary data is only used while emitting
1743 notes, so propagate it to the new variable in the active
1744 dataflow set. If we're not emitting notes, this will be
1745 a no-op. */
1746 gcc_checking_assert (!VAR_LOC_1PAUX (var) || emit_notes);
1747 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (var);
1748 VAR_LOC_1PAUX (var) = NULL;
1750 else
1751 VAR_PART_OFFSET (new_var, i) = VAR_PART_OFFSET (var, i);
1752 nextp = &new_var->var_part[i].loc_chain;
1753 for (node = var->var_part[i].loc_chain; node; node = node->next)
1755 location_chain *new_lc;
1757 new_lc = new location_chain;
1758 new_lc->next = NULL;
1759 if (node->init > initialized)
1760 new_lc->init = node->init;
1761 else
1762 new_lc->init = initialized;
1763 if (node->set_src && !(MEM_P (node->set_src)))
1764 new_lc->set_src = node->set_src;
1765 else
1766 new_lc->set_src = NULL;
1767 new_lc->loc = node->loc;
1769 *nextp = new_lc;
1770 nextp = &new_lc->next;
1773 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1776 dst_can_be_shared = false;
1777 if (shared_hash_shared (set->vars))
1778 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1779 else if (set->traversed_vars && set->vars != set->traversed_vars)
1780 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1781 *slot = new_var;
1782 if (var->in_changed_variables)
1784 variable **cslot
1785 = changed_variables->find_slot_with_hash (var->dv,
1786 dv_htab_hash (var->dv),
1787 NO_INSERT);
1788 gcc_assert (*cslot == (void *) var);
1789 var->in_changed_variables = false;
1790 variable_htab_free (var);
1791 *cslot = new_var;
1792 new_var->in_changed_variables = true;
1794 return slot;
1797 /* Copy all variables from hash table SRC to hash table DST. */
1799 static void
1800 vars_copy (variable_table_type *dst, variable_table_type *src)
1802 variable_iterator_type hi;
1803 variable *var;
1805 FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi)
1807 variable **dstp;
1808 var->refcount++;
1809 dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv),
1810 INSERT);
1811 *dstp = var;
1815 /* Map a decl to its main debug decl. */
1817 static inline tree
1818 var_debug_decl (tree decl)
1820 if (decl && VAR_P (decl) && DECL_HAS_DEBUG_EXPR_P (decl))
1822 tree debugdecl = DECL_DEBUG_EXPR (decl);
1823 if (DECL_P (debugdecl))
1824 decl = debugdecl;
1827 return decl;
1830 /* Set the register LOC to contain DV, OFFSET. */
1832 static void
1833 var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1834 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1835 enum insert_option iopt)
1837 attrs *node;
1838 bool decl_p = dv_is_decl_p (dv);
1840 if (decl_p)
1841 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1843 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1844 if (dv_as_opaque (node->dv) == dv_as_opaque (dv)
1845 && node->offset == offset)
1846 break;
1847 if (!node)
1848 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
1849 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1852 /* Return true if we should track a location that is OFFSET bytes from
1853 a variable. Store the constant offset in *OFFSET_OUT if so. */
1855 static bool
1856 track_offset_p (poly_int64 offset, HOST_WIDE_INT *offset_out)
1858 HOST_WIDE_INT const_offset;
1859 if (!offset.is_constant (&const_offset)
1860 || !IN_RANGE (const_offset, 0, MAX_VAR_PARTS - 1))
1861 return false;
1862 *offset_out = const_offset;
1863 return true;
1866 /* Return the offset of a register that track_offset_p says we
1867 should track. */
1869 static HOST_WIDE_INT
1870 get_tracked_reg_offset (rtx loc)
1872 HOST_WIDE_INT offset;
1873 if (!track_offset_p (REG_OFFSET (loc), &offset))
1874 gcc_unreachable ();
1875 return offset;
1878 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1880 static void
1881 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1882 rtx set_src)
1884 tree decl = REG_EXPR (loc);
1885 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1887 var_reg_decl_set (set, loc, initialized,
1888 dv_from_decl (decl), offset, set_src, INSERT);
1891 static enum var_init_status
1892 get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1894 variable *var;
1895 int i;
1896 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1898 if (! flag_var_tracking_uninit)
1899 return VAR_INIT_STATUS_INITIALIZED;
1901 var = shared_hash_find (set->vars, dv);
1902 if (var)
1904 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1906 location_chain *nextp;
1907 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1908 if (rtx_equal_p (nextp->loc, loc))
1910 ret_val = nextp->init;
1911 break;
1916 return ret_val;
1919 /* Delete current content of register LOC in dataflow set SET and set
1920 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1921 MODIFY is true, any other live copies of the same variable part are
1922 also deleted from the dataflow set, otherwise the variable part is
1923 assumed to be copied from another location holding the same
1924 part. */
1926 static void
1927 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1928 enum var_init_status initialized, rtx set_src)
1930 tree decl = REG_EXPR (loc);
1931 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1932 attrs *node, *next;
1933 attrs **nextp;
1935 decl = var_debug_decl (decl);
1937 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1938 initialized = get_init_value (set, loc, dv_from_decl (decl));
1940 nextp = &set->regs[REGNO (loc)];
1941 for (node = *nextp; node; node = next)
1943 next = node->next;
1944 if (dv_as_opaque (node->dv) != decl || node->offset != offset)
1946 delete_variable_part (set, node->loc, node->dv, node->offset);
1947 delete node;
1948 *nextp = next;
1950 else
1952 node->loc = loc;
1953 nextp = &node->next;
1956 if (modify)
1957 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1958 var_reg_set (set, loc, initialized, set_src);
1961 /* Delete the association of register LOC in dataflow set SET with any
1962 variables that aren't onepart. If CLOBBER is true, also delete any
1963 other live copies of the same variable part, and delete the
1964 association with onepart dvs too. */
1966 static void
1967 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1969 attrs **nextp = &set->regs[REGNO (loc)];
1970 attrs *node, *next;
1972 HOST_WIDE_INT offset;
1973 if (clobber && track_offset_p (REG_OFFSET (loc), &offset))
1975 tree decl = REG_EXPR (loc);
1977 decl = var_debug_decl (decl);
1979 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1982 for (node = *nextp; node; node = next)
1984 next = node->next;
1985 if (clobber || !dv_onepart_p (node->dv))
1987 delete_variable_part (set, node->loc, node->dv, node->offset);
1988 delete node;
1989 *nextp = next;
1991 else
1992 nextp = &node->next;
1996 /* Delete content of register with number REGNO in dataflow set SET. */
1998 static void
1999 var_regno_delete (dataflow_set *set, int regno)
2001 attrs **reg = &set->regs[regno];
2002 attrs *node, *next;
2004 for (node = *reg; node; node = next)
2006 next = node->next;
2007 delete_variable_part (set, node->loc, node->dv, node->offset);
2008 delete node;
2010 *reg = NULL;
2013 /* Return true if I is the negated value of a power of two. */
2014 static bool
2015 negative_power_of_two_p (HOST_WIDE_INT i)
2017 unsigned HOST_WIDE_INT x = -(unsigned HOST_WIDE_INT)i;
2018 return pow2_or_zerop (x);
2021 /* Strip constant offsets and alignments off of LOC. Return the base
2022 expression. */
2024 static rtx
2025 vt_get_canonicalize_base (rtx loc)
2027 while ((GET_CODE (loc) == PLUS
2028 || GET_CODE (loc) == AND)
2029 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2030 && (GET_CODE (loc) != AND
2031 || negative_power_of_two_p (INTVAL (XEXP (loc, 1)))))
2032 loc = XEXP (loc, 0);
2034 return loc;
2037 /* This caches canonicalized addresses for VALUEs, computed using
2038 information in the global cselib table. */
2039 static hash_map<rtx, rtx> *global_get_addr_cache;
2041 /* This caches canonicalized addresses for VALUEs, computed using
2042 information from the global cache and information pertaining to a
2043 basic block being analyzed. */
2044 static hash_map<rtx, rtx> *local_get_addr_cache;
2046 static rtx vt_canonicalize_addr (dataflow_set *, rtx);
2048 /* Return the canonical address for LOC, that must be a VALUE, using a
2049 cached global equivalence or computing it and storing it in the
2050 global cache. */
2052 static rtx
2053 get_addr_from_global_cache (rtx const loc)
2055 rtx x;
2057 gcc_checking_assert (GET_CODE (loc) == VALUE);
2059 bool existed;
2060 rtx *slot = &global_get_addr_cache->get_or_insert (loc, &existed);
2061 if (existed)
2062 return *slot;
2064 x = canon_rtx (get_addr (loc));
2066 /* Tentative, avoiding infinite recursion. */
2067 *slot = x;
2069 if (x != loc)
2071 rtx nx = vt_canonicalize_addr (NULL, x);
2072 if (nx != x)
2074 /* The table may have moved during recursion, recompute
2075 SLOT. */
2076 *global_get_addr_cache->get (loc) = x = nx;
2080 return x;
2083 /* Return the canonical address for LOC, that must be a VALUE, using a
2084 cached local equivalence or computing it and storing it in the
2085 local cache. */
2087 static rtx
2088 get_addr_from_local_cache (dataflow_set *set, rtx const loc)
2090 rtx x;
2091 decl_or_value dv;
2092 variable *var;
2093 location_chain *l;
2095 gcc_checking_assert (GET_CODE (loc) == VALUE);
2097 bool existed;
2098 rtx *slot = &local_get_addr_cache->get_or_insert (loc, &existed);
2099 if (existed)
2100 return *slot;
2102 x = get_addr_from_global_cache (loc);
2104 /* Tentative, avoiding infinite recursion. */
2105 *slot = x;
2107 /* Recurse to cache local expansion of X, or if we need to search
2108 for a VALUE in the expansion. */
2109 if (x != loc)
2111 rtx nx = vt_canonicalize_addr (set, x);
2112 if (nx != x)
2114 slot = local_get_addr_cache->get (loc);
2115 *slot = x = nx;
2117 return x;
2120 dv = dv_from_rtx (x);
2121 var = shared_hash_find (set->vars, dv);
2122 if (!var)
2123 return x;
2125 /* Look for an improved equivalent expression. */
2126 for (l = var->var_part[0].loc_chain; l; l = l->next)
2128 rtx base = vt_get_canonicalize_base (l->loc);
2129 if (GET_CODE (base) == VALUE
2130 && canon_value_cmp (base, loc))
2132 rtx nx = vt_canonicalize_addr (set, l->loc);
2133 if (x != nx)
2135 slot = local_get_addr_cache->get (loc);
2136 *slot = x = nx;
2138 break;
2142 return x;
2145 /* Canonicalize LOC using equivalences from SET in addition to those
2146 in the cselib static table. It expects a VALUE-based expression,
2147 and it will only substitute VALUEs with other VALUEs or
2148 function-global equivalences, so that, if two addresses have base
2149 VALUEs that are locally or globally related in ways that
2150 memrefs_conflict_p cares about, they will both canonicalize to
2151 expressions that have the same base VALUE.
2153 The use of VALUEs as canonical base addresses enables the canonical
2154 RTXs to remain unchanged globally, if they resolve to a constant,
2155 or throughout a basic block otherwise, so that they can be cached
2156 and the cache needs not be invalidated when REGs, MEMs or such
2157 change. */
2159 static rtx
2160 vt_canonicalize_addr (dataflow_set *set, rtx oloc)
2162 HOST_WIDE_INT ofst = 0;
2163 machine_mode mode = GET_MODE (oloc);
2164 rtx loc = oloc;
2165 rtx x;
2166 bool retry = true;
2168 while (retry)
2170 while (GET_CODE (loc) == PLUS
2171 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2173 ofst += INTVAL (XEXP (loc, 1));
2174 loc = XEXP (loc, 0);
2177 /* Alignment operations can't normally be combined, so just
2178 canonicalize the base and we're done. We'll normally have
2179 only one stack alignment anyway. */
2180 if (GET_CODE (loc) == AND
2181 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2182 && negative_power_of_two_p (INTVAL (XEXP (loc, 1))))
2184 x = vt_canonicalize_addr (set, XEXP (loc, 0));
2185 if (x != XEXP (loc, 0))
2186 loc = gen_rtx_AND (mode, x, XEXP (loc, 1));
2187 retry = false;
2190 if (GET_CODE (loc) == VALUE)
2192 if (set)
2193 loc = get_addr_from_local_cache (set, loc);
2194 else
2195 loc = get_addr_from_global_cache (loc);
2197 /* Consolidate plus_constants. */
2198 while (ofst && GET_CODE (loc) == PLUS
2199 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2201 ofst += INTVAL (XEXP (loc, 1));
2202 loc = XEXP (loc, 0);
2205 retry = false;
2207 else
2209 x = canon_rtx (loc);
2210 if (retry)
2211 retry = (x != loc);
2212 loc = x;
2216 /* Add OFST back in. */
2217 if (ofst)
2219 /* Don't build new RTL if we can help it. */
2220 if (GET_CODE (oloc) == PLUS
2221 && XEXP (oloc, 0) == loc
2222 && INTVAL (XEXP (oloc, 1)) == ofst)
2223 return oloc;
2225 loc = plus_constant (mode, loc, ofst);
2228 return loc;
2231 /* Return true iff there's a true dependence between MLOC and LOC.
2232 MADDR must be a canonicalized version of MLOC's address. */
2234 static inline bool
2235 vt_canon_true_dep (dataflow_set *set, rtx mloc, rtx maddr, rtx loc)
2237 if (GET_CODE (loc) != MEM)
2238 return false;
2240 rtx addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2241 if (!canon_true_dependence (mloc, GET_MODE (mloc), maddr, loc, addr))
2242 return false;
2244 return true;
2247 /* Hold parameters for the hashtab traversal function
2248 drop_overlapping_mem_locs, see below. */
2250 struct overlapping_mems
2252 dataflow_set *set;
2253 rtx loc, addr;
2256 /* Remove all MEMs that overlap with COMS->LOC from the location list
2257 of a hash table entry for a onepart variable. COMS->ADDR must be a
2258 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2259 canonicalized itself. */
2262 drop_overlapping_mem_locs (variable **slot, overlapping_mems *coms)
2264 dataflow_set *set = coms->set;
2265 rtx mloc = coms->loc, addr = coms->addr;
2266 variable *var = *slot;
2268 if (var->onepart != NOT_ONEPART)
2270 location_chain *loc, **locp;
2271 bool changed = false;
2272 rtx cur_loc;
2274 gcc_assert (var->n_var_parts == 1);
2276 if (shared_var_p (var, set->vars))
2278 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
2279 if (vt_canon_true_dep (set, mloc, addr, loc->loc))
2280 break;
2282 if (!loc)
2283 return 1;
2285 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
2286 var = *slot;
2287 gcc_assert (var->n_var_parts == 1);
2290 if (VAR_LOC_1PAUX (var))
2291 cur_loc = VAR_LOC_FROM (var);
2292 else
2293 cur_loc = var->var_part[0].cur_loc;
2295 for (locp = &var->var_part[0].loc_chain, loc = *locp;
2296 loc; loc = *locp)
2298 if (!vt_canon_true_dep (set, mloc, addr, loc->loc))
2300 locp = &loc->next;
2301 continue;
2304 *locp = loc->next;
2305 /* If we have deleted the location which was last emitted
2306 we have to emit new location so add the variable to set
2307 of changed variables. */
2308 if (cur_loc == loc->loc)
2310 changed = true;
2311 var->var_part[0].cur_loc = NULL;
2312 if (VAR_LOC_1PAUX (var))
2313 VAR_LOC_FROM (var) = NULL;
2315 delete loc;
2318 if (!var->var_part[0].loc_chain)
2320 var->n_var_parts--;
2321 changed = true;
2323 if (changed)
2324 variable_was_changed (var, set);
2327 return 1;
2330 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2332 static void
2333 clobber_overlapping_mems (dataflow_set *set, rtx loc)
2335 struct overlapping_mems coms;
2337 gcc_checking_assert (GET_CODE (loc) == MEM);
2339 coms.set = set;
2340 coms.loc = canon_rtx (loc);
2341 coms.addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2343 set->traversed_vars = set->vars;
2344 shared_hash_htab (set->vars)
2345 ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms);
2346 set->traversed_vars = NULL;
2349 /* Set the location of DV, OFFSET as the MEM LOC. */
2351 static void
2352 var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2353 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
2354 enum insert_option iopt)
2356 if (dv_is_decl_p (dv))
2357 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
2359 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
2362 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2363 SET to LOC.
2364 Adjust the address first if it is stack pointer based. */
2366 static void
2367 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2368 rtx set_src)
2370 tree decl = MEM_EXPR (loc);
2371 HOST_WIDE_INT offset = int_mem_offset (loc);
2373 var_mem_decl_set (set, loc, initialized,
2374 dv_from_decl (decl), offset, set_src, INSERT);
2377 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2378 dataflow set SET to LOC. If MODIFY is true, any other live copies
2379 of the same variable part are also deleted from the dataflow set,
2380 otherwise the variable part is assumed to be copied from another
2381 location holding the same part.
2382 Adjust the address first if it is stack pointer based. */
2384 static void
2385 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
2386 enum var_init_status initialized, rtx set_src)
2388 tree decl = MEM_EXPR (loc);
2389 HOST_WIDE_INT offset = int_mem_offset (loc);
2391 clobber_overlapping_mems (set, loc);
2392 decl = var_debug_decl (decl);
2394 if (initialized == VAR_INIT_STATUS_UNKNOWN)
2395 initialized = get_init_value (set, loc, dv_from_decl (decl));
2397 if (modify)
2398 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, set_src);
2399 var_mem_set (set, loc, initialized, set_src);
2402 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2403 true, also delete any other live copies of the same variable part.
2404 Adjust the address first if it is stack pointer based. */
2406 static void
2407 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
2409 tree decl = MEM_EXPR (loc);
2410 HOST_WIDE_INT offset = int_mem_offset (loc);
2412 clobber_overlapping_mems (set, loc);
2413 decl = var_debug_decl (decl);
2414 if (clobber)
2415 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
2416 delete_variable_part (set, loc, dv_from_decl (decl), offset);
2419 /* Return true if LOC should not be expanded for location expressions,
2420 or used in them. */
2422 static inline bool
2423 unsuitable_loc (rtx loc)
2425 switch (GET_CODE (loc))
2427 case PC:
2428 case SCRATCH:
2429 case CC0:
2430 case ASM_INPUT:
2431 case ASM_OPERANDS:
2432 return true;
2434 default:
2435 return false;
2439 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2440 bound to it. */
2442 static inline void
2443 val_bind (dataflow_set *set, rtx val, rtx loc, bool modified)
2445 if (REG_P (loc))
2447 if (modified)
2448 var_regno_delete (set, REGNO (loc));
2449 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2450 dv_from_value (val), 0, NULL_RTX, INSERT);
2452 else if (MEM_P (loc))
2454 struct elt_loc_list *l = CSELIB_VAL_PTR (val)->locs;
2456 if (modified)
2457 clobber_overlapping_mems (set, loc);
2459 if (l && GET_CODE (l->loc) == VALUE)
2460 l = canonical_cselib_val (CSELIB_VAL_PTR (l->loc))->locs;
2462 /* If this MEM is a global constant, we don't need it in the
2463 dynamic tables. ??? We should test this before emitting the
2464 micro-op in the first place. */
2465 while (l)
2466 if (GET_CODE (l->loc) == MEM && XEXP (l->loc, 0) == XEXP (loc, 0))
2467 break;
2468 else
2469 l = l->next;
2471 if (!l)
2472 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2473 dv_from_value (val), 0, NULL_RTX, INSERT);
2475 else
2477 /* Other kinds of equivalences are necessarily static, at least
2478 so long as we do not perform substitutions while merging
2479 expressions. */
2480 gcc_unreachable ();
2481 set_variable_part (set, loc, dv_from_value (val), 0,
2482 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2486 /* Bind a value to a location it was just stored in. If MODIFIED
2487 holds, assume the location was modified, detaching it from any
2488 values bound to it. */
2490 static void
2491 val_store (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn,
2492 bool modified)
2494 cselib_val *v = CSELIB_VAL_PTR (val);
2496 gcc_assert (cselib_preserved_value_p (v));
2498 if (dump_file)
2500 fprintf (dump_file, "%i: ", insn ? INSN_UID (insn) : 0);
2501 print_inline_rtx (dump_file, loc, 0);
2502 fprintf (dump_file, " evaluates to ");
2503 print_inline_rtx (dump_file, val, 0);
2504 if (v->locs)
2506 struct elt_loc_list *l;
2507 for (l = v->locs; l; l = l->next)
2509 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
2510 print_inline_rtx (dump_file, l->loc, 0);
2513 fprintf (dump_file, "\n");
2516 gcc_checking_assert (!unsuitable_loc (loc));
2518 val_bind (set, val, loc, modified);
2521 /* Clear (canonical address) slots that reference X. */
2523 bool
2524 local_get_addr_clear_given_value (rtx const &, rtx *slot, rtx x)
2526 if (vt_get_canonicalize_base (*slot) == x)
2527 *slot = NULL;
2528 return true;
2531 /* Reset this node, detaching all its equivalences. Return the slot
2532 in the variable hash table that holds dv, if there is one. */
2534 static void
2535 val_reset (dataflow_set *set, decl_or_value dv)
2537 variable *var = shared_hash_find (set->vars, dv) ;
2538 location_chain *node;
2539 rtx cval;
2541 if (!var || !var->n_var_parts)
2542 return;
2544 gcc_assert (var->n_var_parts == 1);
2546 if (var->onepart == ONEPART_VALUE)
2548 rtx x = dv_as_value (dv);
2550 /* Relationships in the global cache don't change, so reset the
2551 local cache entry only. */
2552 rtx *slot = local_get_addr_cache->get (x);
2553 if (slot)
2555 /* If the value resolved back to itself, odds are that other
2556 values may have cached it too. These entries now refer
2557 to the old X, so detach them too. Entries that used the
2558 old X but resolved to something else remain ok as long as
2559 that something else isn't also reset. */
2560 if (*slot == x)
2561 local_get_addr_cache
2562 ->traverse<rtx, local_get_addr_clear_given_value> (x);
2563 *slot = NULL;
2567 cval = NULL;
2568 for (node = var->var_part[0].loc_chain; node; node = node->next)
2569 if (GET_CODE (node->loc) == VALUE
2570 && canon_value_cmp (node->loc, cval))
2571 cval = node->loc;
2573 for (node = var->var_part[0].loc_chain; node; node = node->next)
2574 if (GET_CODE (node->loc) == VALUE && cval != node->loc)
2576 /* Redirect the equivalence link to the new canonical
2577 value, or simply remove it if it would point at
2578 itself. */
2579 if (cval)
2580 set_variable_part (set, cval, dv_from_value (node->loc),
2581 0, node->init, node->set_src, NO_INSERT);
2582 delete_variable_part (set, dv_as_value (dv),
2583 dv_from_value (node->loc), 0);
2586 if (cval)
2588 decl_or_value cdv = dv_from_value (cval);
2590 /* Keep the remaining values connected, accumulating links
2591 in the canonical value. */
2592 for (node = var->var_part[0].loc_chain; node; node = node->next)
2594 if (node->loc == cval)
2595 continue;
2596 else if (GET_CODE (node->loc) == REG)
2597 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
2598 node->set_src, NO_INSERT);
2599 else if (GET_CODE (node->loc) == MEM)
2600 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
2601 node->set_src, NO_INSERT);
2602 else
2603 set_variable_part (set, node->loc, cdv, 0,
2604 node->init, node->set_src, NO_INSERT);
2608 /* We remove this last, to make sure that the canonical value is not
2609 removed to the point of requiring reinsertion. */
2610 if (cval)
2611 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
2613 clobber_variable_part (set, NULL, dv, 0, NULL);
2616 /* Find the values in a given location and map the val to another
2617 value, if it is unique, or add the location as one holding the
2618 value. */
2620 static void
2621 val_resolve (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn)
2623 decl_or_value dv = dv_from_value (val);
2625 if (dump_file && (dump_flags & TDF_DETAILS))
2627 if (insn)
2628 fprintf (dump_file, "%i: ", INSN_UID (insn));
2629 else
2630 fprintf (dump_file, "head: ");
2631 print_inline_rtx (dump_file, val, 0);
2632 fputs (" is at ", dump_file);
2633 print_inline_rtx (dump_file, loc, 0);
2634 fputc ('\n', dump_file);
2637 val_reset (set, dv);
2639 gcc_checking_assert (!unsuitable_loc (loc));
2641 if (REG_P (loc))
2643 attrs *node, *found = NULL;
2645 for (node = set->regs[REGNO (loc)]; node; node = node->next)
2646 if (dv_is_value_p (node->dv)
2647 && GET_MODE (dv_as_value (node->dv)) == GET_MODE (loc))
2649 found = node;
2651 /* Map incoming equivalences. ??? Wouldn't it be nice if
2652 we just started sharing the location lists? Maybe a
2653 circular list ending at the value itself or some
2654 such. */
2655 set_variable_part (set, dv_as_value (node->dv),
2656 dv_from_value (val), node->offset,
2657 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2658 set_variable_part (set, val, node->dv, node->offset,
2659 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2662 /* If we didn't find any equivalence, we need to remember that
2663 this value is held in the named register. */
2664 if (found)
2665 return;
2667 /* ??? Attempt to find and merge equivalent MEMs or other
2668 expressions too. */
2670 val_bind (set, val, loc, false);
2673 /* Initialize dataflow set SET to be empty.
2674 VARS_SIZE is the initial size of hash table VARS. */
2676 static void
2677 dataflow_set_init (dataflow_set *set)
2679 init_attrs_list_set (set->regs);
2680 set->vars = shared_hash_copy (empty_shared_hash);
2681 set->stack_adjust = 0;
2682 set->traversed_vars = NULL;
2685 /* Delete the contents of dataflow set SET. */
2687 static void
2688 dataflow_set_clear (dataflow_set *set)
2690 int i;
2692 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2693 attrs_list_clear (&set->regs[i]);
2695 shared_hash_destroy (set->vars);
2696 set->vars = shared_hash_copy (empty_shared_hash);
2699 /* Copy the contents of dataflow set SRC to DST. */
2701 static void
2702 dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
2704 int i;
2706 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2707 attrs_list_copy (&dst->regs[i], src->regs[i]);
2709 shared_hash_destroy (dst->vars);
2710 dst->vars = shared_hash_copy (src->vars);
2711 dst->stack_adjust = src->stack_adjust;
2714 /* Information for merging lists of locations for a given offset of variable.
2716 struct variable_union_info
2718 /* Node of the location chain. */
2719 location_chain *lc;
2721 /* The sum of positions in the input chains. */
2722 int pos;
2724 /* The position in the chain of DST dataflow set. */
2725 int pos_dst;
2728 /* Buffer for location list sorting and its allocated size. */
2729 static struct variable_union_info *vui_vec;
2730 static int vui_allocated;
2732 /* Compare function for qsort, order the structures by POS element. */
2734 static int
2735 variable_union_info_cmp_pos (const void *n1, const void *n2)
2737 const struct variable_union_info *const i1 =
2738 (const struct variable_union_info *) n1;
2739 const struct variable_union_info *const i2 =
2740 ( const struct variable_union_info *) n2;
2742 if (i1->pos != i2->pos)
2743 return i1->pos - i2->pos;
2745 return (i1->pos_dst - i2->pos_dst);
2748 /* Compute union of location parts of variable *SLOT and the same variable
2749 from hash table DATA. Compute "sorted" union of the location chains
2750 for common offsets, i.e. the locations of a variable part are sorted by
2751 a priority where the priority is the sum of the positions in the 2 chains
2752 (if a location is only in one list the position in the second list is
2753 defined to be larger than the length of the chains).
2754 When we are updating the location parts the newest location is in the
2755 beginning of the chain, so when we do the described "sorted" union
2756 we keep the newest locations in the beginning. */
2758 static int
2759 variable_union (variable *src, dataflow_set *set)
2761 variable *dst;
2762 variable **dstp;
2763 int i, j, k;
2765 dstp = shared_hash_find_slot (set->vars, src->dv);
2766 if (!dstp || !*dstp)
2768 src->refcount++;
2770 dst_can_be_shared = false;
2771 if (!dstp)
2772 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2774 *dstp = src;
2776 /* Continue traversing the hash table. */
2777 return 1;
2779 else
2780 dst = *dstp;
2782 gcc_assert (src->n_var_parts);
2783 gcc_checking_assert (src->onepart == dst->onepart);
2785 /* We can combine one-part variables very efficiently, because their
2786 entries are in canonical order. */
2787 if (src->onepart)
2789 location_chain **nodep, *dnode, *snode;
2791 gcc_assert (src->n_var_parts == 1
2792 && dst->n_var_parts == 1);
2794 snode = src->var_part[0].loc_chain;
2795 gcc_assert (snode);
2797 restart_onepart_unshared:
2798 nodep = &dst->var_part[0].loc_chain;
2799 dnode = *nodep;
2800 gcc_assert (dnode);
2802 while (snode)
2804 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2806 if (r > 0)
2808 location_chain *nnode;
2810 if (shared_var_p (dst, set->vars))
2812 dstp = unshare_variable (set, dstp, dst,
2813 VAR_INIT_STATUS_INITIALIZED);
2814 dst = *dstp;
2815 goto restart_onepart_unshared;
2818 *nodep = nnode = new location_chain;
2819 nnode->loc = snode->loc;
2820 nnode->init = snode->init;
2821 if (!snode->set_src || MEM_P (snode->set_src))
2822 nnode->set_src = NULL;
2823 else
2824 nnode->set_src = snode->set_src;
2825 nnode->next = dnode;
2826 dnode = nnode;
2828 else if (r == 0)
2829 gcc_checking_assert (rtx_equal_p (dnode->loc, snode->loc));
2831 if (r >= 0)
2832 snode = snode->next;
2834 nodep = &dnode->next;
2835 dnode = *nodep;
2838 return 1;
2841 gcc_checking_assert (!src->onepart);
2843 /* Count the number of location parts, result is K. */
2844 for (i = 0, j = 0, k = 0;
2845 i < src->n_var_parts && j < dst->n_var_parts; k++)
2847 if (VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2849 i++;
2850 j++;
2852 else if (VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
2853 i++;
2854 else
2855 j++;
2857 k += src->n_var_parts - i;
2858 k += dst->n_var_parts - j;
2860 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2861 thus there are at most MAX_VAR_PARTS different offsets. */
2862 gcc_checking_assert (dst->onepart ? k == 1 : k <= MAX_VAR_PARTS);
2864 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2866 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2867 dst = *dstp;
2870 i = src->n_var_parts - 1;
2871 j = dst->n_var_parts - 1;
2872 dst->n_var_parts = k;
2874 for (k--; k >= 0; k--)
2876 location_chain *node, *node2;
2878 if (i >= 0 && j >= 0
2879 && VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2881 /* Compute the "sorted" union of the chains, i.e. the locations which
2882 are in both chains go first, they are sorted by the sum of
2883 positions in the chains. */
2884 int dst_l, src_l;
2885 int ii, jj, n;
2886 struct variable_union_info *vui;
2888 /* If DST is shared compare the location chains.
2889 If they are different we will modify the chain in DST with
2890 high probability so make a copy of DST. */
2891 if (shared_var_p (dst, set->vars))
2893 for (node = src->var_part[i].loc_chain,
2894 node2 = dst->var_part[j].loc_chain; node && node2;
2895 node = node->next, node2 = node2->next)
2897 if (!((REG_P (node2->loc)
2898 && REG_P (node->loc)
2899 && REGNO (node2->loc) == REGNO (node->loc))
2900 || rtx_equal_p (node2->loc, node->loc)))
2902 if (node2->init < node->init)
2903 node2->init = node->init;
2904 break;
2907 if (node || node2)
2909 dstp = unshare_variable (set, dstp, dst,
2910 VAR_INIT_STATUS_UNKNOWN);
2911 dst = (variable *)*dstp;
2915 src_l = 0;
2916 for (node = src->var_part[i].loc_chain; node; node = node->next)
2917 src_l++;
2918 dst_l = 0;
2919 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2920 dst_l++;
2922 if (dst_l == 1)
2924 /* The most common case, much simpler, no qsort is needed. */
2925 location_chain *dstnode = dst->var_part[j].loc_chain;
2926 dst->var_part[k].loc_chain = dstnode;
2927 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
2928 node2 = dstnode;
2929 for (node = src->var_part[i].loc_chain; node; node = node->next)
2930 if (!((REG_P (dstnode->loc)
2931 && REG_P (node->loc)
2932 && REGNO (dstnode->loc) == REGNO (node->loc))
2933 || rtx_equal_p (dstnode->loc, node->loc)))
2935 location_chain *new_node;
2937 /* Copy the location from SRC. */
2938 new_node = new location_chain;
2939 new_node->loc = node->loc;
2940 new_node->init = node->init;
2941 if (!node->set_src || MEM_P (node->set_src))
2942 new_node->set_src = NULL;
2943 else
2944 new_node->set_src = node->set_src;
2945 node2->next = new_node;
2946 node2 = new_node;
2948 node2->next = NULL;
2950 else
2952 if (src_l + dst_l > vui_allocated)
2954 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l);
2955 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,
2956 vui_allocated);
2958 vui = vui_vec;
2960 /* Fill in the locations from DST. */
2961 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2962 node = node->next, jj++)
2964 vui[jj].lc = node;
2965 vui[jj].pos_dst = jj;
2967 /* Pos plus value larger than a sum of 2 valid positions. */
2968 vui[jj].pos = jj + src_l + dst_l;
2971 /* Fill in the locations from SRC. */
2972 n = dst_l;
2973 for (node = src->var_part[i].loc_chain, ii = 0; node;
2974 node = node->next, ii++)
2976 /* Find location from NODE. */
2977 for (jj = 0; jj < dst_l; jj++)
2979 if ((REG_P (vui[jj].lc->loc)
2980 && REG_P (node->loc)
2981 && REGNO (vui[jj].lc->loc) == REGNO (node->loc))
2982 || rtx_equal_p (vui[jj].lc->loc, node->loc))
2984 vui[jj].pos = jj + ii;
2985 break;
2988 if (jj >= dst_l) /* The location has not been found. */
2990 location_chain *new_node;
2992 /* Copy the location from SRC. */
2993 new_node = new location_chain;
2994 new_node->loc = node->loc;
2995 new_node->init = node->init;
2996 if (!node->set_src || MEM_P (node->set_src))
2997 new_node->set_src = NULL;
2998 else
2999 new_node->set_src = node->set_src;
3000 vui[n].lc = new_node;
3001 vui[n].pos_dst = src_l + dst_l;
3002 vui[n].pos = ii + src_l + dst_l;
3003 n++;
3007 if (dst_l == 2)
3009 /* Special case still very common case. For dst_l == 2
3010 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3011 vui[i].pos == i + src_l + dst_l. */
3012 if (vui[0].pos > vui[1].pos)
3014 /* Order should be 1, 0, 2... */
3015 dst->var_part[k].loc_chain = vui[1].lc;
3016 vui[1].lc->next = vui[0].lc;
3017 if (n >= 3)
3019 vui[0].lc->next = vui[2].lc;
3020 vui[n - 1].lc->next = NULL;
3022 else
3023 vui[0].lc->next = NULL;
3024 ii = 3;
3026 else
3028 dst->var_part[k].loc_chain = vui[0].lc;
3029 if (n >= 3 && vui[2].pos < vui[1].pos)
3031 /* Order should be 0, 2, 1, 3... */
3032 vui[0].lc->next = vui[2].lc;
3033 vui[2].lc->next = vui[1].lc;
3034 if (n >= 4)
3036 vui[1].lc->next = vui[3].lc;
3037 vui[n - 1].lc->next = NULL;
3039 else
3040 vui[1].lc->next = NULL;
3041 ii = 4;
3043 else
3045 /* Order should be 0, 1, 2... */
3046 ii = 1;
3047 vui[n - 1].lc->next = NULL;
3050 for (; ii < n; ii++)
3051 vui[ii - 1].lc->next = vui[ii].lc;
3053 else
3055 qsort (vui, n, sizeof (struct variable_union_info),
3056 variable_union_info_cmp_pos);
3058 /* Reconnect the nodes in sorted order. */
3059 for (ii = 1; ii < n; ii++)
3060 vui[ii - 1].lc->next = vui[ii].lc;
3061 vui[n - 1].lc->next = NULL;
3062 dst->var_part[k].loc_chain = vui[0].lc;
3065 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
3067 i--;
3068 j--;
3070 else if ((i >= 0 && j >= 0
3071 && VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
3072 || i < 0)
3074 dst->var_part[k] = dst->var_part[j];
3075 j--;
3077 else if ((i >= 0 && j >= 0
3078 && VAR_PART_OFFSET (src, i) > VAR_PART_OFFSET (dst, j))
3079 || j < 0)
3081 location_chain **nextp;
3083 /* Copy the chain from SRC. */
3084 nextp = &dst->var_part[k].loc_chain;
3085 for (node = src->var_part[i].loc_chain; node; node = node->next)
3087 location_chain *new_lc;
3089 new_lc = new location_chain;
3090 new_lc->next = NULL;
3091 new_lc->init = node->init;
3092 if (!node->set_src || MEM_P (node->set_src))
3093 new_lc->set_src = NULL;
3094 else
3095 new_lc->set_src = node->set_src;
3096 new_lc->loc = node->loc;
3098 *nextp = new_lc;
3099 nextp = &new_lc->next;
3102 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (src, i);
3103 i--;
3105 dst->var_part[k].cur_loc = NULL;
3108 if (flag_var_tracking_uninit)
3109 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
3111 location_chain *node, *node2;
3112 for (node = src->var_part[i].loc_chain; node; node = node->next)
3113 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
3114 if (rtx_equal_p (node->loc, node2->loc))
3116 if (node->init > node2->init)
3117 node2->init = node->init;
3121 /* Continue traversing the hash table. */
3122 return 1;
3125 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3127 static void
3128 dataflow_set_union (dataflow_set *dst, dataflow_set *src)
3130 int i;
3132 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3133 attrs_list_union (&dst->regs[i], src->regs[i]);
3135 if (dst->vars == empty_shared_hash)
3137 shared_hash_destroy (dst->vars);
3138 dst->vars = shared_hash_copy (src->vars);
3140 else
3142 variable_iterator_type hi;
3143 variable *var;
3145 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars),
3146 var, variable, hi)
3147 variable_union (var, dst);
3151 /* Whether the value is currently being expanded. */
3152 #define VALUE_RECURSED_INTO(x) \
3153 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3155 /* Whether no expansion was found, saving useless lookups.
3156 It must only be set when VALUE_CHANGED is clear. */
3157 #define NO_LOC_P(x) \
3158 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3160 /* Whether cur_loc in the value needs to be (re)computed. */
3161 #define VALUE_CHANGED(x) \
3162 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3163 /* Whether cur_loc in the decl needs to be (re)computed. */
3164 #define DECL_CHANGED(x) TREE_VISITED (x)
3166 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3167 user DECLs, this means they're in changed_variables. Values and
3168 debug exprs may be left with this flag set if no user variable
3169 requires them to be evaluated. */
3171 static inline void
3172 set_dv_changed (decl_or_value dv, bool newv)
3174 switch (dv_onepart_p (dv))
3176 case ONEPART_VALUE:
3177 if (newv)
3178 NO_LOC_P (dv_as_value (dv)) = false;
3179 VALUE_CHANGED (dv_as_value (dv)) = newv;
3180 break;
3182 case ONEPART_DEXPR:
3183 if (newv)
3184 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv))) = false;
3185 /* Fall through. */
3187 default:
3188 DECL_CHANGED (dv_as_decl (dv)) = newv;
3189 break;
3193 /* Return true if DV needs to have its cur_loc recomputed. */
3195 static inline bool
3196 dv_changed_p (decl_or_value dv)
3198 return (dv_is_value_p (dv)
3199 ? VALUE_CHANGED (dv_as_value (dv))
3200 : DECL_CHANGED (dv_as_decl (dv)));
3203 /* Return a location list node whose loc is rtx_equal to LOC, in the
3204 location list of a one-part variable or value VAR, or in that of
3205 any values recursively mentioned in the location lists. VARS must
3206 be in star-canonical form. */
3208 static location_chain *
3209 find_loc_in_1pdv (rtx loc, variable *var, variable_table_type *vars)
3211 location_chain *node;
3212 enum rtx_code loc_code;
3214 if (!var)
3215 return NULL;
3217 gcc_checking_assert (var->onepart);
3219 if (!var->n_var_parts)
3220 return NULL;
3222 gcc_checking_assert (loc != dv_as_opaque (var->dv));
3224 loc_code = GET_CODE (loc);
3225 for (node = var->var_part[0].loc_chain; node; node = node->next)
3227 decl_or_value dv;
3228 variable *rvar;
3230 if (GET_CODE (node->loc) != loc_code)
3232 if (GET_CODE (node->loc) != VALUE)
3233 continue;
3235 else if (loc == node->loc)
3236 return node;
3237 else if (loc_code != VALUE)
3239 if (rtx_equal_p (loc, node->loc))
3240 return node;
3241 continue;
3244 /* Since we're in star-canonical form, we don't need to visit
3245 non-canonical nodes: one-part variables and non-canonical
3246 values would only point back to the canonical node. */
3247 if (dv_is_value_p (var->dv)
3248 && !canon_value_cmp (node->loc, dv_as_value (var->dv)))
3250 /* Skip all subsequent VALUEs. */
3251 while (node->next && GET_CODE (node->next->loc) == VALUE)
3253 node = node->next;
3254 gcc_checking_assert (!canon_value_cmp (node->loc,
3255 dv_as_value (var->dv)));
3256 if (loc == node->loc)
3257 return node;
3259 continue;
3262 gcc_checking_assert (node == var->var_part[0].loc_chain);
3263 gcc_checking_assert (!node->next);
3265 dv = dv_from_value (node->loc);
3266 rvar = vars->find_with_hash (dv, dv_htab_hash (dv));
3267 return find_loc_in_1pdv (loc, rvar, vars);
3270 /* ??? Gotta look in cselib_val locations too. */
3272 return NULL;
3275 /* Hash table iteration argument passed to variable_merge. */
3276 struct dfset_merge
3278 /* The set in which the merge is to be inserted. */
3279 dataflow_set *dst;
3280 /* The set that we're iterating in. */
3281 dataflow_set *cur;
3282 /* The set that may contain the other dv we are to merge with. */
3283 dataflow_set *src;
3284 /* Number of onepart dvs in src. */
3285 int src_onepart_cnt;
3288 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3289 loc_cmp order, and it is maintained as such. */
3291 static void
3292 insert_into_intersection (location_chain **nodep, rtx loc,
3293 enum var_init_status status)
3295 location_chain *node;
3296 int r;
3298 for (node = *nodep; node; nodep = &node->next, node = *nodep)
3299 if ((r = loc_cmp (node->loc, loc)) == 0)
3301 node->init = MIN (node->init, status);
3302 return;
3304 else if (r > 0)
3305 break;
3307 node = new location_chain;
3309 node->loc = loc;
3310 node->set_src = NULL;
3311 node->init = status;
3312 node->next = *nodep;
3313 *nodep = node;
3316 /* Insert in DEST the intersection of the locations present in both
3317 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3318 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3319 DSM->dst. */
3321 static void
3322 intersect_loc_chains (rtx val, location_chain **dest, struct dfset_merge *dsm,
3323 location_chain *s1node, variable *s2var)
3325 dataflow_set *s1set = dsm->cur;
3326 dataflow_set *s2set = dsm->src;
3327 location_chain *found;
3329 if (s2var)
3331 location_chain *s2node;
3333 gcc_checking_assert (s2var->onepart);
3335 if (s2var->n_var_parts)
3337 s2node = s2var->var_part[0].loc_chain;
3339 for (; s1node && s2node;
3340 s1node = s1node->next, s2node = s2node->next)
3341 if (s1node->loc != s2node->loc)
3342 break;
3343 else if (s1node->loc == val)
3344 continue;
3345 else
3346 insert_into_intersection (dest, s1node->loc,
3347 MIN (s1node->init, s2node->init));
3351 for (; s1node; s1node = s1node->next)
3353 if (s1node->loc == val)
3354 continue;
3356 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
3357 shared_hash_htab (s2set->vars))))
3359 insert_into_intersection (dest, s1node->loc,
3360 MIN (s1node->init, found->init));
3361 continue;
3364 if (GET_CODE (s1node->loc) == VALUE
3365 && !VALUE_RECURSED_INTO (s1node->loc))
3367 decl_or_value dv = dv_from_value (s1node->loc);
3368 variable *svar = shared_hash_find (s1set->vars, dv);
3369 if (svar)
3371 if (svar->n_var_parts == 1)
3373 VALUE_RECURSED_INTO (s1node->loc) = true;
3374 intersect_loc_chains (val, dest, dsm,
3375 svar->var_part[0].loc_chain,
3376 s2var);
3377 VALUE_RECURSED_INTO (s1node->loc) = false;
3382 /* ??? gotta look in cselib_val locations too. */
3384 /* ??? if the location is equivalent to any location in src,
3385 searched recursively
3387 add to dst the values needed to represent the equivalence
3389 telling whether locations S is equivalent to another dv's
3390 location list:
3392 for each location D in the list
3394 if S and D satisfy rtx_equal_p, then it is present
3396 else if D is a value, recurse without cycles
3398 else if S and D have the same CODE and MODE
3400 for each operand oS and the corresponding oD
3402 if oS and oD are not equivalent, then S an D are not equivalent
3404 else if they are RTX vectors
3406 if any vector oS element is not equivalent to its respective oD,
3407 then S and D are not equivalent
3415 /* Return -1 if X should be before Y in a location list for a 1-part
3416 variable, 1 if Y should be before X, and 0 if they're equivalent
3417 and should not appear in the list. */
3419 static int
3420 loc_cmp (rtx x, rtx y)
3422 int i, j, r;
3423 RTX_CODE code = GET_CODE (x);
3424 const char *fmt;
3426 if (x == y)
3427 return 0;
3429 if (REG_P (x))
3431 if (!REG_P (y))
3432 return -1;
3433 gcc_assert (GET_MODE (x) == GET_MODE (y));
3434 if (REGNO (x) == REGNO (y))
3435 return 0;
3436 else if (REGNO (x) < REGNO (y))
3437 return -1;
3438 else
3439 return 1;
3442 if (REG_P (y))
3443 return 1;
3445 if (MEM_P (x))
3447 if (!MEM_P (y))
3448 return -1;
3449 gcc_assert (GET_MODE (x) == GET_MODE (y));
3450 return loc_cmp (XEXP (x, 0), XEXP (y, 0));
3453 if (MEM_P (y))
3454 return 1;
3456 if (GET_CODE (x) == VALUE)
3458 if (GET_CODE (y) != VALUE)
3459 return -1;
3460 /* Don't assert the modes are the same, that is true only
3461 when not recursing. (subreg:QI (value:SI 1:1) 0)
3462 and (subreg:QI (value:DI 2:2) 0) can be compared,
3463 even when the modes are different. */
3464 if (canon_value_cmp (x, y))
3465 return -1;
3466 else
3467 return 1;
3470 if (GET_CODE (y) == VALUE)
3471 return 1;
3473 /* Entry value is the least preferable kind of expression. */
3474 if (GET_CODE (x) == ENTRY_VALUE)
3476 if (GET_CODE (y) != ENTRY_VALUE)
3477 return 1;
3478 gcc_assert (GET_MODE (x) == GET_MODE (y));
3479 return loc_cmp (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
3482 if (GET_CODE (y) == ENTRY_VALUE)
3483 return -1;
3485 if (GET_CODE (x) == GET_CODE (y))
3486 /* Compare operands below. */;
3487 else if (GET_CODE (x) < GET_CODE (y))
3488 return -1;
3489 else
3490 return 1;
3492 gcc_assert (GET_MODE (x) == GET_MODE (y));
3494 if (GET_CODE (x) == DEBUG_EXPR)
3496 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3497 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))
3498 return -1;
3499 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3500 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)));
3501 return 1;
3504 fmt = GET_RTX_FORMAT (code);
3505 for (i = 0; i < GET_RTX_LENGTH (code); i++)
3506 switch (fmt[i])
3508 case 'w':
3509 if (XWINT (x, i) == XWINT (y, i))
3510 break;
3511 else if (XWINT (x, i) < XWINT (y, i))
3512 return -1;
3513 else
3514 return 1;
3516 case 'n':
3517 case 'i':
3518 if (XINT (x, i) == XINT (y, i))
3519 break;
3520 else if (XINT (x, i) < XINT (y, i))
3521 return -1;
3522 else
3523 return 1;
3525 case 'p':
3526 r = compare_sizes_for_sort (SUBREG_BYTE (x), SUBREG_BYTE (y));
3527 if (r != 0)
3528 return r;
3529 break;
3531 case 'V':
3532 case 'E':
3533 /* Compare the vector length first. */
3534 if (XVECLEN (x, i) == XVECLEN (y, i))
3535 /* Compare the vectors elements. */;
3536 else if (XVECLEN (x, i) < XVECLEN (y, i))
3537 return -1;
3538 else
3539 return 1;
3541 for (j = 0; j < XVECLEN (x, i); j++)
3542 if ((r = loc_cmp (XVECEXP (x, i, j),
3543 XVECEXP (y, i, j))))
3544 return r;
3545 break;
3547 case 'e':
3548 if ((r = loc_cmp (XEXP (x, i), XEXP (y, i))))
3549 return r;
3550 break;
3552 case 'S':
3553 case 's':
3554 if (XSTR (x, i) == XSTR (y, i))
3555 break;
3556 if (!XSTR (x, i))
3557 return -1;
3558 if (!XSTR (y, i))
3559 return 1;
3560 if ((r = strcmp (XSTR (x, i), XSTR (y, i))) == 0)
3561 break;
3562 else if (r < 0)
3563 return -1;
3564 else
3565 return 1;
3567 case 'u':
3568 /* These are just backpointers, so they don't matter. */
3569 break;
3571 case '0':
3572 case 't':
3573 break;
3575 /* It is believed that rtx's at this level will never
3576 contain anything but integers and other rtx's,
3577 except for within LABEL_REFs and SYMBOL_REFs. */
3578 default:
3579 gcc_unreachable ();
3581 if (CONST_WIDE_INT_P (x))
3583 /* Compare the vector length first. */
3584 if (CONST_WIDE_INT_NUNITS (x) >= CONST_WIDE_INT_NUNITS (y))
3585 return 1;
3586 else if (CONST_WIDE_INT_NUNITS (x) < CONST_WIDE_INT_NUNITS (y))
3587 return -1;
3589 /* Compare the vectors elements. */;
3590 for (j = CONST_WIDE_INT_NUNITS (x) - 1; j >= 0 ; j--)
3592 if (CONST_WIDE_INT_ELT (x, j) < CONST_WIDE_INT_ELT (y, j))
3593 return -1;
3594 if (CONST_WIDE_INT_ELT (x, j) > CONST_WIDE_INT_ELT (y, j))
3595 return 1;
3599 return 0;
3602 /* Check the order of entries in one-part variables. */
3605 canonicalize_loc_order_check (variable **slot,
3606 dataflow_set *data ATTRIBUTE_UNUSED)
3608 variable *var = *slot;
3609 location_chain *node, *next;
3611 #ifdef ENABLE_RTL_CHECKING
3612 int i;
3613 for (i = 0; i < var->n_var_parts; i++)
3614 gcc_assert (var->var_part[0].cur_loc == NULL);
3615 gcc_assert (!var->in_changed_variables);
3616 #endif
3618 if (!var->onepart)
3619 return 1;
3621 gcc_assert (var->n_var_parts == 1);
3622 node = var->var_part[0].loc_chain;
3623 gcc_assert (node);
3625 while ((next = node->next))
3627 gcc_assert (loc_cmp (node->loc, next->loc) < 0);
3628 node = next;
3631 return 1;
3634 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3635 more likely to be chosen as canonical for an equivalence set.
3636 Ensure less likely values can reach more likely neighbors, making
3637 the connections bidirectional. */
3640 canonicalize_values_mark (variable **slot, dataflow_set *set)
3642 variable *var = *slot;
3643 decl_or_value dv = var->dv;
3644 rtx val;
3645 location_chain *node;
3647 if (!dv_is_value_p (dv))
3648 return 1;
3650 gcc_checking_assert (var->n_var_parts == 1);
3652 val = dv_as_value (dv);
3654 for (node = var->var_part[0].loc_chain; node; node = node->next)
3655 if (GET_CODE (node->loc) == VALUE)
3657 if (canon_value_cmp (node->loc, val))
3658 VALUE_RECURSED_INTO (val) = true;
3659 else
3661 decl_or_value odv = dv_from_value (node->loc);
3662 variable **oslot;
3663 oslot = shared_hash_find_slot_noinsert (set->vars, odv);
3665 set_slot_part (set, val, oslot, odv, 0,
3666 node->init, NULL_RTX);
3668 VALUE_RECURSED_INTO (node->loc) = true;
3672 return 1;
3675 /* Remove redundant entries from equivalence lists in onepart
3676 variables, canonicalizing equivalence sets into star shapes. */
3679 canonicalize_values_star (variable **slot, dataflow_set *set)
3681 variable *var = *slot;
3682 decl_or_value dv = var->dv;
3683 location_chain *node;
3684 decl_or_value cdv;
3685 rtx val, cval;
3686 variable **cslot;
3687 bool has_value;
3688 bool has_marks;
3690 if (!var->onepart)
3691 return 1;
3693 gcc_checking_assert (var->n_var_parts == 1);
3695 if (dv_is_value_p (dv))
3697 cval = dv_as_value (dv);
3698 if (!VALUE_RECURSED_INTO (cval))
3699 return 1;
3700 VALUE_RECURSED_INTO (cval) = false;
3702 else
3703 cval = NULL_RTX;
3705 restart:
3706 val = cval;
3707 has_value = false;
3708 has_marks = false;
3710 gcc_assert (var->n_var_parts == 1);
3712 for (node = var->var_part[0].loc_chain; node; node = node->next)
3713 if (GET_CODE (node->loc) == VALUE)
3715 has_value = true;
3716 if (VALUE_RECURSED_INTO (node->loc))
3717 has_marks = true;
3718 if (canon_value_cmp (node->loc, cval))
3719 cval = node->loc;
3722 if (!has_value)
3723 return 1;
3725 if (cval == val)
3727 if (!has_marks || dv_is_decl_p (dv))
3728 return 1;
3730 /* Keep it marked so that we revisit it, either after visiting a
3731 child node, or after visiting a new parent that might be
3732 found out. */
3733 VALUE_RECURSED_INTO (val) = true;
3735 for (node = var->var_part[0].loc_chain; node; node = node->next)
3736 if (GET_CODE (node->loc) == VALUE
3737 && VALUE_RECURSED_INTO (node->loc))
3739 cval = node->loc;
3740 restart_with_cval:
3741 VALUE_RECURSED_INTO (cval) = false;
3742 dv = dv_from_value (cval);
3743 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3744 if (!slot)
3746 gcc_assert (dv_is_decl_p (var->dv));
3747 /* The canonical value was reset and dropped.
3748 Remove it. */
3749 clobber_variable_part (set, NULL, var->dv, 0, NULL);
3750 return 1;
3752 var = *slot;
3753 gcc_assert (dv_is_value_p (var->dv));
3754 if (var->n_var_parts == 0)
3755 return 1;
3756 gcc_assert (var->n_var_parts == 1);
3757 goto restart;
3760 VALUE_RECURSED_INTO (val) = false;
3762 return 1;
3765 /* Push values to the canonical one. */
3766 cdv = dv_from_value (cval);
3767 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3769 for (node = var->var_part[0].loc_chain; node; node = node->next)
3770 if (node->loc != cval)
3772 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3773 node->init, NULL_RTX);
3774 if (GET_CODE (node->loc) == VALUE)
3776 decl_or_value ndv = dv_from_value (node->loc);
3778 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX,
3779 NO_INSERT);
3781 if (canon_value_cmp (node->loc, val))
3783 /* If it could have been a local minimum, it's not any more,
3784 since it's now neighbor to cval, so it may have to push
3785 to it. Conversely, if it wouldn't have prevailed over
3786 val, then whatever mark it has is fine: if it was to
3787 push, it will now push to a more canonical node, but if
3788 it wasn't, then it has already pushed any values it might
3789 have to. */
3790 VALUE_RECURSED_INTO (node->loc) = true;
3791 /* Make sure we visit node->loc by ensuring we cval is
3792 visited too. */
3793 VALUE_RECURSED_INTO (cval) = true;
3795 else if (!VALUE_RECURSED_INTO (node->loc))
3796 /* If we have no need to "recurse" into this node, it's
3797 already "canonicalized", so drop the link to the old
3798 parent. */
3799 clobber_variable_part (set, cval, ndv, 0, NULL);
3801 else if (GET_CODE (node->loc) == REG)
3803 attrs *list = set->regs[REGNO (node->loc)], **listp;
3805 /* Change an existing attribute referring to dv so that it
3806 refers to cdv, removing any duplicate this might
3807 introduce, and checking that no previous duplicates
3808 existed, all in a single pass. */
3810 while (list)
3812 if (list->offset == 0
3813 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3814 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3815 break;
3817 list = list->next;
3820 gcc_assert (list);
3821 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3823 list->dv = cdv;
3824 for (listp = &list->next; (list = *listp); listp = &list->next)
3826 if (list->offset)
3827 continue;
3829 if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3831 *listp = list->next;
3832 delete list;
3833 list = *listp;
3834 break;
3837 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (dv));
3840 else if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3842 for (listp = &list->next; (list = *listp); listp = &list->next)
3844 if (list->offset)
3845 continue;
3847 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3849 *listp = list->next;
3850 delete list;
3851 list = *listp;
3852 break;
3855 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (cdv));
3858 else
3859 gcc_unreachable ();
3861 if (flag_checking)
3862 while (list)
3864 if (list->offset == 0
3865 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3866 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3867 gcc_unreachable ();
3869 list = list->next;
3874 if (val)
3875 set_slot_part (set, val, cslot, cdv, 0,
3876 VAR_INIT_STATUS_INITIALIZED, NULL_RTX);
3878 slot = clobber_slot_part (set, cval, slot, 0, NULL);
3880 /* Variable may have been unshared. */
3881 var = *slot;
3882 gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
3883 && var->var_part[0].loc_chain->next == NULL);
3885 if (VALUE_RECURSED_INTO (cval))
3886 goto restart_with_cval;
3888 return 1;
3891 /* Bind one-part variables to the canonical value in an equivalence
3892 set. Not doing this causes dataflow convergence failure in rare
3893 circumstances, see PR42873. Unfortunately we can't do this
3894 efficiently as part of canonicalize_values_star, since we may not
3895 have determined or even seen the canonical value of a set when we
3896 get to a variable that references another member of the set. */
3899 canonicalize_vars_star (variable **slot, dataflow_set *set)
3901 variable *var = *slot;
3902 decl_or_value dv = var->dv;
3903 location_chain *node;
3904 rtx cval;
3905 decl_or_value cdv;
3906 variable **cslot;
3907 variable *cvar;
3908 location_chain *cnode;
3910 if (!var->onepart || var->onepart == ONEPART_VALUE)
3911 return 1;
3913 gcc_assert (var->n_var_parts == 1);
3915 node = var->var_part[0].loc_chain;
3917 if (GET_CODE (node->loc) != VALUE)
3918 return 1;
3920 gcc_assert (!node->next);
3921 cval = node->loc;
3923 /* Push values to the canonical one. */
3924 cdv = dv_from_value (cval);
3925 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3926 if (!cslot)
3927 return 1;
3928 cvar = *cslot;
3929 gcc_assert (cvar->n_var_parts == 1);
3931 cnode = cvar->var_part[0].loc_chain;
3933 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3934 that are not “more canonical” than it. */
3935 if (GET_CODE (cnode->loc) != VALUE
3936 || !canon_value_cmp (cnode->loc, cval))
3937 return 1;
3939 /* CVAL was found to be non-canonical. Change the variable to point
3940 to the canonical VALUE. */
3941 gcc_assert (!cnode->next);
3942 cval = cnode->loc;
3944 slot = set_slot_part (set, cval, slot, dv, 0,
3945 node->init, node->set_src);
3946 clobber_slot_part (set, cval, slot, 0, node->set_src);
3948 return 1;
3951 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3952 corresponding entry in DSM->src. Multi-part variables are combined
3953 with variable_union, whereas onepart dvs are combined with
3954 intersection. */
3956 static int
3957 variable_merge_over_cur (variable *s1var, struct dfset_merge *dsm)
3959 dataflow_set *dst = dsm->dst;
3960 variable **dstslot;
3961 variable *s2var, *dvar = NULL;
3962 decl_or_value dv = s1var->dv;
3963 onepart_enum onepart = s1var->onepart;
3964 rtx val;
3965 hashval_t dvhash;
3966 location_chain *node, **nodep;
3968 /* If the incoming onepart variable has an empty location list, then
3969 the intersection will be just as empty. For other variables,
3970 it's always union. */
3971 gcc_checking_assert (s1var->n_var_parts
3972 && s1var->var_part[0].loc_chain);
3974 if (!onepart)
3975 return variable_union (s1var, dst);
3977 gcc_checking_assert (s1var->n_var_parts == 1);
3979 dvhash = dv_htab_hash (dv);
3980 if (dv_is_value_p (dv))
3981 val = dv_as_value (dv);
3982 else
3983 val = NULL;
3985 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
3986 if (!s2var)
3988 dst_can_be_shared = false;
3989 return 1;
3992 dsm->src_onepart_cnt--;
3993 gcc_assert (s2var->var_part[0].loc_chain
3994 && s2var->onepart == onepart
3995 && s2var->n_var_parts == 1);
3997 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3998 if (dstslot)
4000 dvar = *dstslot;
4001 gcc_assert (dvar->refcount == 1
4002 && dvar->onepart == onepart
4003 && dvar->n_var_parts == 1);
4004 nodep = &dvar->var_part[0].loc_chain;
4006 else
4008 nodep = &node;
4009 node = NULL;
4012 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
4014 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
4015 dvhash, INSERT);
4016 *dstslot = dvar = s2var;
4017 dvar->refcount++;
4019 else
4021 dst_can_be_shared = false;
4023 intersect_loc_chains (val, nodep, dsm,
4024 s1var->var_part[0].loc_chain, s2var);
4026 if (!dstslot)
4028 if (node)
4030 dvar = onepart_pool_allocate (onepart);
4031 dvar->dv = dv;
4032 dvar->refcount = 1;
4033 dvar->n_var_parts = 1;
4034 dvar->onepart = onepart;
4035 dvar->in_changed_variables = false;
4036 dvar->var_part[0].loc_chain = node;
4037 dvar->var_part[0].cur_loc = NULL;
4038 if (onepart)
4039 VAR_LOC_1PAUX (dvar) = NULL;
4040 else
4041 VAR_PART_OFFSET (dvar, 0) = 0;
4043 dstslot
4044 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
4045 INSERT);
4046 gcc_assert (!*dstslot);
4047 *dstslot = dvar;
4049 else
4050 return 1;
4054 nodep = &dvar->var_part[0].loc_chain;
4055 while ((node = *nodep))
4057 location_chain **nextp = &node->next;
4059 if (GET_CODE (node->loc) == REG)
4061 attrs *list;
4063 for (list = dst->regs[REGNO (node->loc)]; list; list = list->next)
4064 if (GET_MODE (node->loc) == GET_MODE (list->loc)
4065 && dv_is_value_p (list->dv))
4066 break;
4068 if (!list)
4069 attrs_list_insert (&dst->regs[REGNO (node->loc)],
4070 dv, 0, node->loc);
4071 /* If this value became canonical for another value that had
4072 this register, we want to leave it alone. */
4073 else if (dv_as_value (list->dv) != val)
4075 dstslot = set_slot_part (dst, dv_as_value (list->dv),
4076 dstslot, dv, 0,
4077 node->init, NULL_RTX);
4078 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
4080 /* Since nextp points into the removed node, we can't
4081 use it. The pointer to the next node moved to nodep.
4082 However, if the variable we're walking is unshared
4083 during our walk, we'll keep walking the location list
4084 of the previously-shared variable, in which case the
4085 node won't have been removed, and we'll want to skip
4086 it. That's why we test *nodep here. */
4087 if (*nodep != node)
4088 nextp = nodep;
4091 else
4092 /* Canonicalization puts registers first, so we don't have to
4093 walk it all. */
4094 break;
4095 nodep = nextp;
4098 if (dvar != *dstslot)
4099 dvar = *dstslot;
4100 nodep = &dvar->var_part[0].loc_chain;
4102 if (val)
4104 /* Mark all referenced nodes for canonicalization, and make sure
4105 we have mutual equivalence links. */
4106 VALUE_RECURSED_INTO (val) = true;
4107 for (node = *nodep; node; node = node->next)
4108 if (GET_CODE (node->loc) == VALUE)
4110 VALUE_RECURSED_INTO (node->loc) = true;
4111 set_variable_part (dst, val, dv_from_value (node->loc), 0,
4112 node->init, NULL, INSERT);
4115 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4116 gcc_assert (*dstslot == dvar);
4117 canonicalize_values_star (dstslot, dst);
4118 gcc_checking_assert (dstslot
4119 == shared_hash_find_slot_noinsert_1 (dst->vars,
4120 dv, dvhash));
4121 dvar = *dstslot;
4123 else
4125 bool has_value = false, has_other = false;
4127 /* If we have one value and anything else, we're going to
4128 canonicalize this, so make sure all values have an entry in
4129 the table and are marked for canonicalization. */
4130 for (node = *nodep; node; node = node->next)
4132 if (GET_CODE (node->loc) == VALUE)
4134 /* If this was marked during register canonicalization,
4135 we know we have to canonicalize values. */
4136 if (has_value)
4137 has_other = true;
4138 has_value = true;
4139 if (has_other)
4140 break;
4142 else
4144 has_other = true;
4145 if (has_value)
4146 break;
4150 if (has_value && has_other)
4152 for (node = *nodep; node; node = node->next)
4154 if (GET_CODE (node->loc) == VALUE)
4156 decl_or_value dv = dv_from_value (node->loc);
4157 variable **slot = NULL;
4159 if (shared_hash_shared (dst->vars))
4160 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
4161 if (!slot)
4162 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
4163 INSERT);
4164 if (!*slot)
4166 variable *var = onepart_pool_allocate (ONEPART_VALUE);
4167 var->dv = dv;
4168 var->refcount = 1;
4169 var->n_var_parts = 1;
4170 var->onepart = ONEPART_VALUE;
4171 var->in_changed_variables = false;
4172 var->var_part[0].loc_chain = NULL;
4173 var->var_part[0].cur_loc = NULL;
4174 VAR_LOC_1PAUX (var) = NULL;
4175 *slot = var;
4178 VALUE_RECURSED_INTO (node->loc) = true;
4182 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4183 gcc_assert (*dstslot == dvar);
4184 canonicalize_values_star (dstslot, dst);
4185 gcc_checking_assert (dstslot
4186 == shared_hash_find_slot_noinsert_1 (dst->vars,
4187 dv, dvhash));
4188 dvar = *dstslot;
4192 if (!onepart_variable_different_p (dvar, s2var))
4194 variable_htab_free (dvar);
4195 *dstslot = dvar = s2var;
4196 dvar->refcount++;
4198 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
4200 variable_htab_free (dvar);
4201 *dstslot = dvar = s1var;
4202 dvar->refcount++;
4203 dst_can_be_shared = false;
4205 else
4206 dst_can_be_shared = false;
4208 return 1;
4211 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4212 multi-part variable. Unions of multi-part variables and
4213 intersections of one-part ones will be handled in
4214 variable_merge_over_cur(). */
4216 static int
4217 variable_merge_over_src (variable *s2var, struct dfset_merge *dsm)
4219 dataflow_set *dst = dsm->dst;
4220 decl_or_value dv = s2var->dv;
4222 if (!s2var->onepart)
4224 variable **dstp = shared_hash_find_slot (dst->vars, dv);
4225 *dstp = s2var;
4226 s2var->refcount++;
4227 return 1;
4230 dsm->src_onepart_cnt++;
4231 return 1;
4234 /* Combine dataflow set information from SRC2 into DST, using PDST
4235 to carry over information across passes. */
4237 static void
4238 dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
4240 dataflow_set cur = *dst;
4241 dataflow_set *src1 = &cur;
4242 struct dfset_merge dsm;
4243 int i;
4244 size_t src1_elems, src2_elems;
4245 variable_iterator_type hi;
4246 variable *var;
4248 src1_elems = shared_hash_htab (src1->vars)->elements ();
4249 src2_elems = shared_hash_htab (src2->vars)->elements ();
4250 dataflow_set_init (dst);
4251 dst->stack_adjust = cur.stack_adjust;
4252 shared_hash_destroy (dst->vars);
4253 dst->vars = new shared_hash;
4254 dst->vars->refcount = 1;
4255 dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems));
4257 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4258 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
4260 dsm.dst = dst;
4261 dsm.src = src2;
4262 dsm.cur = src1;
4263 dsm.src_onepart_cnt = 0;
4265 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars),
4266 var, variable, hi)
4267 variable_merge_over_src (var, &dsm);
4268 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars),
4269 var, variable, hi)
4270 variable_merge_over_cur (var, &dsm);
4272 if (dsm.src_onepart_cnt)
4273 dst_can_be_shared = false;
4275 dataflow_set_destroy (src1);
4278 /* Mark register equivalences. */
4280 static void
4281 dataflow_set_equiv_regs (dataflow_set *set)
4283 int i;
4284 attrs *list, **listp;
4286 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4288 rtx canon[NUM_MACHINE_MODES];
4290 /* If the list is empty or one entry, no need to canonicalize
4291 anything. */
4292 if (set->regs[i] == NULL || set->regs[i]->next == NULL)
4293 continue;
4295 memset (canon, 0, sizeof (canon));
4297 for (list = set->regs[i]; list; list = list->next)
4298 if (list->offset == 0 && dv_is_value_p (list->dv))
4300 rtx val = dv_as_value (list->dv);
4301 rtx *cvalp = &canon[(int)GET_MODE (val)];
4302 rtx cval = *cvalp;
4304 if (canon_value_cmp (val, cval))
4305 *cvalp = val;
4308 for (list = set->regs[i]; list; list = list->next)
4309 if (list->offset == 0 && dv_onepart_p (list->dv))
4311 rtx cval = canon[(int)GET_MODE (list->loc)];
4313 if (!cval)
4314 continue;
4316 if (dv_is_value_p (list->dv))
4318 rtx val = dv_as_value (list->dv);
4320 if (val == cval)
4321 continue;
4323 VALUE_RECURSED_INTO (val) = true;
4324 set_variable_part (set, val, dv_from_value (cval), 0,
4325 VAR_INIT_STATUS_INITIALIZED,
4326 NULL, NO_INSERT);
4329 VALUE_RECURSED_INTO (cval) = true;
4330 set_variable_part (set, cval, list->dv, 0,
4331 VAR_INIT_STATUS_INITIALIZED, NULL, NO_INSERT);
4334 for (listp = &set->regs[i]; (list = *listp);
4335 listp = list ? &list->next : listp)
4336 if (list->offset == 0 && dv_onepart_p (list->dv))
4338 rtx cval = canon[(int)GET_MODE (list->loc)];
4339 variable **slot;
4341 if (!cval)
4342 continue;
4344 if (dv_is_value_p (list->dv))
4346 rtx val = dv_as_value (list->dv);
4347 if (!VALUE_RECURSED_INTO (val))
4348 continue;
4351 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
4352 canonicalize_values_star (slot, set);
4353 if (*listp != list)
4354 list = NULL;
4359 /* Remove any redundant values in the location list of VAR, which must
4360 be unshared and 1-part. */
4362 static void
4363 remove_duplicate_values (variable *var)
4365 location_chain *node, **nodep;
4367 gcc_assert (var->onepart);
4368 gcc_assert (var->n_var_parts == 1);
4369 gcc_assert (var->refcount == 1);
4371 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
4373 if (GET_CODE (node->loc) == VALUE)
4375 if (VALUE_RECURSED_INTO (node->loc))
4377 /* Remove duplicate value node. */
4378 *nodep = node->next;
4379 delete node;
4380 continue;
4382 else
4383 VALUE_RECURSED_INTO (node->loc) = true;
4385 nodep = &node->next;
4388 for (node = var->var_part[0].loc_chain; node; node = node->next)
4389 if (GET_CODE (node->loc) == VALUE)
4391 gcc_assert (VALUE_RECURSED_INTO (node->loc));
4392 VALUE_RECURSED_INTO (node->loc) = false;
4397 /* Hash table iteration argument passed to variable_post_merge. */
4398 struct dfset_post_merge
4400 /* The new input set for the current block. */
4401 dataflow_set *set;
4402 /* Pointer to the permanent input set for the current block, or
4403 NULL. */
4404 dataflow_set **permp;
4407 /* Create values for incoming expressions associated with one-part
4408 variables that don't have value numbers for them. */
4411 variable_post_merge_new_vals (variable **slot, dfset_post_merge *dfpm)
4413 dataflow_set *set = dfpm->set;
4414 variable *var = *slot;
4415 location_chain *node;
4417 if (!var->onepart || !var->n_var_parts)
4418 return 1;
4420 gcc_assert (var->n_var_parts == 1);
4422 if (dv_is_decl_p (var->dv))
4424 bool check_dupes = false;
4426 restart:
4427 for (node = var->var_part[0].loc_chain; node; node = node->next)
4429 if (GET_CODE (node->loc) == VALUE)
4430 gcc_assert (!VALUE_RECURSED_INTO (node->loc));
4431 else if (GET_CODE (node->loc) == REG)
4433 attrs *att, **attp, **curp = NULL;
4435 if (var->refcount != 1)
4437 slot = unshare_variable (set, slot, var,
4438 VAR_INIT_STATUS_INITIALIZED);
4439 var = *slot;
4440 goto restart;
4443 for (attp = &set->regs[REGNO (node->loc)]; (att = *attp);
4444 attp = &att->next)
4445 if (att->offset == 0
4446 && GET_MODE (att->loc) == GET_MODE (node->loc))
4448 if (dv_is_value_p (att->dv))
4450 rtx cval = dv_as_value (att->dv);
4451 node->loc = cval;
4452 check_dupes = true;
4453 break;
4455 else if (dv_as_opaque (att->dv) == dv_as_opaque (var->dv))
4456 curp = attp;
4459 if (!curp)
4461 curp = attp;
4462 while (*curp)
4463 if ((*curp)->offset == 0
4464 && GET_MODE ((*curp)->loc) == GET_MODE (node->loc)
4465 && dv_as_opaque ((*curp)->dv) == dv_as_opaque (var->dv))
4466 break;
4467 else
4468 curp = &(*curp)->next;
4469 gcc_assert (*curp);
4472 if (!att)
4474 decl_or_value cdv;
4475 rtx cval;
4477 if (!*dfpm->permp)
4479 *dfpm->permp = XNEW (dataflow_set);
4480 dataflow_set_init (*dfpm->permp);
4483 for (att = (*dfpm->permp)->regs[REGNO (node->loc)];
4484 att; att = att->next)
4485 if (GET_MODE (att->loc) == GET_MODE (node->loc))
4487 gcc_assert (att->offset == 0
4488 && dv_is_value_p (att->dv));
4489 val_reset (set, att->dv);
4490 break;
4493 if (att)
4495 cdv = att->dv;
4496 cval = dv_as_value (cdv);
4498 else
4500 /* Create a unique value to hold this register,
4501 that ought to be found and reused in
4502 subsequent rounds. */
4503 cselib_val *v;
4504 gcc_assert (!cselib_lookup (node->loc,
4505 GET_MODE (node->loc), 0,
4506 VOIDmode));
4507 v = cselib_lookup (node->loc, GET_MODE (node->loc), 1,
4508 VOIDmode);
4509 cselib_preserve_value (v);
4510 cselib_invalidate_rtx (node->loc);
4511 cval = v->val_rtx;
4512 cdv = dv_from_value (cval);
4513 if (dump_file)
4514 fprintf (dump_file,
4515 "Created new value %u:%u for reg %i\n",
4516 v->uid, v->hash, REGNO (node->loc));
4519 var_reg_decl_set (*dfpm->permp, node->loc,
4520 VAR_INIT_STATUS_INITIALIZED,
4521 cdv, 0, NULL, INSERT);
4523 node->loc = cval;
4524 check_dupes = true;
4527 /* Remove attribute referring to the decl, which now
4528 uses the value for the register, already existing or
4529 to be added when we bring perm in. */
4530 att = *curp;
4531 *curp = att->next;
4532 delete att;
4536 if (check_dupes)
4537 remove_duplicate_values (var);
4540 return 1;
4543 /* Reset values in the permanent set that are not associated with the
4544 chosen expression. */
4547 variable_post_merge_perm_vals (variable **pslot, dfset_post_merge *dfpm)
4549 dataflow_set *set = dfpm->set;
4550 variable *pvar = *pslot, *var;
4551 location_chain *pnode;
4552 decl_or_value dv;
4553 attrs *att;
4555 gcc_assert (dv_is_value_p (pvar->dv)
4556 && pvar->n_var_parts == 1);
4557 pnode = pvar->var_part[0].loc_chain;
4558 gcc_assert (pnode
4559 && !pnode->next
4560 && REG_P (pnode->loc));
4562 dv = pvar->dv;
4564 var = shared_hash_find (set->vars, dv);
4565 if (var)
4567 /* Although variable_post_merge_new_vals may have made decls
4568 non-star-canonical, values that pre-existed in canonical form
4569 remain canonical, and newly-created values reference a single
4570 REG, so they are canonical as well. Since VAR has the
4571 location list for a VALUE, using find_loc_in_1pdv for it is
4572 fine, since VALUEs don't map back to DECLs. */
4573 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
4574 return 1;
4575 val_reset (set, dv);
4578 for (att = set->regs[REGNO (pnode->loc)]; att; att = att->next)
4579 if (att->offset == 0
4580 && GET_MODE (att->loc) == GET_MODE (pnode->loc)
4581 && dv_is_value_p (att->dv))
4582 break;
4584 /* If there is a value associated with this register already, create
4585 an equivalence. */
4586 if (att && dv_as_value (att->dv) != dv_as_value (dv))
4588 rtx cval = dv_as_value (att->dv);
4589 set_variable_part (set, cval, dv, 0, pnode->init, NULL, INSERT);
4590 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
4591 NULL, INSERT);
4593 else if (!att)
4595 attrs_list_insert (&set->regs[REGNO (pnode->loc)],
4596 dv, 0, pnode->loc);
4597 variable_union (pvar, set);
4600 return 1;
4603 /* Just checking stuff and registering register attributes for
4604 now. */
4606 static void
4607 dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
4609 struct dfset_post_merge dfpm;
4611 dfpm.set = set;
4612 dfpm.permp = permp;
4614 shared_hash_htab (set->vars)
4615 ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm);
4616 if (*permp)
4617 shared_hash_htab ((*permp)->vars)
4618 ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm);
4619 shared_hash_htab (set->vars)
4620 ->traverse <dataflow_set *, canonicalize_values_star> (set);
4621 shared_hash_htab (set->vars)
4622 ->traverse <dataflow_set *, canonicalize_vars_star> (set);
4625 /* Return a node whose loc is a MEM that refers to EXPR in the
4626 location list of a one-part variable or value VAR, or in that of
4627 any values recursively mentioned in the location lists. */
4629 static location_chain *
4630 find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars)
4632 location_chain *node;
4633 decl_or_value dv;
4634 variable *var;
4635 location_chain *where = NULL;
4637 if (!val)
4638 return NULL;
4640 gcc_assert (GET_CODE (val) == VALUE
4641 && !VALUE_RECURSED_INTO (val));
4643 dv = dv_from_value (val);
4644 var = vars->find_with_hash (dv, dv_htab_hash (dv));
4646 if (!var)
4647 return NULL;
4649 gcc_assert (var->onepart);
4651 if (!var->n_var_parts)
4652 return NULL;
4654 VALUE_RECURSED_INTO (val) = true;
4656 for (node = var->var_part[0].loc_chain; node; node = node->next)
4657 if (MEM_P (node->loc)
4658 && MEM_EXPR (node->loc) == expr
4659 && int_mem_offset (node->loc) == 0)
4661 where = node;
4662 break;
4664 else if (GET_CODE (node->loc) == VALUE
4665 && !VALUE_RECURSED_INTO (node->loc)
4666 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
4667 break;
4669 VALUE_RECURSED_INTO (val) = false;
4671 return where;
4674 /* Return TRUE if the value of MEM may vary across a call. */
4676 static bool
4677 mem_dies_at_call (rtx mem)
4679 tree expr = MEM_EXPR (mem);
4680 tree decl;
4682 if (!expr)
4683 return true;
4685 decl = get_base_address (expr);
4687 if (!decl)
4688 return true;
4690 if (!DECL_P (decl))
4691 return true;
4693 return (may_be_aliased (decl)
4694 || (!TREE_READONLY (decl) && is_global_var (decl)));
4697 /* Remove all MEMs from the location list of a hash table entry for a
4698 one-part variable, except those whose MEM attributes map back to
4699 the variable itself, directly or within a VALUE. */
4702 dataflow_set_preserve_mem_locs (variable **slot, dataflow_set *set)
4704 variable *var = *slot;
4706 if (var->onepart == ONEPART_VDECL || var->onepart == ONEPART_DEXPR)
4708 tree decl = dv_as_decl (var->dv);
4709 location_chain *loc, **locp;
4710 bool changed = false;
4712 if (!var->n_var_parts)
4713 return 1;
4715 gcc_assert (var->n_var_parts == 1);
4717 if (shared_var_p (var, set->vars))
4719 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4721 /* We want to remove dying MEMs that don't refer to DECL. */
4722 if (GET_CODE (loc->loc) == MEM
4723 && (MEM_EXPR (loc->loc) != decl
4724 || int_mem_offset (loc->loc) != 0)
4725 && mem_dies_at_call (loc->loc))
4726 break;
4727 /* We want to move here MEMs that do refer to DECL. */
4728 else if (GET_CODE (loc->loc) == VALUE
4729 && find_mem_expr_in_1pdv (decl, loc->loc,
4730 shared_hash_htab (set->vars)))
4731 break;
4734 if (!loc)
4735 return 1;
4737 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4738 var = *slot;
4739 gcc_assert (var->n_var_parts == 1);
4742 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4743 loc; loc = *locp)
4745 rtx old_loc = loc->loc;
4746 if (GET_CODE (old_loc) == VALUE)
4748 location_chain *mem_node
4749 = find_mem_expr_in_1pdv (decl, loc->loc,
4750 shared_hash_htab (set->vars));
4752 /* ??? This picks up only one out of multiple MEMs that
4753 refer to the same variable. Do we ever need to be
4754 concerned about dealing with more than one, or, given
4755 that they should all map to the same variable
4756 location, their addresses will have been merged and
4757 they will be regarded as equivalent? */
4758 if (mem_node)
4760 loc->loc = mem_node->loc;
4761 loc->set_src = mem_node->set_src;
4762 loc->init = MIN (loc->init, mem_node->init);
4766 if (GET_CODE (loc->loc) != MEM
4767 || (MEM_EXPR (loc->loc) == decl
4768 && int_mem_offset (loc->loc) == 0)
4769 || !mem_dies_at_call (loc->loc))
4771 if (old_loc != loc->loc && emit_notes)
4773 if (old_loc == var->var_part[0].cur_loc)
4775 changed = true;
4776 var->var_part[0].cur_loc = NULL;
4779 locp = &loc->next;
4780 continue;
4783 if (emit_notes)
4785 if (old_loc == var->var_part[0].cur_loc)
4787 changed = true;
4788 var->var_part[0].cur_loc = NULL;
4791 *locp = loc->next;
4792 delete loc;
4795 if (!var->var_part[0].loc_chain)
4797 var->n_var_parts--;
4798 changed = true;
4800 if (changed)
4801 variable_was_changed (var, set);
4804 return 1;
4807 /* Remove all MEMs from the location list of a hash table entry for a
4808 onepart variable. */
4811 dataflow_set_remove_mem_locs (variable **slot, dataflow_set *set)
4813 variable *var = *slot;
4815 if (var->onepart != NOT_ONEPART)
4817 location_chain *loc, **locp;
4818 bool changed = false;
4819 rtx cur_loc;
4821 gcc_assert (var->n_var_parts == 1);
4823 if (shared_var_p (var, set->vars))
4825 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4826 if (GET_CODE (loc->loc) == MEM
4827 && mem_dies_at_call (loc->loc))
4828 break;
4830 if (!loc)
4831 return 1;
4833 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4834 var = *slot;
4835 gcc_assert (var->n_var_parts == 1);
4838 if (VAR_LOC_1PAUX (var))
4839 cur_loc = VAR_LOC_FROM (var);
4840 else
4841 cur_loc = var->var_part[0].cur_loc;
4843 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4844 loc; loc = *locp)
4846 if (GET_CODE (loc->loc) != MEM
4847 || !mem_dies_at_call (loc->loc))
4849 locp = &loc->next;
4850 continue;
4853 *locp = loc->next;
4854 /* If we have deleted the location which was last emitted
4855 we have to emit new location so add the variable to set
4856 of changed variables. */
4857 if (cur_loc == loc->loc)
4859 changed = true;
4860 var->var_part[0].cur_loc = NULL;
4861 if (VAR_LOC_1PAUX (var))
4862 VAR_LOC_FROM (var) = NULL;
4864 delete loc;
4867 if (!var->var_part[0].loc_chain)
4869 var->n_var_parts--;
4870 changed = true;
4872 if (changed)
4873 variable_was_changed (var, set);
4876 return 1;
4879 /* Remove all variable-location information about call-clobbered
4880 registers, as well as associations between MEMs and VALUEs. */
4882 static void
4883 dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
4885 unsigned int r;
4886 hard_reg_set_iterator hrsi;
4887 HARD_REG_SET invalidated_regs;
4889 get_call_reg_set_usage (call_insn, &invalidated_regs,
4890 regs_invalidated_by_call);
4892 EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
4893 var_regno_delete (set, r);
4895 if (MAY_HAVE_DEBUG_BIND_INSNS)
4897 set->traversed_vars = set->vars;
4898 shared_hash_htab (set->vars)
4899 ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
4900 set->traversed_vars = set->vars;
4901 shared_hash_htab (set->vars)
4902 ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set);
4903 set->traversed_vars = NULL;
4907 static bool
4908 variable_part_different_p (variable_part *vp1, variable_part *vp2)
4910 location_chain *lc1, *lc2;
4912 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4914 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4916 if (REG_P (lc1->loc) && REG_P (lc2->loc))
4918 if (REGNO (lc1->loc) == REGNO (lc2->loc))
4919 break;
4921 if (rtx_equal_p (lc1->loc, lc2->loc))
4922 break;
4924 if (!lc2)
4925 return true;
4927 return false;
4930 /* Return true if one-part variables VAR1 and VAR2 are different.
4931 They must be in canonical order. */
4933 static bool
4934 onepart_variable_different_p (variable *var1, variable *var2)
4936 location_chain *lc1, *lc2;
4938 if (var1 == var2)
4939 return false;
4941 gcc_assert (var1->n_var_parts == 1
4942 && var2->n_var_parts == 1);
4944 lc1 = var1->var_part[0].loc_chain;
4945 lc2 = var2->var_part[0].loc_chain;
4947 gcc_assert (lc1 && lc2);
4949 while (lc1 && lc2)
4951 if (loc_cmp (lc1->loc, lc2->loc))
4952 return true;
4953 lc1 = lc1->next;
4954 lc2 = lc2->next;
4957 return lc1 != lc2;
4960 /* Return true if one-part variables VAR1 and VAR2 are different.
4961 They must be in canonical order. */
4963 static void
4964 dump_onepart_variable_differences (variable *var1, variable *var2)
4966 location_chain *lc1, *lc2;
4968 gcc_assert (var1 != var2);
4969 gcc_assert (dump_file);
4970 gcc_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv));
4971 gcc_assert (var1->n_var_parts == 1
4972 && var2->n_var_parts == 1);
4974 lc1 = var1->var_part[0].loc_chain;
4975 lc2 = var2->var_part[0].loc_chain;
4977 gcc_assert (lc1 && lc2);
4979 while (lc1 && lc2)
4981 switch (loc_cmp (lc1->loc, lc2->loc))
4983 case -1:
4984 fprintf (dump_file, "removed: ");
4985 print_rtl_single (dump_file, lc1->loc);
4986 lc1 = lc1->next;
4987 continue;
4988 case 0:
4989 break;
4990 case 1:
4991 fprintf (dump_file, "added: ");
4992 print_rtl_single (dump_file, lc2->loc);
4993 lc2 = lc2->next;
4994 continue;
4995 default:
4996 gcc_unreachable ();
4998 lc1 = lc1->next;
4999 lc2 = lc2->next;
5002 while (lc1)
5004 fprintf (dump_file, "removed: ");
5005 print_rtl_single (dump_file, lc1->loc);
5006 lc1 = lc1->next;
5009 while (lc2)
5011 fprintf (dump_file, "added: ");
5012 print_rtl_single (dump_file, lc2->loc);
5013 lc2 = lc2->next;
5017 /* Return true if variables VAR1 and VAR2 are different. */
5019 static bool
5020 variable_different_p (variable *var1, variable *var2)
5022 int i;
5024 if (var1 == var2)
5025 return false;
5027 if (var1->onepart != var2->onepart)
5028 return true;
5030 if (var1->n_var_parts != var2->n_var_parts)
5031 return true;
5033 if (var1->onepart && var1->n_var_parts)
5035 gcc_checking_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv)
5036 && var1->n_var_parts == 1);
5037 /* One-part values have locations in a canonical order. */
5038 return onepart_variable_different_p (var1, var2);
5041 for (i = 0; i < var1->n_var_parts; i++)
5043 if (VAR_PART_OFFSET (var1, i) != VAR_PART_OFFSET (var2, i))
5044 return true;
5045 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
5046 return true;
5047 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
5048 return true;
5050 return false;
5053 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5055 static bool
5056 dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
5058 variable_iterator_type hi;
5059 variable *var1;
5060 bool diffound = false;
5061 bool details = (dump_file && (dump_flags & TDF_DETAILS));
5063 #define RETRUE \
5064 do \
5066 if (!details) \
5067 return true; \
5068 else \
5069 diffound = true; \
5071 while (0)
5073 if (old_set->vars == new_set->vars)
5074 return false;
5076 if (shared_hash_htab (old_set->vars)->elements ()
5077 != shared_hash_htab (new_set->vars)->elements ())
5078 RETRUE;
5080 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars),
5081 var1, variable, hi)
5083 variable_table_type *htab = shared_hash_htab (new_set->vars);
5084 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5086 if (!var2)
5088 if (dump_file && (dump_flags & TDF_DETAILS))
5090 fprintf (dump_file, "dataflow difference found: removal of:\n");
5091 dump_var (var1);
5093 RETRUE;
5095 else if (variable_different_p (var1, var2))
5097 if (details)
5099 fprintf (dump_file, "dataflow difference found: "
5100 "old and new follow:\n");
5101 dump_var (var1);
5102 if (dv_onepart_p (var1->dv))
5103 dump_onepart_variable_differences (var1, var2);
5104 dump_var (var2);
5106 RETRUE;
5110 /* There's no need to traverse the second hashtab unless we want to
5111 print the details. If both have the same number of elements and
5112 the second one had all entries found in the first one, then the
5113 second can't have any extra entries. */
5114 if (!details)
5115 return diffound;
5117 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set->vars),
5118 var1, variable, hi)
5120 variable_table_type *htab = shared_hash_htab (old_set->vars);
5121 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5122 if (!var2)
5124 if (details)
5126 fprintf (dump_file, "dataflow difference found: addition of:\n");
5127 dump_var (var1);
5129 RETRUE;
5133 #undef RETRUE
5135 return diffound;
5138 /* Free the contents of dataflow set SET. */
5140 static void
5141 dataflow_set_destroy (dataflow_set *set)
5143 int i;
5145 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5146 attrs_list_clear (&set->regs[i]);
5148 shared_hash_destroy (set->vars);
5149 set->vars = NULL;
5152 /* Return true if T is a tracked parameter with non-degenerate record type. */
5154 static bool
5155 tracked_record_parameter_p (tree t)
5157 if (TREE_CODE (t) != PARM_DECL)
5158 return false;
5160 if (DECL_MODE (t) == BLKmode)
5161 return false;
5163 tree type = TREE_TYPE (t);
5164 if (TREE_CODE (type) != RECORD_TYPE)
5165 return false;
5167 if (TYPE_FIELDS (type) == NULL_TREE
5168 || DECL_CHAIN (TYPE_FIELDS (type)) == NULL_TREE)
5169 return false;
5171 return true;
5174 /* Shall EXPR be tracked? */
5176 static bool
5177 track_expr_p (tree expr, bool need_rtl)
5179 rtx decl_rtl;
5180 tree realdecl;
5182 if (TREE_CODE (expr) == DEBUG_EXPR_DECL)
5183 return DECL_RTL_SET_P (expr);
5185 /* If EXPR is not a parameter or a variable do not track it. */
5186 if (!VAR_P (expr) && TREE_CODE (expr) != PARM_DECL)
5187 return 0;
5189 /* It also must have a name... */
5190 if (!DECL_NAME (expr) && need_rtl)
5191 return 0;
5193 /* ... and a RTL assigned to it. */
5194 decl_rtl = DECL_RTL_IF_SET (expr);
5195 if (!decl_rtl && need_rtl)
5196 return 0;
5198 /* If this expression is really a debug alias of some other declaration, we
5199 don't need to track this expression if the ultimate declaration is
5200 ignored. */
5201 realdecl = expr;
5202 if (VAR_P (realdecl) && DECL_HAS_DEBUG_EXPR_P (realdecl))
5204 realdecl = DECL_DEBUG_EXPR (realdecl);
5205 if (!DECL_P (realdecl))
5207 if (handled_component_p (realdecl)
5208 || (TREE_CODE (realdecl) == MEM_REF
5209 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5211 HOST_WIDE_INT bitsize, bitpos;
5212 bool reverse;
5213 tree innerdecl
5214 = get_ref_base_and_extent_hwi (realdecl, &bitpos,
5215 &bitsize, &reverse);
5216 if (!innerdecl
5217 || !DECL_P (innerdecl)
5218 || DECL_IGNORED_P (innerdecl)
5219 /* Do not track declarations for parts of tracked record
5220 parameters since we want to track them as a whole. */
5221 || tracked_record_parameter_p (innerdecl)
5222 || TREE_STATIC (innerdecl)
5223 || bitsize == 0
5224 || bitpos + bitsize > 256)
5225 return 0;
5226 else
5227 realdecl = expr;
5229 else
5230 return 0;
5234 /* Do not track EXPR if REALDECL it should be ignored for debugging
5235 purposes. */
5236 if (DECL_IGNORED_P (realdecl))
5237 return 0;
5239 /* Do not track global variables until we are able to emit correct location
5240 list for them. */
5241 if (TREE_STATIC (realdecl))
5242 return 0;
5244 /* When the EXPR is a DECL for alias of some variable (see example)
5245 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5246 DECL_RTL contains SYMBOL_REF.
5248 Example:
5249 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5250 char **_dl_argv;
5252 if (decl_rtl && MEM_P (decl_rtl)
5253 && contains_symbol_ref_p (XEXP (decl_rtl, 0)))
5254 return 0;
5256 /* If RTX is a memory it should not be very large (because it would be
5257 an array or struct). */
5258 if (decl_rtl && MEM_P (decl_rtl))
5260 /* Do not track structures and arrays. */
5261 if ((GET_MODE (decl_rtl) == BLKmode
5262 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
5263 && !tracked_record_parameter_p (realdecl))
5264 return 0;
5265 if (MEM_SIZE_KNOWN_P (decl_rtl)
5266 && maybe_gt (MEM_SIZE (decl_rtl), MAX_VAR_PARTS))
5267 return 0;
5270 DECL_CHANGED (expr) = 0;
5271 DECL_CHANGED (realdecl) = 0;
5272 return 1;
5275 /* Determine whether a given LOC refers to the same variable part as
5276 EXPR+OFFSET. */
5278 static bool
5279 same_variable_part_p (rtx loc, tree expr, poly_int64 offset)
5281 tree expr2;
5282 poly_int64 offset2;
5284 if (! DECL_P (expr))
5285 return false;
5287 if (REG_P (loc))
5289 expr2 = REG_EXPR (loc);
5290 offset2 = REG_OFFSET (loc);
5292 else if (MEM_P (loc))
5294 expr2 = MEM_EXPR (loc);
5295 offset2 = int_mem_offset (loc);
5297 else
5298 return false;
5300 if (! expr2 || ! DECL_P (expr2))
5301 return false;
5303 expr = var_debug_decl (expr);
5304 expr2 = var_debug_decl (expr2);
5306 return (expr == expr2 && known_eq (offset, offset2));
5309 /* LOC is a REG or MEM that we would like to track if possible.
5310 If EXPR is null, we don't know what expression LOC refers to,
5311 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5312 LOC is an lvalue register.
5314 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5315 is something we can track. When returning true, store the mode of
5316 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5317 from EXPR in *OFFSET_OUT (if nonnull). */
5319 static bool
5320 track_loc_p (rtx loc, tree expr, poly_int64 offset, bool store_reg_p,
5321 machine_mode *mode_out, HOST_WIDE_INT *offset_out)
5323 machine_mode mode;
5325 if (expr == NULL || !track_expr_p (expr, true))
5326 return false;
5328 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5329 whole subreg, but only the old inner part is really relevant. */
5330 mode = GET_MODE (loc);
5331 if (REG_P (loc) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc)))
5333 machine_mode pseudo_mode;
5335 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc));
5336 if (paradoxical_subreg_p (mode, pseudo_mode))
5338 offset += byte_lowpart_offset (pseudo_mode, mode);
5339 mode = pseudo_mode;
5343 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5344 Do the same if we are storing to a register and EXPR occupies
5345 the whole of register LOC; in that case, the whole of EXPR is
5346 being changed. We exclude complex modes from the second case
5347 because the real and imaginary parts are represented as separate
5348 pseudo registers, even if the whole complex value fits into one
5349 hard register. */
5350 if ((paradoxical_subreg_p (mode, DECL_MODE (expr))
5351 || (store_reg_p
5352 && !COMPLEX_MODE_P (DECL_MODE (expr))
5353 && hard_regno_nregs (REGNO (loc), DECL_MODE (expr)) == 1))
5354 && known_eq (offset + byte_lowpart_offset (DECL_MODE (expr), mode), 0))
5356 mode = DECL_MODE (expr);
5357 offset = 0;
5360 HOST_WIDE_INT const_offset;
5361 if (!track_offset_p (offset, &const_offset))
5362 return false;
5364 if (mode_out)
5365 *mode_out = mode;
5366 if (offset_out)
5367 *offset_out = const_offset;
5368 return true;
5371 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5372 want to track. When returning nonnull, make sure that the attributes
5373 on the returned value are updated. */
5375 static rtx
5376 var_lowpart (machine_mode mode, rtx loc)
5378 unsigned int regno;
5380 if (GET_MODE (loc) == mode)
5381 return loc;
5383 if (!REG_P (loc) && !MEM_P (loc))
5384 return NULL;
5386 poly_uint64 offset = byte_lowpart_offset (mode, GET_MODE (loc));
5388 if (MEM_P (loc))
5389 return adjust_address_nv (loc, mode, offset);
5391 poly_uint64 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
5392 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
5393 reg_offset, mode);
5394 return gen_rtx_REG_offset (loc, mode, regno, offset);
5397 /* Carry information about uses and stores while walking rtx. */
5399 struct count_use_info
5401 /* The insn where the RTX is. */
5402 rtx_insn *insn;
5404 /* The basic block where insn is. */
5405 basic_block bb;
5407 /* The array of n_sets sets in the insn, as determined by cselib. */
5408 struct cselib_set *sets;
5409 int n_sets;
5411 /* True if we're counting stores, false otherwise. */
5412 bool store_p;
5415 /* Find a VALUE corresponding to X. */
5417 static inline cselib_val *
5418 find_use_val (rtx x, machine_mode mode, struct count_use_info *cui)
5420 int i;
5422 if (cui->sets)
5424 /* This is called after uses are set up and before stores are
5425 processed by cselib, so it's safe to look up srcs, but not
5426 dsts. So we look up expressions that appear in srcs or in
5427 dest expressions, but we search the sets array for dests of
5428 stores. */
5429 if (cui->store_p)
5431 /* Some targets represent memset and memcpy patterns
5432 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5433 (set (mem:BLK ...) (const_int ...)) or
5434 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5435 in that case, otherwise we end up with mode mismatches. */
5436 if (mode == BLKmode && MEM_P (x))
5437 return NULL;
5438 for (i = 0; i < cui->n_sets; i++)
5439 if (cui->sets[i].dest == x)
5440 return cui->sets[i].src_elt;
5442 else
5443 return cselib_lookup (x, mode, 0, VOIDmode);
5446 return NULL;
5449 /* Replace all registers and addresses in an expression with VALUE
5450 expressions that map back to them, unless the expression is a
5451 register. If no mapping is or can be performed, returns NULL. */
5453 static rtx
5454 replace_expr_with_values (rtx loc)
5456 if (REG_P (loc) || GET_CODE (loc) == ENTRY_VALUE)
5457 return NULL;
5458 else if (MEM_P (loc))
5460 cselib_val *addr = cselib_lookup (XEXP (loc, 0),
5461 get_address_mode (loc), 0,
5462 GET_MODE (loc));
5463 if (addr)
5464 return replace_equiv_address_nv (loc, addr->val_rtx);
5465 else
5466 return NULL;
5468 else
5469 return cselib_subst_to_values (loc, VOIDmode);
5472 /* Return true if X contains a DEBUG_EXPR. */
5474 static bool
5475 rtx_debug_expr_p (const_rtx x)
5477 subrtx_iterator::array_type array;
5478 FOR_EACH_SUBRTX (iter, array, x, ALL)
5479 if (GET_CODE (*iter) == DEBUG_EXPR)
5480 return true;
5481 return false;
5484 /* Determine what kind of micro operation to choose for a USE. Return
5485 MO_CLOBBER if no micro operation is to be generated. */
5487 static enum micro_operation_type
5488 use_type (rtx loc, struct count_use_info *cui, machine_mode *modep)
5490 tree expr;
5492 if (cui && cui->sets)
5494 if (GET_CODE (loc) == VAR_LOCATION)
5496 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc), false))
5498 rtx ploc = PAT_VAR_LOCATION_LOC (loc);
5499 if (! VAR_LOC_UNKNOWN_P (ploc))
5501 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc), 1,
5502 VOIDmode);
5504 /* ??? flag_float_store and volatile mems are never
5505 given values, but we could in theory use them for
5506 locations. */
5507 gcc_assert (val || 1);
5509 return MO_VAL_LOC;
5511 else
5512 return MO_CLOBBER;
5515 if (REG_P (loc) || MEM_P (loc))
5517 if (modep)
5518 *modep = GET_MODE (loc);
5519 if (cui->store_p)
5521 if (REG_P (loc)
5522 || (find_use_val (loc, GET_MODE (loc), cui)
5523 && cselib_lookup (XEXP (loc, 0),
5524 get_address_mode (loc), 0,
5525 GET_MODE (loc))))
5526 return MO_VAL_SET;
5528 else
5530 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5532 if (val && !cselib_preserved_value_p (val))
5533 return MO_VAL_USE;
5538 if (REG_P (loc))
5540 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER);
5542 if (loc == cfa_base_rtx)
5543 return MO_CLOBBER;
5544 expr = REG_EXPR (loc);
5546 if (!expr)
5547 return MO_USE_NO_VAR;
5548 else if (target_for_debug_bind (var_debug_decl (expr)))
5549 return MO_CLOBBER;
5550 else if (track_loc_p (loc, expr, REG_OFFSET (loc),
5551 false, modep, NULL))
5552 return MO_USE;
5553 else
5554 return MO_USE_NO_VAR;
5556 else if (MEM_P (loc))
5558 expr = MEM_EXPR (loc);
5560 if (!expr)
5561 return MO_CLOBBER;
5562 else if (target_for_debug_bind (var_debug_decl (expr)))
5563 return MO_CLOBBER;
5564 else if (track_loc_p (loc, expr, int_mem_offset (loc),
5565 false, modep, NULL)
5566 /* Multi-part variables shouldn't refer to one-part
5567 variable names such as VALUEs (never happens) or
5568 DEBUG_EXPRs (only happens in the presence of debug
5569 insns). */
5570 && (!MAY_HAVE_DEBUG_BIND_INSNS
5571 || !rtx_debug_expr_p (XEXP (loc, 0))))
5572 return MO_USE;
5573 else
5574 return MO_CLOBBER;
5577 return MO_CLOBBER;
5580 /* Log to OUT information about micro-operation MOPT involving X in
5581 INSN of BB. */
5583 static inline void
5584 log_op_type (rtx x, basic_block bb, rtx_insn *insn,
5585 enum micro_operation_type mopt, FILE *out)
5587 fprintf (out, "bb %i op %i insn %i %s ",
5588 bb->index, VTI (bb)->mos.length (),
5589 INSN_UID (insn), micro_operation_type_name[mopt]);
5590 print_inline_rtx (out, x, 2);
5591 fputc ('\n', out);
5594 /* Tell whether the CONCAT used to holds a VALUE and its location
5595 needs value resolution, i.e., an attempt of mapping the location
5596 back to other incoming values. */
5597 #define VAL_NEEDS_RESOLUTION(x) \
5598 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5599 /* Whether the location in the CONCAT is a tracked expression, that
5600 should also be handled like a MO_USE. */
5601 #define VAL_HOLDS_TRACK_EXPR(x) \
5602 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5603 /* Whether the location in the CONCAT should be handled like a MO_COPY
5604 as well. */
5605 #define VAL_EXPR_IS_COPIED(x) \
5606 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5607 /* Whether the location in the CONCAT should be handled like a
5608 MO_CLOBBER as well. */
5609 #define VAL_EXPR_IS_CLOBBERED(x) \
5610 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5612 /* All preserved VALUEs. */
5613 static vec<rtx> preserved_values;
5615 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5617 static void
5618 preserve_value (cselib_val *val)
5620 cselib_preserve_value (val);
5621 preserved_values.safe_push (val->val_rtx);
5624 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5625 any rtxes not suitable for CONST use not replaced by VALUEs
5626 are discovered. */
5628 static bool
5629 non_suitable_const (const_rtx x)
5631 subrtx_iterator::array_type array;
5632 FOR_EACH_SUBRTX (iter, array, x, ALL)
5634 const_rtx x = *iter;
5635 switch (GET_CODE (x))
5637 case REG:
5638 case DEBUG_EXPR:
5639 case PC:
5640 case SCRATCH:
5641 case CC0:
5642 case ASM_INPUT:
5643 case ASM_OPERANDS:
5644 return true;
5645 case MEM:
5646 if (!MEM_READONLY_P (x))
5647 return true;
5648 break;
5649 default:
5650 break;
5653 return false;
5656 /* Add uses (register and memory references) LOC which will be tracked
5657 to VTI (bb)->mos. */
5659 static void
5660 add_uses (rtx loc, struct count_use_info *cui)
5662 machine_mode mode = VOIDmode;
5663 enum micro_operation_type type = use_type (loc, cui, &mode);
5665 if (type != MO_CLOBBER)
5667 basic_block bb = cui->bb;
5668 micro_operation mo;
5670 mo.type = type;
5671 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
5672 mo.insn = cui->insn;
5674 if (type == MO_VAL_LOC)
5676 rtx oloc = loc;
5677 rtx vloc = PAT_VAR_LOCATION_LOC (oloc);
5678 cselib_val *val;
5680 gcc_assert (cui->sets);
5682 if (MEM_P (vloc)
5683 && !REG_P (XEXP (vloc, 0))
5684 && !MEM_P (XEXP (vloc, 0)))
5686 rtx mloc = vloc;
5687 machine_mode address_mode = get_address_mode (mloc);
5688 cselib_val *val
5689 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5690 GET_MODE (mloc));
5692 if (val && !cselib_preserved_value_p (val))
5693 preserve_value (val);
5696 if (CONSTANT_P (vloc)
5697 && (GET_CODE (vloc) != CONST || non_suitable_const (vloc)))
5698 /* For constants don't look up any value. */;
5699 else if (!VAR_LOC_UNKNOWN_P (vloc) && !unsuitable_loc (vloc)
5700 && (val = find_use_val (vloc, GET_MODE (oloc), cui)))
5702 machine_mode mode2;
5703 enum micro_operation_type type2;
5704 rtx nloc = NULL;
5705 bool resolvable = REG_P (vloc) || MEM_P (vloc);
5707 if (resolvable)
5708 nloc = replace_expr_with_values (vloc);
5710 if (nloc)
5712 oloc = shallow_copy_rtx (oloc);
5713 PAT_VAR_LOCATION_LOC (oloc) = nloc;
5716 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc);
5718 type2 = use_type (vloc, 0, &mode2);
5720 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5721 || type2 == MO_CLOBBER);
5723 if (type2 == MO_CLOBBER
5724 && !cselib_preserved_value_p (val))
5726 VAL_NEEDS_RESOLUTION (oloc) = resolvable;
5727 preserve_value (val);
5730 else if (!VAR_LOC_UNKNOWN_P (vloc))
5732 oloc = shallow_copy_rtx (oloc);
5733 PAT_VAR_LOCATION_LOC (oloc) = gen_rtx_UNKNOWN_VAR_LOC ();
5736 mo.u.loc = oloc;
5738 else if (type == MO_VAL_USE)
5740 machine_mode mode2 = VOIDmode;
5741 enum micro_operation_type type2;
5742 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5743 rtx vloc, oloc = loc, nloc;
5745 gcc_assert (cui->sets);
5747 if (MEM_P (oloc)
5748 && !REG_P (XEXP (oloc, 0))
5749 && !MEM_P (XEXP (oloc, 0)))
5751 rtx mloc = oloc;
5752 machine_mode address_mode = get_address_mode (mloc);
5753 cselib_val *val
5754 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5755 GET_MODE (mloc));
5757 if (val && !cselib_preserved_value_p (val))
5758 preserve_value (val);
5761 type2 = use_type (loc, 0, &mode2);
5763 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5764 || type2 == MO_CLOBBER);
5766 if (type2 == MO_USE)
5767 vloc = var_lowpart (mode2, loc);
5768 else
5769 vloc = oloc;
5771 /* The loc of a MO_VAL_USE may have two forms:
5773 (concat val src): val is at src, a value-based
5774 representation.
5776 (concat (concat val use) src): same as above, with use as
5777 the MO_USE tracked value, if it differs from src.
5781 gcc_checking_assert (REG_P (loc) || MEM_P (loc));
5782 nloc = replace_expr_with_values (loc);
5783 if (!nloc)
5784 nloc = oloc;
5786 if (vloc != nloc)
5787 oloc = gen_rtx_CONCAT (mode2, val->val_rtx, vloc);
5788 else
5789 oloc = val->val_rtx;
5791 mo.u.loc = gen_rtx_CONCAT (mode, oloc, nloc);
5793 if (type2 == MO_USE)
5794 VAL_HOLDS_TRACK_EXPR (mo.u.loc) = 1;
5795 if (!cselib_preserved_value_p (val))
5797 VAL_NEEDS_RESOLUTION (mo.u.loc) = 1;
5798 preserve_value (val);
5801 else
5802 gcc_assert (type == MO_USE || type == MO_USE_NO_VAR);
5804 if (dump_file && (dump_flags & TDF_DETAILS))
5805 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
5806 VTI (bb)->mos.safe_push (mo);
5810 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5812 static void
5813 add_uses_1 (rtx *x, void *cui)
5815 subrtx_var_iterator::array_type array;
5816 FOR_EACH_SUBRTX_VAR (iter, array, *x, NONCONST)
5817 add_uses (*iter, (struct count_use_info *) cui);
5820 /* This is the value used during expansion of locations. We want it
5821 to be unbounded, so that variables expanded deep in a recursion
5822 nest are fully evaluated, so that their values are cached
5823 correctly. We avoid recursion cycles through other means, and we
5824 don't unshare RTL, so excess complexity is not a problem. */
5825 #define EXPR_DEPTH (INT_MAX)
5826 /* We use this to keep too-complex expressions from being emitted as
5827 location notes, and then to debug information. Users can trade
5828 compile time for ridiculously complex expressions, although they're
5829 seldom useful, and they may often have to be discarded as not
5830 representable anyway. */
5831 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5833 /* Attempt to reverse the EXPR operation in the debug info and record
5834 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5835 no longer live we can express its value as VAL - 6. */
5837 static void
5838 reverse_op (rtx val, const_rtx expr, rtx_insn *insn)
5840 rtx src, arg, ret;
5841 cselib_val *v;
5842 struct elt_loc_list *l;
5843 enum rtx_code code;
5844 int count;
5846 if (GET_CODE (expr) != SET)
5847 return;
5849 if (!REG_P (SET_DEST (expr)) || GET_MODE (val) != GET_MODE (SET_DEST (expr)))
5850 return;
5852 src = SET_SRC (expr);
5853 switch (GET_CODE (src))
5855 case PLUS:
5856 case MINUS:
5857 case XOR:
5858 case NOT:
5859 case NEG:
5860 if (!REG_P (XEXP (src, 0)))
5861 return;
5862 break;
5863 case SIGN_EXTEND:
5864 case ZERO_EXTEND:
5865 if (!REG_P (XEXP (src, 0)) && !MEM_P (XEXP (src, 0)))
5866 return;
5867 break;
5868 default:
5869 return;
5872 if (!SCALAR_INT_MODE_P (GET_MODE (src)) || XEXP (src, 0) == cfa_base_rtx)
5873 return;
5875 v = cselib_lookup (XEXP (src, 0), GET_MODE (XEXP (src, 0)), 0, VOIDmode);
5876 if (!v || !cselib_preserved_value_p (v))
5877 return;
5879 /* Use canonical V to avoid creating multiple redundant expressions
5880 for different VALUES equivalent to V. */
5881 v = canonical_cselib_val (v);
5883 /* Adding a reverse op isn't useful if V already has an always valid
5884 location. Ignore ENTRY_VALUE, while it is always constant, we should
5885 prefer non-ENTRY_VALUE locations whenever possible. */
5886 for (l = v->locs, count = 0; l; l = l->next, count++)
5887 if (CONSTANT_P (l->loc)
5888 && (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
5889 return;
5890 /* Avoid creating too large locs lists. */
5891 else if (count == PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE))
5892 return;
5894 switch (GET_CODE (src))
5896 case NOT:
5897 case NEG:
5898 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5899 return;
5900 ret = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (val), val);
5901 break;
5902 case SIGN_EXTEND:
5903 case ZERO_EXTEND:
5904 ret = gen_lowpart_SUBREG (GET_MODE (v->val_rtx), val);
5905 break;
5906 case XOR:
5907 code = XOR;
5908 goto binary;
5909 case PLUS:
5910 code = MINUS;
5911 goto binary;
5912 case MINUS:
5913 code = PLUS;
5914 goto binary;
5915 binary:
5916 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5917 return;
5918 arg = XEXP (src, 1);
5919 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5921 arg = cselib_expand_value_rtx (arg, scratch_regs, 5);
5922 if (arg == NULL_RTX)
5923 return;
5924 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5925 return;
5927 ret = simplify_gen_binary (code, GET_MODE (val), val, arg);
5928 break;
5929 default:
5930 gcc_unreachable ();
5933 cselib_add_permanent_equiv (v, ret, insn);
5936 /* Add stores (register and memory references) LOC which will be tracked
5937 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5938 CUIP->insn is instruction which the LOC is part of. */
5940 static void
5941 add_stores (rtx loc, const_rtx expr, void *cuip)
5943 machine_mode mode = VOIDmode, mode2;
5944 struct count_use_info *cui = (struct count_use_info *)cuip;
5945 basic_block bb = cui->bb;
5946 micro_operation mo;
5947 rtx oloc = loc, nloc, src = NULL;
5948 enum micro_operation_type type = use_type (loc, cui, &mode);
5949 bool track_p = false;
5950 cselib_val *v;
5951 bool resolve, preserve;
5953 if (type == MO_CLOBBER)
5954 return;
5956 mode2 = mode;
5958 if (REG_P (loc))
5960 gcc_assert (loc != cfa_base_rtx);
5961 if ((GET_CODE (expr) == CLOBBER && type != MO_VAL_SET)
5962 || !(track_p = use_type (loc, NULL, &mode2) == MO_USE)
5963 || GET_CODE (expr) == CLOBBER)
5965 mo.type = MO_CLOBBER;
5966 mo.u.loc = loc;
5967 if (GET_CODE (expr) == SET
5968 && SET_DEST (expr) == loc
5969 && !unsuitable_loc (SET_SRC (expr))
5970 && find_use_val (loc, mode, cui))
5972 gcc_checking_assert (type == MO_VAL_SET);
5973 mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
5976 else
5978 if (GET_CODE (expr) == SET
5979 && SET_DEST (expr) == loc
5980 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
5981 src = var_lowpart (mode2, SET_SRC (expr));
5982 loc = var_lowpart (mode2, loc);
5984 if (src == NULL)
5986 mo.type = MO_SET;
5987 mo.u.loc = loc;
5989 else
5991 rtx xexpr = gen_rtx_SET (loc, src);
5992 if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
5994 /* If this is an instruction copying (part of) a parameter
5995 passed by invisible reference to its register location,
5996 pretend it's a SET so that the initial memory location
5997 is discarded, as the parameter register can be reused
5998 for other purposes and we do not track locations based
5999 on generic registers. */
6000 if (MEM_P (src)
6001 && REG_EXPR (loc)
6002 && TREE_CODE (REG_EXPR (loc)) == PARM_DECL
6003 && DECL_MODE (REG_EXPR (loc)) != BLKmode
6004 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc)))
6005 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc)), 0)
6006 != arg_pointer_rtx)
6007 mo.type = MO_SET;
6008 else
6009 mo.type = MO_COPY;
6011 else
6012 mo.type = MO_SET;
6013 mo.u.loc = xexpr;
6016 mo.insn = cui->insn;
6018 else if (MEM_P (loc)
6019 && ((track_p = use_type (loc, NULL, &mode2) == MO_USE)
6020 || cui->sets))
6022 if (MEM_P (loc) && type == MO_VAL_SET
6023 && !REG_P (XEXP (loc, 0))
6024 && !MEM_P (XEXP (loc, 0)))
6026 rtx mloc = loc;
6027 machine_mode address_mode = get_address_mode (mloc);
6028 cselib_val *val = cselib_lookup (XEXP (mloc, 0),
6029 address_mode, 0,
6030 GET_MODE (mloc));
6032 if (val && !cselib_preserved_value_p (val))
6033 preserve_value (val);
6036 if (GET_CODE (expr) == CLOBBER || !track_p)
6038 mo.type = MO_CLOBBER;
6039 mo.u.loc = track_p ? var_lowpart (mode2, loc) : loc;
6041 else
6043 if (GET_CODE (expr) == SET
6044 && SET_DEST (expr) == loc
6045 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
6046 src = var_lowpart (mode2, SET_SRC (expr));
6047 loc = var_lowpart (mode2, loc);
6049 if (src == NULL)
6051 mo.type = MO_SET;
6052 mo.u.loc = loc;
6054 else
6056 rtx xexpr = gen_rtx_SET (loc, src);
6057 if (same_variable_part_p (SET_SRC (xexpr),
6058 MEM_EXPR (loc),
6059 int_mem_offset (loc)))
6060 mo.type = MO_COPY;
6061 else
6062 mo.type = MO_SET;
6063 mo.u.loc = xexpr;
6066 mo.insn = cui->insn;
6068 else
6069 return;
6071 if (type != MO_VAL_SET)
6072 goto log_and_return;
6074 v = find_use_val (oloc, mode, cui);
6076 if (!v)
6077 goto log_and_return;
6079 resolve = preserve = !cselib_preserved_value_p (v);
6081 /* We cannot track values for multiple-part variables, so we track only
6082 locations for tracked record parameters. */
6083 if (track_p
6084 && REG_P (loc)
6085 && REG_EXPR (loc)
6086 && tracked_record_parameter_p (REG_EXPR (loc)))
6088 /* Although we don't use the value here, it could be used later by the
6089 mere virtue of its existence as the operand of the reverse operation
6090 that gave rise to it (typically extension/truncation). Make sure it
6091 is preserved as required by vt_expand_var_loc_chain. */
6092 if (preserve)
6093 preserve_value (v);
6094 goto log_and_return;
6097 if (loc == stack_pointer_rtx
6098 && hard_frame_pointer_adjustment != -1
6099 && preserve)
6100 cselib_set_value_sp_based (v);
6102 nloc = replace_expr_with_values (oloc);
6103 if (nloc)
6104 oloc = nloc;
6106 if (GET_CODE (PATTERN (cui->insn)) == COND_EXEC)
6108 cselib_val *oval = cselib_lookup (oloc, GET_MODE (oloc), 0, VOIDmode);
6110 if (oval == v)
6111 return;
6112 gcc_assert (REG_P (oloc) || MEM_P (oloc));
6114 if (oval && !cselib_preserved_value_p (oval))
6116 micro_operation moa;
6118 preserve_value (oval);
6120 moa.type = MO_VAL_USE;
6121 moa.u.loc = gen_rtx_CONCAT (mode, oval->val_rtx, oloc);
6122 VAL_NEEDS_RESOLUTION (moa.u.loc) = 1;
6123 moa.insn = cui->insn;
6125 if (dump_file && (dump_flags & TDF_DETAILS))
6126 log_op_type (moa.u.loc, cui->bb, cui->insn,
6127 moa.type, dump_file);
6128 VTI (bb)->mos.safe_push (moa);
6131 resolve = false;
6133 else if (resolve && GET_CODE (mo.u.loc) == SET)
6135 if (REG_P (SET_SRC (expr)) || MEM_P (SET_SRC (expr)))
6136 nloc = replace_expr_with_values (SET_SRC (expr));
6137 else
6138 nloc = NULL_RTX;
6140 /* Avoid the mode mismatch between oexpr and expr. */
6141 if (!nloc && mode != mode2)
6143 nloc = SET_SRC (expr);
6144 gcc_assert (oloc == SET_DEST (expr));
6147 if (nloc && nloc != SET_SRC (mo.u.loc))
6148 oloc = gen_rtx_SET (oloc, nloc);
6149 else
6151 if (oloc == SET_DEST (mo.u.loc))
6152 /* No point in duplicating. */
6153 oloc = mo.u.loc;
6154 if (!REG_P (SET_SRC (mo.u.loc)))
6155 resolve = false;
6158 else if (!resolve)
6160 if (GET_CODE (mo.u.loc) == SET
6161 && oloc == SET_DEST (mo.u.loc))
6162 /* No point in duplicating. */
6163 oloc = mo.u.loc;
6165 else
6166 resolve = false;
6168 loc = gen_rtx_CONCAT (mode, v->val_rtx, oloc);
6170 if (mo.u.loc != oloc)
6171 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, mo.u.loc);
6173 /* The loc of a MO_VAL_SET may have various forms:
6175 (concat val dst): dst now holds val
6177 (concat val (set dst src)): dst now holds val, copied from src
6179 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6180 after replacing mems and non-top-level regs with values.
6182 (concat (concat val dstv) (set dst src)): dst now holds val,
6183 copied from src. dstv is a value-based representation of dst, if
6184 it differs from dst. If resolution is needed, src is a REG, and
6185 its mode is the same as that of val.
6187 (concat (concat val (set dstv srcv)) (set dst src)): src
6188 copied to dst, holding val. dstv and srcv are value-based
6189 representations of dst and src, respectively.
6193 if (GET_CODE (PATTERN (cui->insn)) != COND_EXEC)
6194 reverse_op (v->val_rtx, expr, cui->insn);
6196 mo.u.loc = loc;
6198 if (track_p)
6199 VAL_HOLDS_TRACK_EXPR (loc) = 1;
6200 if (preserve)
6202 VAL_NEEDS_RESOLUTION (loc) = resolve;
6203 preserve_value (v);
6205 if (mo.type == MO_CLOBBER)
6206 VAL_EXPR_IS_CLOBBERED (loc) = 1;
6207 if (mo.type == MO_COPY)
6208 VAL_EXPR_IS_COPIED (loc) = 1;
6210 mo.type = MO_VAL_SET;
6212 log_and_return:
6213 if (dump_file && (dump_flags & TDF_DETAILS))
6214 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
6215 VTI (bb)->mos.safe_push (mo);
6218 /* Arguments to the call. */
6219 static rtx call_arguments;
6221 /* Compute call_arguments. */
6223 static void
6224 prepare_call_arguments (basic_block bb, rtx_insn *insn)
6226 rtx link, x, call;
6227 rtx prev, cur, next;
6228 rtx this_arg = NULL_RTX;
6229 tree type = NULL_TREE, t, fndecl = NULL_TREE;
6230 tree obj_type_ref = NULL_TREE;
6231 CUMULATIVE_ARGS args_so_far_v;
6232 cumulative_args_t args_so_far;
6234 memset (&args_so_far_v, 0, sizeof (args_so_far_v));
6235 args_so_far = pack_cumulative_args (&args_so_far_v);
6236 call = get_call_rtx_from (insn);
6237 if (call)
6239 if (GET_CODE (XEXP (XEXP (call, 0), 0)) == SYMBOL_REF)
6241 rtx symbol = XEXP (XEXP (call, 0), 0);
6242 if (SYMBOL_REF_DECL (symbol))
6243 fndecl = SYMBOL_REF_DECL (symbol);
6245 if (fndecl == NULL_TREE)
6246 fndecl = MEM_EXPR (XEXP (call, 0));
6247 if (fndecl
6248 && TREE_CODE (TREE_TYPE (fndecl)) != FUNCTION_TYPE
6249 && TREE_CODE (TREE_TYPE (fndecl)) != METHOD_TYPE)
6250 fndecl = NULL_TREE;
6251 if (fndecl && TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6252 type = TREE_TYPE (fndecl);
6253 if (fndecl && TREE_CODE (fndecl) != FUNCTION_DECL)
6255 if (TREE_CODE (fndecl) == INDIRECT_REF
6256 && TREE_CODE (TREE_OPERAND (fndecl, 0)) == OBJ_TYPE_REF)
6257 obj_type_ref = TREE_OPERAND (fndecl, 0);
6258 fndecl = NULL_TREE;
6260 if (type)
6262 for (t = TYPE_ARG_TYPES (type); t && t != void_list_node;
6263 t = TREE_CHAIN (t))
6264 if (TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
6265 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t))))
6266 break;
6267 if ((t == NULL || t == void_list_node) && obj_type_ref == NULL_TREE)
6268 type = NULL;
6269 else
6271 int nargs ATTRIBUTE_UNUSED = list_length (TYPE_ARG_TYPES (type));
6272 link = CALL_INSN_FUNCTION_USAGE (insn);
6273 #ifndef PCC_STATIC_STRUCT_RETURN
6274 if (aggregate_value_p (TREE_TYPE (type), type)
6275 && targetm.calls.struct_value_rtx (type, 0) == 0)
6277 tree struct_addr = build_pointer_type (TREE_TYPE (type));
6278 machine_mode mode = TYPE_MODE (struct_addr);
6279 rtx reg;
6280 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6281 nargs + 1);
6282 reg = targetm.calls.function_arg (args_so_far, mode,
6283 struct_addr, true);
6284 targetm.calls.function_arg_advance (args_so_far, mode,
6285 struct_addr, true);
6286 if (reg == NULL_RTX)
6288 for (; link; link = XEXP (link, 1))
6289 if (GET_CODE (XEXP (link, 0)) == USE
6290 && MEM_P (XEXP (XEXP (link, 0), 0)))
6292 link = XEXP (link, 1);
6293 break;
6297 else
6298 #endif
6299 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6300 nargs);
6301 if (obj_type_ref && TYPE_ARG_TYPES (type) != void_list_node)
6303 machine_mode mode;
6304 t = TYPE_ARG_TYPES (type);
6305 mode = TYPE_MODE (TREE_VALUE (t));
6306 this_arg = targetm.calls.function_arg (args_so_far, mode,
6307 TREE_VALUE (t), true);
6308 if (this_arg && !REG_P (this_arg))
6309 this_arg = NULL_RTX;
6310 else if (this_arg == NULL_RTX)
6312 for (; link; link = XEXP (link, 1))
6313 if (GET_CODE (XEXP (link, 0)) == USE
6314 && MEM_P (XEXP (XEXP (link, 0), 0)))
6316 this_arg = XEXP (XEXP (link, 0), 0);
6317 break;
6324 t = type ? TYPE_ARG_TYPES (type) : NULL_TREE;
6326 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6327 if (GET_CODE (XEXP (link, 0)) == USE)
6329 rtx item = NULL_RTX;
6330 x = XEXP (XEXP (link, 0), 0);
6331 if (GET_MODE (link) == VOIDmode
6332 || GET_MODE (link) == BLKmode
6333 || (GET_MODE (link) != GET_MODE (x)
6334 && ((GET_MODE_CLASS (GET_MODE (link)) != MODE_INT
6335 && GET_MODE_CLASS (GET_MODE (link)) != MODE_PARTIAL_INT)
6336 || (GET_MODE_CLASS (GET_MODE (x)) != MODE_INT
6337 && GET_MODE_CLASS (GET_MODE (x)) != MODE_PARTIAL_INT))))
6338 /* Can't do anything for these, if the original type mode
6339 isn't known or can't be converted. */;
6340 else if (REG_P (x))
6342 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6343 scalar_int_mode mode;
6344 if (val && cselib_preserved_value_p (val))
6345 item = val->val_rtx;
6346 else if (is_a <scalar_int_mode> (GET_MODE (x), &mode))
6348 opt_scalar_int_mode mode_iter;
6349 FOR_EACH_WIDER_MODE (mode_iter, mode)
6351 mode = mode_iter.require ();
6352 if (GET_MODE_BITSIZE (mode) > BITS_PER_WORD)
6353 break;
6355 rtx reg = simplify_subreg (mode, x, GET_MODE (x), 0);
6356 if (reg == NULL_RTX || !REG_P (reg))
6357 continue;
6358 val = cselib_lookup (reg, mode, 0, VOIDmode);
6359 if (val && cselib_preserved_value_p (val))
6361 item = val->val_rtx;
6362 break;
6367 else if (MEM_P (x))
6369 rtx mem = x;
6370 cselib_val *val;
6372 if (!frame_pointer_needed)
6374 struct adjust_mem_data amd;
6375 amd.mem_mode = VOIDmode;
6376 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
6377 amd.store = true;
6378 mem = simplify_replace_fn_rtx (mem, NULL_RTX, adjust_mems,
6379 &amd);
6380 gcc_assert (amd.side_effects.is_empty ());
6382 val = cselib_lookup (mem, GET_MODE (mem), 0, VOIDmode);
6383 if (val && cselib_preserved_value_p (val))
6384 item = val->val_rtx;
6385 else if (GET_MODE_CLASS (GET_MODE (mem)) != MODE_INT
6386 && GET_MODE_CLASS (GET_MODE (mem)) != MODE_PARTIAL_INT)
6388 /* For non-integer stack argument see also if they weren't
6389 initialized by integers. */
6390 scalar_int_mode imode;
6391 if (int_mode_for_mode (GET_MODE (mem)).exists (&imode)
6392 && imode != GET_MODE (mem))
6394 val = cselib_lookup (adjust_address_nv (mem, imode, 0),
6395 imode, 0, VOIDmode);
6396 if (val && cselib_preserved_value_p (val))
6397 item = lowpart_subreg (GET_MODE (x), val->val_rtx,
6398 imode);
6402 if (item)
6404 rtx x2 = x;
6405 if (GET_MODE (item) != GET_MODE (link))
6406 item = lowpart_subreg (GET_MODE (link), item, GET_MODE (item));
6407 if (GET_MODE (x2) != GET_MODE (link))
6408 x2 = lowpart_subreg (GET_MODE (link), x2, GET_MODE (x2));
6409 item = gen_rtx_CONCAT (GET_MODE (link), x2, item);
6410 call_arguments
6411 = gen_rtx_EXPR_LIST (VOIDmode, item, call_arguments);
6413 if (t && t != void_list_node)
6415 tree argtype = TREE_VALUE (t);
6416 machine_mode mode = TYPE_MODE (argtype);
6417 rtx reg;
6418 if (pass_by_reference (&args_so_far_v, mode, argtype, true))
6420 argtype = build_pointer_type (argtype);
6421 mode = TYPE_MODE (argtype);
6423 reg = targetm.calls.function_arg (args_so_far, mode,
6424 argtype, true);
6425 if (TREE_CODE (argtype) == REFERENCE_TYPE
6426 && INTEGRAL_TYPE_P (TREE_TYPE (argtype))
6427 && reg
6428 && REG_P (reg)
6429 && GET_MODE (reg) == mode
6430 && (GET_MODE_CLASS (mode) == MODE_INT
6431 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
6432 && REG_P (x)
6433 && REGNO (x) == REGNO (reg)
6434 && GET_MODE (x) == mode
6435 && item)
6437 machine_mode indmode
6438 = TYPE_MODE (TREE_TYPE (argtype));
6439 rtx mem = gen_rtx_MEM (indmode, x);
6440 cselib_val *val = cselib_lookup (mem, indmode, 0, VOIDmode);
6441 if (val && cselib_preserved_value_p (val))
6443 item = gen_rtx_CONCAT (indmode, mem, val->val_rtx);
6444 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6445 call_arguments);
6447 else
6449 struct elt_loc_list *l;
6450 tree initial;
6452 /* Try harder, when passing address of a constant
6453 pool integer it can be easily read back. */
6454 item = XEXP (item, 1);
6455 if (GET_CODE (item) == SUBREG)
6456 item = SUBREG_REG (item);
6457 gcc_assert (GET_CODE (item) == VALUE);
6458 val = CSELIB_VAL_PTR (item);
6459 for (l = val->locs; l; l = l->next)
6460 if (GET_CODE (l->loc) == SYMBOL_REF
6461 && TREE_CONSTANT_POOL_ADDRESS_P (l->loc)
6462 && SYMBOL_REF_DECL (l->loc)
6463 && DECL_INITIAL (SYMBOL_REF_DECL (l->loc)))
6465 initial = DECL_INITIAL (SYMBOL_REF_DECL (l->loc));
6466 if (tree_fits_shwi_p (initial))
6468 item = GEN_INT (tree_to_shwi (initial));
6469 item = gen_rtx_CONCAT (indmode, mem, item);
6470 call_arguments
6471 = gen_rtx_EXPR_LIST (VOIDmode, item,
6472 call_arguments);
6474 break;
6478 targetm.calls.function_arg_advance (args_so_far, mode,
6479 argtype, true);
6480 t = TREE_CHAIN (t);
6484 /* Add debug arguments. */
6485 if (fndecl
6486 && TREE_CODE (fndecl) == FUNCTION_DECL
6487 && DECL_HAS_DEBUG_ARGS_P (fndecl))
6489 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (fndecl);
6490 if (debug_args)
6492 unsigned int ix;
6493 tree param;
6494 for (ix = 0; vec_safe_iterate (*debug_args, ix, &param); ix += 2)
6496 rtx item;
6497 tree dtemp = (**debug_args)[ix + 1];
6498 machine_mode mode = DECL_MODE (dtemp);
6499 item = gen_rtx_DEBUG_PARAMETER_REF (mode, param);
6500 item = gen_rtx_CONCAT (mode, item, DECL_RTL_KNOWN_SET (dtemp));
6501 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6502 call_arguments);
6507 /* Reverse call_arguments chain. */
6508 prev = NULL_RTX;
6509 for (cur = call_arguments; cur; cur = next)
6511 next = XEXP (cur, 1);
6512 XEXP (cur, 1) = prev;
6513 prev = cur;
6515 call_arguments = prev;
6517 x = get_call_rtx_from (insn);
6518 if (x)
6520 x = XEXP (XEXP (x, 0), 0);
6521 if (GET_CODE (x) == SYMBOL_REF)
6522 /* Don't record anything. */;
6523 else if (CONSTANT_P (x))
6525 x = gen_rtx_CONCAT (GET_MODE (x) == VOIDmode ? Pmode : GET_MODE (x),
6526 pc_rtx, x);
6527 call_arguments
6528 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6530 else
6532 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6533 if (val && cselib_preserved_value_p (val))
6535 x = gen_rtx_CONCAT (GET_MODE (x), pc_rtx, val->val_rtx);
6536 call_arguments
6537 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6541 if (this_arg)
6543 machine_mode mode
6544 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref)));
6545 rtx clobbered = gen_rtx_MEM (mode, this_arg);
6546 HOST_WIDE_INT token
6547 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref));
6548 if (token)
6549 clobbered = plus_constant (mode, clobbered,
6550 token * GET_MODE_SIZE (mode));
6551 clobbered = gen_rtx_MEM (mode, clobbered);
6552 x = gen_rtx_CONCAT (mode, gen_rtx_CLOBBER (VOIDmode, pc_rtx), clobbered);
6553 call_arguments
6554 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6558 /* Callback for cselib_record_sets_hook, that records as micro
6559 operations uses and stores in an insn after cselib_record_sets has
6560 analyzed the sets in an insn, but before it modifies the stored
6561 values in the internal tables, unless cselib_record_sets doesn't
6562 call it directly (perhaps because we're not doing cselib in the
6563 first place, in which case sets and n_sets will be 0). */
6565 static void
6566 add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
6568 basic_block bb = BLOCK_FOR_INSN (insn);
6569 int n1, n2;
6570 struct count_use_info cui;
6571 micro_operation *mos;
6573 cselib_hook_called = true;
6575 cui.insn = insn;
6576 cui.bb = bb;
6577 cui.sets = sets;
6578 cui.n_sets = n_sets;
6580 n1 = VTI (bb)->mos.length ();
6581 cui.store_p = false;
6582 note_uses (&PATTERN (insn), add_uses_1, &cui);
6583 n2 = VTI (bb)->mos.length () - 1;
6584 mos = VTI (bb)->mos.address ();
6586 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6587 MO_VAL_LOC last. */
6588 while (n1 < n2)
6590 while (n1 < n2 && mos[n1].type == MO_USE)
6591 n1++;
6592 while (n1 < n2 && mos[n2].type != MO_USE)
6593 n2--;
6594 if (n1 < n2)
6595 std::swap (mos[n1], mos[n2]);
6598 n2 = VTI (bb)->mos.length () - 1;
6599 while (n1 < n2)
6601 while (n1 < n2 && mos[n1].type != MO_VAL_LOC)
6602 n1++;
6603 while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
6604 n2--;
6605 if (n1 < n2)
6606 std::swap (mos[n1], mos[n2]);
6609 if (CALL_P (insn))
6611 micro_operation mo;
6613 mo.type = MO_CALL;
6614 mo.insn = insn;
6615 mo.u.loc = call_arguments;
6616 call_arguments = NULL_RTX;
6618 if (dump_file && (dump_flags & TDF_DETAILS))
6619 log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
6620 VTI (bb)->mos.safe_push (mo);
6623 n1 = VTI (bb)->mos.length ();
6624 /* This will record NEXT_INSN (insn), such that we can
6625 insert notes before it without worrying about any
6626 notes that MO_USEs might emit after the insn. */
6627 cui.store_p = true;
6628 note_stores (PATTERN (insn), add_stores, &cui);
6629 n2 = VTI (bb)->mos.length () - 1;
6630 mos = VTI (bb)->mos.address ();
6632 /* Order the MO_VAL_USEs first (note_stores does nothing
6633 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6634 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6635 while (n1 < n2)
6637 while (n1 < n2 && mos[n1].type == MO_VAL_USE)
6638 n1++;
6639 while (n1 < n2 && mos[n2].type != MO_VAL_USE)
6640 n2--;
6641 if (n1 < n2)
6642 std::swap (mos[n1], mos[n2]);
6645 n2 = VTI (bb)->mos.length () - 1;
6646 while (n1 < n2)
6648 while (n1 < n2 && mos[n1].type == MO_CLOBBER)
6649 n1++;
6650 while (n1 < n2 && mos[n2].type != MO_CLOBBER)
6651 n2--;
6652 if (n1 < n2)
6653 std::swap (mos[n1], mos[n2]);
6657 static enum var_init_status
6658 find_src_status (dataflow_set *in, rtx src)
6660 tree decl = NULL_TREE;
6661 enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED;
6663 if (! flag_var_tracking_uninit)
6664 status = VAR_INIT_STATUS_INITIALIZED;
6666 if (src && REG_P (src))
6667 decl = var_debug_decl (REG_EXPR (src));
6668 else if (src && MEM_P (src))
6669 decl = var_debug_decl (MEM_EXPR (src));
6671 if (src && decl)
6672 status = get_init_value (in, src, dv_from_decl (decl));
6674 return status;
6677 /* SRC is the source of an assignment. Use SET to try to find what
6678 was ultimately assigned to SRC. Return that value if known,
6679 otherwise return SRC itself. */
6681 static rtx
6682 find_src_set_src (dataflow_set *set, rtx src)
6684 tree decl = NULL_TREE; /* The variable being copied around. */
6685 rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */
6686 variable *var;
6687 location_chain *nextp;
6688 int i;
6689 bool found;
6691 if (src && REG_P (src))
6692 decl = var_debug_decl (REG_EXPR (src));
6693 else if (src && MEM_P (src))
6694 decl = var_debug_decl (MEM_EXPR (src));
6696 if (src && decl)
6698 decl_or_value dv = dv_from_decl (decl);
6700 var = shared_hash_find (set->vars, dv);
6701 if (var)
6703 found = false;
6704 for (i = 0; i < var->n_var_parts && !found; i++)
6705 for (nextp = var->var_part[i].loc_chain; nextp && !found;
6706 nextp = nextp->next)
6707 if (rtx_equal_p (nextp->loc, src))
6709 set_src = nextp->set_src;
6710 found = true;
6716 return set_src;
6719 /* Compute the changes of variable locations in the basic block BB. */
6721 static bool
6722 compute_bb_dataflow (basic_block bb)
6724 unsigned int i;
6725 micro_operation *mo;
6726 bool changed;
6727 dataflow_set old_out;
6728 dataflow_set *in = &VTI (bb)->in;
6729 dataflow_set *out = &VTI (bb)->out;
6731 dataflow_set_init (&old_out);
6732 dataflow_set_copy (&old_out, out);
6733 dataflow_set_copy (out, in);
6735 if (MAY_HAVE_DEBUG_BIND_INSNS)
6736 local_get_addr_cache = new hash_map<rtx, rtx>;
6738 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
6740 rtx_insn *insn = mo->insn;
6742 switch (mo->type)
6744 case MO_CALL:
6745 dataflow_set_clear_at_call (out, insn);
6746 break;
6748 case MO_USE:
6750 rtx loc = mo->u.loc;
6752 if (REG_P (loc))
6753 var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6754 else if (MEM_P (loc))
6755 var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6757 break;
6759 case MO_VAL_LOC:
6761 rtx loc = mo->u.loc;
6762 rtx val, vloc;
6763 tree var;
6765 if (GET_CODE (loc) == CONCAT)
6767 val = XEXP (loc, 0);
6768 vloc = XEXP (loc, 1);
6770 else
6772 val = NULL_RTX;
6773 vloc = loc;
6776 var = PAT_VAR_LOCATION_DECL (vloc);
6778 clobber_variable_part (out, NULL_RTX,
6779 dv_from_decl (var), 0, NULL_RTX);
6780 if (val)
6782 if (VAL_NEEDS_RESOLUTION (loc))
6783 val_resolve (out, val, PAT_VAR_LOCATION_LOC (vloc), insn);
6784 set_variable_part (out, val, dv_from_decl (var), 0,
6785 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6786 INSERT);
6788 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
6789 set_variable_part (out, PAT_VAR_LOCATION_LOC (vloc),
6790 dv_from_decl (var), 0,
6791 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6792 INSERT);
6794 break;
6796 case MO_VAL_USE:
6798 rtx loc = mo->u.loc;
6799 rtx val, vloc, uloc;
6801 vloc = uloc = XEXP (loc, 1);
6802 val = XEXP (loc, 0);
6804 if (GET_CODE (val) == CONCAT)
6806 uloc = XEXP (val, 1);
6807 val = XEXP (val, 0);
6810 if (VAL_NEEDS_RESOLUTION (loc))
6811 val_resolve (out, val, vloc, insn);
6812 else
6813 val_store (out, val, uloc, insn, false);
6815 if (VAL_HOLDS_TRACK_EXPR (loc))
6817 if (GET_CODE (uloc) == REG)
6818 var_reg_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6819 NULL);
6820 else if (GET_CODE (uloc) == MEM)
6821 var_mem_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6822 NULL);
6825 break;
6827 case MO_VAL_SET:
6829 rtx loc = mo->u.loc;
6830 rtx val, vloc, uloc;
6831 rtx dstv, srcv;
6833 vloc = loc;
6834 uloc = XEXP (vloc, 1);
6835 val = XEXP (vloc, 0);
6836 vloc = uloc;
6838 if (GET_CODE (uloc) == SET)
6840 dstv = SET_DEST (uloc);
6841 srcv = SET_SRC (uloc);
6843 else
6845 dstv = uloc;
6846 srcv = NULL;
6849 if (GET_CODE (val) == CONCAT)
6851 dstv = vloc = XEXP (val, 1);
6852 val = XEXP (val, 0);
6855 if (GET_CODE (vloc) == SET)
6857 srcv = SET_SRC (vloc);
6859 gcc_assert (val != srcv);
6860 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
6862 dstv = vloc = SET_DEST (vloc);
6864 if (VAL_NEEDS_RESOLUTION (loc))
6865 val_resolve (out, val, srcv, insn);
6867 else if (VAL_NEEDS_RESOLUTION (loc))
6869 gcc_assert (GET_CODE (uloc) == SET
6870 && GET_CODE (SET_SRC (uloc)) == REG);
6871 val_resolve (out, val, SET_SRC (uloc), insn);
6874 if (VAL_HOLDS_TRACK_EXPR (loc))
6876 if (VAL_EXPR_IS_CLOBBERED (loc))
6878 if (REG_P (uloc))
6879 var_reg_delete (out, uloc, true);
6880 else if (MEM_P (uloc))
6882 gcc_assert (MEM_P (dstv));
6883 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
6884 var_mem_delete (out, dstv, true);
6887 else
6889 bool copied_p = VAL_EXPR_IS_COPIED (loc);
6890 rtx src = NULL, dst = uloc;
6891 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
6893 if (GET_CODE (uloc) == SET)
6895 src = SET_SRC (uloc);
6896 dst = SET_DEST (uloc);
6899 if (copied_p)
6901 if (flag_var_tracking_uninit)
6903 status = find_src_status (in, src);
6905 if (status == VAR_INIT_STATUS_UNKNOWN)
6906 status = find_src_status (out, src);
6909 src = find_src_set_src (in, src);
6912 if (REG_P (dst))
6913 var_reg_delete_and_set (out, dst, !copied_p,
6914 status, srcv);
6915 else if (MEM_P (dst))
6917 gcc_assert (MEM_P (dstv));
6918 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
6919 var_mem_delete_and_set (out, dstv, !copied_p,
6920 status, srcv);
6924 else if (REG_P (uloc))
6925 var_regno_delete (out, REGNO (uloc));
6926 else if (MEM_P (uloc))
6928 gcc_checking_assert (GET_CODE (vloc) == MEM);
6929 gcc_checking_assert (dstv == vloc);
6930 if (dstv != vloc)
6931 clobber_overlapping_mems (out, vloc);
6934 val_store (out, val, dstv, insn, true);
6936 break;
6938 case MO_SET:
6940 rtx loc = mo->u.loc;
6941 rtx set_src = NULL;
6943 if (GET_CODE (loc) == SET)
6945 set_src = SET_SRC (loc);
6946 loc = SET_DEST (loc);
6949 if (REG_P (loc))
6950 var_reg_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6951 set_src);
6952 else if (MEM_P (loc))
6953 var_mem_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6954 set_src);
6956 break;
6958 case MO_COPY:
6960 rtx loc = mo->u.loc;
6961 enum var_init_status src_status;
6962 rtx set_src = NULL;
6964 if (GET_CODE (loc) == SET)
6966 set_src = SET_SRC (loc);
6967 loc = SET_DEST (loc);
6970 if (! flag_var_tracking_uninit)
6971 src_status = VAR_INIT_STATUS_INITIALIZED;
6972 else
6974 src_status = find_src_status (in, set_src);
6976 if (src_status == VAR_INIT_STATUS_UNKNOWN)
6977 src_status = find_src_status (out, set_src);
6980 set_src = find_src_set_src (in, set_src);
6982 if (REG_P (loc))
6983 var_reg_delete_and_set (out, loc, false, src_status, set_src);
6984 else if (MEM_P (loc))
6985 var_mem_delete_and_set (out, loc, false, src_status, set_src);
6987 break;
6989 case MO_USE_NO_VAR:
6991 rtx loc = mo->u.loc;
6993 if (REG_P (loc))
6994 var_reg_delete (out, loc, false);
6995 else if (MEM_P (loc))
6996 var_mem_delete (out, loc, false);
6998 break;
7000 case MO_CLOBBER:
7002 rtx loc = mo->u.loc;
7004 if (REG_P (loc))
7005 var_reg_delete (out, loc, true);
7006 else if (MEM_P (loc))
7007 var_mem_delete (out, loc, true);
7009 break;
7011 case MO_ADJUST:
7012 out->stack_adjust += mo->u.adjust;
7013 break;
7017 if (MAY_HAVE_DEBUG_BIND_INSNS)
7019 delete local_get_addr_cache;
7020 local_get_addr_cache = NULL;
7022 dataflow_set_equiv_regs (out);
7023 shared_hash_htab (out->vars)
7024 ->traverse <dataflow_set *, canonicalize_values_mark> (out);
7025 shared_hash_htab (out->vars)
7026 ->traverse <dataflow_set *, canonicalize_values_star> (out);
7027 if (flag_checking)
7028 shared_hash_htab (out->vars)
7029 ->traverse <dataflow_set *, canonicalize_loc_order_check> (out);
7031 changed = dataflow_set_different (&old_out, out);
7032 dataflow_set_destroy (&old_out);
7033 return changed;
7036 /* Find the locations of variables in the whole function. */
7038 static bool
7039 vt_find_locations (void)
7041 bb_heap_t *worklist = new bb_heap_t (LONG_MIN);
7042 bb_heap_t *pending = new bb_heap_t (LONG_MIN);
7043 sbitmap in_worklist, in_pending;
7044 basic_block bb;
7045 edge e;
7046 int *bb_order;
7047 int *rc_order;
7048 int i;
7049 int htabsz = 0;
7050 int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
7051 bool success = true;
7053 timevar_push (TV_VAR_TRACKING_DATAFLOW);
7054 /* Compute reverse completion order of depth first search of the CFG
7055 so that the data-flow runs faster. */
7056 rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS);
7057 bb_order = XNEWVEC (int, last_basic_block_for_fn (cfun));
7058 pre_and_rev_post_order_compute (NULL, rc_order, false);
7059 for (i = 0; i < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; i++)
7060 bb_order[rc_order[i]] = i;
7061 free (rc_order);
7063 auto_sbitmap visited (last_basic_block_for_fn (cfun));
7064 in_worklist = sbitmap_alloc (last_basic_block_for_fn (cfun));
7065 in_pending = sbitmap_alloc (last_basic_block_for_fn (cfun));
7066 bitmap_clear (in_worklist);
7068 FOR_EACH_BB_FN (bb, cfun)
7069 pending->insert (bb_order[bb->index], bb);
7070 bitmap_ones (in_pending);
7072 while (success && !pending->empty ())
7074 std::swap (worklist, pending);
7075 std::swap (in_worklist, in_pending);
7077 bitmap_clear (visited);
7079 while (!worklist->empty ())
7081 bb = worklist->extract_min ();
7082 bitmap_clear_bit (in_worklist, bb->index);
7083 gcc_assert (!bitmap_bit_p (visited, bb->index));
7084 if (!bitmap_bit_p (visited, bb->index))
7086 bool changed;
7087 edge_iterator ei;
7088 int oldinsz, oldoutsz;
7090 bitmap_set_bit (visited, bb->index);
7092 if (VTI (bb)->in.vars)
7094 htabsz
7095 -= shared_hash_htab (VTI (bb)->in.vars)->size ()
7096 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7097 oldinsz = shared_hash_htab (VTI (bb)->in.vars)->elements ();
7098 oldoutsz
7099 = shared_hash_htab (VTI (bb)->out.vars)->elements ();
7101 else
7102 oldinsz = oldoutsz = 0;
7104 if (MAY_HAVE_DEBUG_BIND_INSNS)
7106 dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
7107 bool first = true, adjust = false;
7109 /* Calculate the IN set as the intersection of
7110 predecessor OUT sets. */
7112 dataflow_set_clear (in);
7113 dst_can_be_shared = true;
7115 FOR_EACH_EDGE (e, ei, bb->preds)
7116 if (!VTI (e->src)->flooded)
7117 gcc_assert (bb_order[bb->index]
7118 <= bb_order[e->src->index]);
7119 else if (first)
7121 dataflow_set_copy (in, &VTI (e->src)->out);
7122 first_out = &VTI (e->src)->out;
7123 first = false;
7125 else
7127 dataflow_set_merge (in, &VTI (e->src)->out);
7128 adjust = true;
7131 if (adjust)
7133 dataflow_post_merge_adjust (in, &VTI (bb)->permp);
7135 if (flag_checking)
7136 /* Merge and merge_adjust should keep entries in
7137 canonical order. */
7138 shared_hash_htab (in->vars)
7139 ->traverse <dataflow_set *,
7140 canonicalize_loc_order_check> (in);
7142 if (dst_can_be_shared)
7144 shared_hash_destroy (in->vars);
7145 in->vars = shared_hash_copy (first_out->vars);
7149 VTI (bb)->flooded = true;
7151 else
7153 /* Calculate the IN set as union of predecessor OUT sets. */
7154 dataflow_set_clear (&VTI (bb)->in);
7155 FOR_EACH_EDGE (e, ei, bb->preds)
7156 dataflow_set_union (&VTI (bb)->in, &VTI (e->src)->out);
7159 changed = compute_bb_dataflow (bb);
7160 htabsz += shared_hash_htab (VTI (bb)->in.vars)->size ()
7161 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7163 if (htabmax && htabsz > htabmax)
7165 if (MAY_HAVE_DEBUG_BIND_INSNS)
7166 inform (DECL_SOURCE_LOCATION (cfun->decl),
7167 "variable tracking size limit exceeded with "
7168 "-fvar-tracking-assignments, retrying without");
7169 else
7170 inform (DECL_SOURCE_LOCATION (cfun->decl),
7171 "variable tracking size limit exceeded");
7172 success = false;
7173 break;
7176 if (changed)
7178 FOR_EACH_EDGE (e, ei, bb->succs)
7180 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
7181 continue;
7183 if (bitmap_bit_p (visited, e->dest->index))
7185 if (!bitmap_bit_p (in_pending, e->dest->index))
7187 /* Send E->DEST to next round. */
7188 bitmap_set_bit (in_pending, e->dest->index);
7189 pending->insert (bb_order[e->dest->index],
7190 e->dest);
7193 else if (!bitmap_bit_p (in_worklist, e->dest->index))
7195 /* Add E->DEST to current round. */
7196 bitmap_set_bit (in_worklist, e->dest->index);
7197 worklist->insert (bb_order[e->dest->index],
7198 e->dest);
7203 if (dump_file)
7204 fprintf (dump_file,
7205 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7206 bb->index,
7207 (int)shared_hash_htab (VTI (bb)->in.vars)->size (),
7208 oldinsz,
7209 (int)shared_hash_htab (VTI (bb)->out.vars)->size (),
7210 oldoutsz,
7211 (int)worklist->nodes (), (int)pending->nodes (),
7212 htabsz);
7214 if (dump_file && (dump_flags & TDF_DETAILS))
7216 fprintf (dump_file, "BB %i IN:\n", bb->index);
7217 dump_dataflow_set (&VTI (bb)->in);
7218 fprintf (dump_file, "BB %i OUT:\n", bb->index);
7219 dump_dataflow_set (&VTI (bb)->out);
7225 if (success && MAY_HAVE_DEBUG_BIND_INSNS)
7226 FOR_EACH_BB_FN (bb, cfun)
7227 gcc_assert (VTI (bb)->flooded);
7229 free (bb_order);
7230 delete worklist;
7231 delete pending;
7232 sbitmap_free (in_worklist);
7233 sbitmap_free (in_pending);
7235 timevar_pop (TV_VAR_TRACKING_DATAFLOW);
7236 return success;
7239 /* Print the content of the LIST to dump file. */
7241 static void
7242 dump_attrs_list (attrs *list)
7244 for (; list; list = list->next)
7246 if (dv_is_decl_p (list->dv))
7247 print_mem_expr (dump_file, dv_as_decl (list->dv));
7248 else
7249 print_rtl_single (dump_file, dv_as_value (list->dv));
7250 fprintf (dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset);
7252 fprintf (dump_file, "\n");
7255 /* Print the information about variable *SLOT to dump file. */
7258 dump_var_tracking_slot (variable **slot, void *data ATTRIBUTE_UNUSED)
7260 variable *var = *slot;
7262 dump_var (var);
7264 /* Continue traversing the hash table. */
7265 return 1;
7268 /* Print the information about variable VAR to dump file. */
7270 static void
7271 dump_var (variable *var)
7273 int i;
7274 location_chain *node;
7276 if (dv_is_decl_p (var->dv))
7278 const_tree decl = dv_as_decl (var->dv);
7280 if (DECL_NAME (decl))
7282 fprintf (dump_file, " name: %s",
7283 IDENTIFIER_POINTER (DECL_NAME (decl)));
7284 if (dump_flags & TDF_UID)
7285 fprintf (dump_file, "D.%u", DECL_UID (decl));
7287 else if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
7288 fprintf (dump_file, " name: D#%u", DEBUG_TEMP_UID (decl));
7289 else
7290 fprintf (dump_file, " name: D.%u", DECL_UID (decl));
7291 fprintf (dump_file, "\n");
7293 else
7295 fputc (' ', dump_file);
7296 print_rtl_single (dump_file, dv_as_value (var->dv));
7299 for (i = 0; i < var->n_var_parts; i++)
7301 fprintf (dump_file, " offset %ld\n",
7302 (long)(var->onepart ? 0 : VAR_PART_OFFSET (var, i)));
7303 for (node = var->var_part[i].loc_chain; node; node = node->next)
7305 fprintf (dump_file, " ");
7306 if (node->init == VAR_INIT_STATUS_UNINITIALIZED)
7307 fprintf (dump_file, "[uninit]");
7308 print_rtl_single (dump_file, node->loc);
7313 /* Print the information about variables from hash table VARS to dump file. */
7315 static void
7316 dump_vars (variable_table_type *vars)
7318 if (vars->elements () > 0)
7320 fprintf (dump_file, "Variables:\n");
7321 vars->traverse <void *, dump_var_tracking_slot> (NULL);
7325 /* Print the dataflow set SET to dump file. */
7327 static void
7328 dump_dataflow_set (dataflow_set *set)
7330 int i;
7332 fprintf (dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n",
7333 set->stack_adjust);
7334 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
7336 if (set->regs[i])
7338 fprintf (dump_file, "Reg %d:", i);
7339 dump_attrs_list (set->regs[i]);
7342 dump_vars (shared_hash_htab (set->vars));
7343 fprintf (dump_file, "\n");
7346 /* Print the IN and OUT sets for each basic block to dump file. */
7348 static void
7349 dump_dataflow_sets (void)
7351 basic_block bb;
7353 FOR_EACH_BB_FN (bb, cfun)
7355 fprintf (dump_file, "\nBasic block %d:\n", bb->index);
7356 fprintf (dump_file, "IN:\n");
7357 dump_dataflow_set (&VTI (bb)->in);
7358 fprintf (dump_file, "OUT:\n");
7359 dump_dataflow_set (&VTI (bb)->out);
7363 /* Return the variable for DV in dropped_values, inserting one if
7364 requested with INSERT. */
7366 static inline variable *
7367 variable_from_dropped (decl_or_value dv, enum insert_option insert)
7369 variable **slot;
7370 variable *empty_var;
7371 onepart_enum onepart;
7373 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), insert);
7375 if (!slot)
7376 return NULL;
7378 if (*slot)
7379 return *slot;
7381 gcc_checking_assert (insert == INSERT);
7383 onepart = dv_onepart_p (dv);
7385 gcc_checking_assert (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR);
7387 empty_var = onepart_pool_allocate (onepart);
7388 empty_var->dv = dv;
7389 empty_var->refcount = 1;
7390 empty_var->n_var_parts = 0;
7391 empty_var->onepart = onepart;
7392 empty_var->in_changed_variables = false;
7393 empty_var->var_part[0].loc_chain = NULL;
7394 empty_var->var_part[0].cur_loc = NULL;
7395 VAR_LOC_1PAUX (empty_var) = NULL;
7396 set_dv_changed (dv, true);
7398 *slot = empty_var;
7400 return empty_var;
7403 /* Recover the one-part aux from dropped_values. */
7405 static struct onepart_aux *
7406 recover_dropped_1paux (variable *var)
7408 variable *dvar;
7410 gcc_checking_assert (var->onepart);
7412 if (VAR_LOC_1PAUX (var))
7413 return VAR_LOC_1PAUX (var);
7415 if (var->onepart == ONEPART_VDECL)
7416 return NULL;
7418 dvar = variable_from_dropped (var->dv, NO_INSERT);
7420 if (!dvar)
7421 return NULL;
7423 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (dvar);
7424 VAR_LOC_1PAUX (dvar) = NULL;
7426 return VAR_LOC_1PAUX (var);
7429 /* Add variable VAR to the hash table of changed variables and
7430 if it has no locations delete it from SET's hash table. */
7432 static void
7433 variable_was_changed (variable *var, dataflow_set *set)
7435 hashval_t hash = dv_htab_hash (var->dv);
7437 if (emit_notes)
7439 variable **slot;
7441 /* Remember this decl or VALUE has been added to changed_variables. */
7442 set_dv_changed (var->dv, true);
7444 slot = changed_variables->find_slot_with_hash (var->dv, hash, INSERT);
7446 if (*slot)
7448 variable *old_var = *slot;
7449 gcc_assert (old_var->in_changed_variables);
7450 old_var->in_changed_variables = false;
7451 if (var != old_var && var->onepart)
7453 /* Restore the auxiliary info from an empty variable
7454 previously created for changed_variables, so it is
7455 not lost. */
7456 gcc_checking_assert (!VAR_LOC_1PAUX (var));
7457 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (old_var);
7458 VAR_LOC_1PAUX (old_var) = NULL;
7460 variable_htab_free (*slot);
7463 if (set && var->n_var_parts == 0)
7465 onepart_enum onepart = var->onepart;
7466 variable *empty_var = NULL;
7467 variable **dslot = NULL;
7469 if (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR)
7471 dslot = dropped_values->find_slot_with_hash (var->dv,
7472 dv_htab_hash (var->dv),
7473 INSERT);
7474 empty_var = *dslot;
7476 if (empty_var)
7478 gcc_checking_assert (!empty_var->in_changed_variables);
7479 if (!VAR_LOC_1PAUX (var))
7481 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (empty_var);
7482 VAR_LOC_1PAUX (empty_var) = NULL;
7484 else
7485 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
7489 if (!empty_var)
7491 empty_var = onepart_pool_allocate (onepart);
7492 empty_var->dv = var->dv;
7493 empty_var->refcount = 1;
7494 empty_var->n_var_parts = 0;
7495 empty_var->onepart = onepart;
7496 if (dslot)
7498 empty_var->refcount++;
7499 *dslot = empty_var;
7502 else
7503 empty_var->refcount++;
7504 empty_var->in_changed_variables = true;
7505 *slot = empty_var;
7506 if (onepart)
7508 empty_var->var_part[0].loc_chain = NULL;
7509 empty_var->var_part[0].cur_loc = NULL;
7510 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (var);
7511 VAR_LOC_1PAUX (var) = NULL;
7513 goto drop_var;
7515 else
7517 if (var->onepart && !VAR_LOC_1PAUX (var))
7518 recover_dropped_1paux (var);
7519 var->refcount++;
7520 var->in_changed_variables = true;
7521 *slot = var;
7524 else
7526 gcc_assert (set);
7527 if (var->n_var_parts == 0)
7529 variable **slot;
7531 drop_var:
7532 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
7533 if (slot)
7535 if (shared_hash_shared (set->vars))
7536 slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
7537 NO_INSERT);
7538 shared_hash_htab (set->vars)->clear_slot (slot);
7544 /* Look for the index in VAR->var_part corresponding to OFFSET.
7545 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7546 referenced int will be set to the index that the part has or should
7547 have, if it should be inserted. */
7549 static inline int
7550 find_variable_location_part (variable *var, HOST_WIDE_INT offset,
7551 int *insertion_point)
7553 int pos, low, high;
7555 if (var->onepart)
7557 if (offset != 0)
7558 return -1;
7560 if (insertion_point)
7561 *insertion_point = 0;
7563 return var->n_var_parts - 1;
7566 /* Find the location part. */
7567 low = 0;
7568 high = var->n_var_parts;
7569 while (low != high)
7571 pos = (low + high) / 2;
7572 if (VAR_PART_OFFSET (var, pos) < offset)
7573 low = pos + 1;
7574 else
7575 high = pos;
7577 pos = low;
7579 if (insertion_point)
7580 *insertion_point = pos;
7582 if (pos < var->n_var_parts && VAR_PART_OFFSET (var, pos) == offset)
7583 return pos;
7585 return -1;
7588 static variable **
7589 set_slot_part (dataflow_set *set, rtx loc, variable **slot,
7590 decl_or_value dv, HOST_WIDE_INT offset,
7591 enum var_init_status initialized, rtx set_src)
7593 int pos;
7594 location_chain *node, *next;
7595 location_chain **nextp;
7596 variable *var;
7597 onepart_enum onepart;
7599 var = *slot;
7601 if (var)
7602 onepart = var->onepart;
7603 else
7604 onepart = dv_onepart_p (dv);
7606 gcc_checking_assert (offset == 0 || !onepart);
7607 gcc_checking_assert (loc != dv_as_opaque (dv));
7609 if (! flag_var_tracking_uninit)
7610 initialized = VAR_INIT_STATUS_INITIALIZED;
7612 if (!var)
7614 /* Create new variable information. */
7615 var = onepart_pool_allocate (onepart);
7616 var->dv = dv;
7617 var->refcount = 1;
7618 var->n_var_parts = 1;
7619 var->onepart = onepart;
7620 var->in_changed_variables = false;
7621 if (var->onepart)
7622 VAR_LOC_1PAUX (var) = NULL;
7623 else
7624 VAR_PART_OFFSET (var, 0) = offset;
7625 var->var_part[0].loc_chain = NULL;
7626 var->var_part[0].cur_loc = NULL;
7627 *slot = var;
7628 pos = 0;
7629 nextp = &var->var_part[0].loc_chain;
7631 else if (onepart)
7633 int r = -1, c = 0;
7635 gcc_assert (dv_as_opaque (var->dv) == dv_as_opaque (dv));
7637 pos = 0;
7639 if (GET_CODE (loc) == VALUE)
7641 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7642 nextp = &node->next)
7643 if (GET_CODE (node->loc) == VALUE)
7645 if (node->loc == loc)
7647 r = 0;
7648 break;
7650 if (canon_value_cmp (node->loc, loc))
7651 c++;
7652 else
7654 r = 1;
7655 break;
7658 else if (REG_P (node->loc) || MEM_P (node->loc))
7659 c++;
7660 else
7662 r = 1;
7663 break;
7666 else if (REG_P (loc))
7668 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7669 nextp = &node->next)
7670 if (REG_P (node->loc))
7672 if (REGNO (node->loc) < REGNO (loc))
7673 c++;
7674 else
7676 if (REGNO (node->loc) == REGNO (loc))
7677 r = 0;
7678 else
7679 r = 1;
7680 break;
7683 else
7685 r = 1;
7686 break;
7689 else if (MEM_P (loc))
7691 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7692 nextp = &node->next)
7693 if (REG_P (node->loc))
7694 c++;
7695 else if (MEM_P (node->loc))
7697 if ((r = loc_cmp (XEXP (node->loc, 0), XEXP (loc, 0))) >= 0)
7698 break;
7699 else
7700 c++;
7702 else
7704 r = 1;
7705 break;
7708 else
7709 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7710 nextp = &node->next)
7711 if ((r = loc_cmp (node->loc, loc)) >= 0)
7712 break;
7713 else
7714 c++;
7716 if (r == 0)
7717 return slot;
7719 if (shared_var_p (var, set->vars))
7721 slot = unshare_variable (set, slot, var, initialized);
7722 var = *slot;
7723 for (nextp = &var->var_part[0].loc_chain; c;
7724 nextp = &(*nextp)->next)
7725 c--;
7726 gcc_assert ((!node && !*nextp) || node->loc == (*nextp)->loc);
7729 else
7731 int inspos = 0;
7733 gcc_assert (dv_as_decl (var->dv) == dv_as_decl (dv));
7735 pos = find_variable_location_part (var, offset, &inspos);
7737 if (pos >= 0)
7739 node = var->var_part[pos].loc_chain;
7741 if (node
7742 && ((REG_P (node->loc) && REG_P (loc)
7743 && REGNO (node->loc) == REGNO (loc))
7744 || rtx_equal_p (node->loc, loc)))
7746 /* LOC is in the beginning of the chain so we have nothing
7747 to do. */
7748 if (node->init < initialized)
7749 node->init = initialized;
7750 if (set_src != NULL)
7751 node->set_src = set_src;
7753 return slot;
7755 else
7757 /* We have to make a copy of a shared variable. */
7758 if (shared_var_p (var, set->vars))
7760 slot = unshare_variable (set, slot, var, initialized);
7761 var = *slot;
7765 else
7767 /* We have not found the location part, new one will be created. */
7769 /* We have to make a copy of the shared variable. */
7770 if (shared_var_p (var, set->vars))
7772 slot = unshare_variable (set, slot, var, initialized);
7773 var = *slot;
7776 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7777 thus there are at most MAX_VAR_PARTS different offsets. */
7778 gcc_assert (var->n_var_parts < MAX_VAR_PARTS
7779 && (!var->n_var_parts || !onepart));
7781 /* We have to move the elements of array starting at index
7782 inspos to the next position. */
7783 for (pos = var->n_var_parts; pos > inspos; pos--)
7784 var->var_part[pos] = var->var_part[pos - 1];
7786 var->n_var_parts++;
7787 gcc_checking_assert (!onepart);
7788 VAR_PART_OFFSET (var, pos) = offset;
7789 var->var_part[pos].loc_chain = NULL;
7790 var->var_part[pos].cur_loc = NULL;
7793 /* Delete the location from the list. */
7794 nextp = &var->var_part[pos].loc_chain;
7795 for (node = var->var_part[pos].loc_chain; node; node = next)
7797 next = node->next;
7798 if ((REG_P (node->loc) && REG_P (loc)
7799 && REGNO (node->loc) == REGNO (loc))
7800 || rtx_equal_p (node->loc, loc))
7802 /* Save these values, to assign to the new node, before
7803 deleting this one. */
7804 if (node->init > initialized)
7805 initialized = node->init;
7806 if (node->set_src != NULL && set_src == NULL)
7807 set_src = node->set_src;
7808 if (var->var_part[pos].cur_loc == node->loc)
7809 var->var_part[pos].cur_loc = NULL;
7810 delete node;
7811 *nextp = next;
7812 break;
7814 else
7815 nextp = &node->next;
7818 nextp = &var->var_part[pos].loc_chain;
7821 /* Add the location to the beginning. */
7822 node = new location_chain;
7823 node->loc = loc;
7824 node->init = initialized;
7825 node->set_src = set_src;
7826 node->next = *nextp;
7827 *nextp = node;
7829 /* If no location was emitted do so. */
7830 if (var->var_part[pos].cur_loc == NULL)
7831 variable_was_changed (var, set);
7833 return slot;
7836 /* Set the part of variable's location in the dataflow set SET. The
7837 variable part is specified by variable's declaration in DV and
7838 offset OFFSET and the part's location by LOC. IOPT should be
7839 NO_INSERT if the variable is known to be in SET already and the
7840 variable hash table must not be resized, and INSERT otherwise. */
7842 static void
7843 set_variable_part (dataflow_set *set, rtx loc,
7844 decl_or_value dv, HOST_WIDE_INT offset,
7845 enum var_init_status initialized, rtx set_src,
7846 enum insert_option iopt)
7848 variable **slot;
7850 if (iopt == NO_INSERT)
7851 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7852 else
7854 slot = shared_hash_find_slot (set->vars, dv);
7855 if (!slot)
7856 slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
7858 set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
7861 /* Remove all recorded register locations for the given variable part
7862 from dataflow set SET, except for those that are identical to loc.
7863 The variable part is specified by variable's declaration or value
7864 DV and offset OFFSET. */
7866 static variable **
7867 clobber_slot_part (dataflow_set *set, rtx loc, variable **slot,
7868 HOST_WIDE_INT offset, rtx set_src)
7870 variable *var = *slot;
7871 int pos = find_variable_location_part (var, offset, NULL);
7873 if (pos >= 0)
7875 location_chain *node, *next;
7877 /* Remove the register locations from the dataflow set. */
7878 next = var->var_part[pos].loc_chain;
7879 for (node = next; node; node = next)
7881 next = node->next;
7882 if (node->loc != loc
7883 && (!flag_var_tracking_uninit
7884 || !set_src
7885 || MEM_P (set_src)
7886 || !rtx_equal_p (set_src, node->set_src)))
7888 if (REG_P (node->loc))
7890 attrs *anode, *anext;
7891 attrs **anextp;
7893 /* Remove the variable part from the register's
7894 list, but preserve any other variable parts
7895 that might be regarded as live in that same
7896 register. */
7897 anextp = &set->regs[REGNO (node->loc)];
7898 for (anode = *anextp; anode; anode = anext)
7900 anext = anode->next;
7901 if (dv_as_opaque (anode->dv) == dv_as_opaque (var->dv)
7902 && anode->offset == offset)
7904 delete anode;
7905 *anextp = anext;
7907 else
7908 anextp = &anode->next;
7912 slot = delete_slot_part (set, node->loc, slot, offset);
7917 return slot;
7920 /* Remove all recorded register locations for the given variable part
7921 from dataflow set SET, except for those that are identical to loc.
7922 The variable part is specified by variable's declaration or value
7923 DV and offset OFFSET. */
7925 static void
7926 clobber_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
7927 HOST_WIDE_INT offset, rtx set_src)
7929 variable **slot;
7931 if (!dv_as_opaque (dv)
7932 || (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
7933 return;
7935 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7936 if (!slot)
7937 return;
7939 clobber_slot_part (set, loc, slot, offset, set_src);
7942 /* Delete the part of variable's location from dataflow set SET. The
7943 variable part is specified by its SET->vars slot SLOT and offset
7944 OFFSET and the part's location by LOC. */
7946 static variable **
7947 delete_slot_part (dataflow_set *set, rtx loc, variable **slot,
7948 HOST_WIDE_INT offset)
7950 variable *var = *slot;
7951 int pos = find_variable_location_part (var, offset, NULL);
7953 if (pos >= 0)
7955 location_chain *node, *next;
7956 location_chain **nextp;
7957 bool changed;
7958 rtx cur_loc;
7960 if (shared_var_p (var, set->vars))
7962 /* If the variable contains the location part we have to
7963 make a copy of the variable. */
7964 for (node = var->var_part[pos].loc_chain; node;
7965 node = node->next)
7967 if ((REG_P (node->loc) && REG_P (loc)
7968 && REGNO (node->loc) == REGNO (loc))
7969 || rtx_equal_p (node->loc, loc))
7971 slot = unshare_variable (set, slot, var,
7972 VAR_INIT_STATUS_UNKNOWN);
7973 var = *slot;
7974 break;
7979 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
7980 cur_loc = VAR_LOC_FROM (var);
7981 else
7982 cur_loc = var->var_part[pos].cur_loc;
7984 /* Delete the location part. */
7985 changed = false;
7986 nextp = &var->var_part[pos].loc_chain;
7987 for (node = *nextp; node; node = next)
7989 next = node->next;
7990 if ((REG_P (node->loc) && REG_P (loc)
7991 && REGNO (node->loc) == REGNO (loc))
7992 || rtx_equal_p (node->loc, loc))
7994 /* If we have deleted the location which was last emitted
7995 we have to emit new location so add the variable to set
7996 of changed variables. */
7997 if (cur_loc == node->loc)
7999 changed = true;
8000 var->var_part[pos].cur_loc = NULL;
8001 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
8002 VAR_LOC_FROM (var) = NULL;
8004 delete node;
8005 *nextp = next;
8006 break;
8008 else
8009 nextp = &node->next;
8012 if (var->var_part[pos].loc_chain == NULL)
8014 changed = true;
8015 var->n_var_parts--;
8016 while (pos < var->n_var_parts)
8018 var->var_part[pos] = var->var_part[pos + 1];
8019 pos++;
8022 if (changed)
8023 variable_was_changed (var, set);
8026 return slot;
8029 /* Delete the part of variable's location from dataflow set SET. The
8030 variable part is specified by variable's declaration or value DV
8031 and offset OFFSET and the part's location by LOC. */
8033 static void
8034 delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
8035 HOST_WIDE_INT offset)
8037 variable **slot = shared_hash_find_slot_noinsert (set->vars, dv);
8038 if (!slot)
8039 return;
8041 delete_slot_part (set, loc, slot, offset);
8045 /* Structure for passing some other parameters to function
8046 vt_expand_loc_callback. */
8047 struct expand_loc_callback_data
8049 /* The variables and values active at this point. */
8050 variable_table_type *vars;
8052 /* Stack of values and debug_exprs under expansion, and their
8053 children. */
8054 auto_vec<rtx, 4> expanding;
8056 /* Stack of values and debug_exprs whose expansion hit recursion
8057 cycles. They will have VALUE_RECURSED_INTO marked when added to
8058 this list. This flag will be cleared if any of its dependencies
8059 resolves to a valid location. So, if the flag remains set at the
8060 end of the search, we know no valid location for this one can
8061 possibly exist. */
8062 auto_vec<rtx, 4> pending;
8064 /* The maximum depth among the sub-expressions under expansion.
8065 Zero indicates no expansion so far. */
8066 expand_depth depth;
8069 /* Allocate the one-part auxiliary data structure for VAR, with enough
8070 room for COUNT dependencies. */
8072 static void
8073 loc_exp_dep_alloc (variable *var, int count)
8075 size_t allocsize;
8077 gcc_checking_assert (var->onepart);
8079 /* We can be called with COUNT == 0 to allocate the data structure
8080 without any dependencies, e.g. for the backlinks only. However,
8081 if we are specifying a COUNT, then the dependency list must have
8082 been emptied before. It would be possible to adjust pointers or
8083 force it empty here, but this is better done at an earlier point
8084 in the algorithm, so we instead leave an assertion to catch
8085 errors. */
8086 gcc_checking_assert (!count
8087 || VAR_LOC_DEP_VEC (var) == NULL
8088 || VAR_LOC_DEP_VEC (var)->is_empty ());
8090 if (VAR_LOC_1PAUX (var) && VAR_LOC_DEP_VEC (var)->space (count))
8091 return;
8093 allocsize = offsetof (struct onepart_aux, deps)
8094 + vec<loc_exp_dep, va_heap, vl_embed>::embedded_size (count);
8096 if (VAR_LOC_1PAUX (var))
8098 VAR_LOC_1PAUX (var) = XRESIZEVAR (struct onepart_aux,
8099 VAR_LOC_1PAUX (var), allocsize);
8100 /* If the reallocation moves the onepaux structure, the
8101 back-pointer to BACKLINKS in the first list member will still
8102 point to its old location. Adjust it. */
8103 if (VAR_LOC_DEP_LST (var))
8104 VAR_LOC_DEP_LST (var)->pprev = VAR_LOC_DEP_LSTP (var);
8106 else
8108 VAR_LOC_1PAUX (var) = XNEWVAR (struct onepart_aux, allocsize);
8109 *VAR_LOC_DEP_LSTP (var) = NULL;
8110 VAR_LOC_FROM (var) = NULL;
8111 VAR_LOC_DEPTH (var).complexity = 0;
8112 VAR_LOC_DEPTH (var).entryvals = 0;
8114 VAR_LOC_DEP_VEC (var)->embedded_init (count);
8117 /* Remove all entries from the vector of active dependencies of VAR,
8118 removing them from the back-links lists too. */
8120 static void
8121 loc_exp_dep_clear (variable *var)
8123 while (VAR_LOC_DEP_VEC (var) && !VAR_LOC_DEP_VEC (var)->is_empty ())
8125 loc_exp_dep *led = &VAR_LOC_DEP_VEC (var)->last ();
8126 if (led->next)
8127 led->next->pprev = led->pprev;
8128 if (led->pprev)
8129 *led->pprev = led->next;
8130 VAR_LOC_DEP_VEC (var)->pop ();
8134 /* Insert an active dependency from VAR on X to the vector of
8135 dependencies, and add the corresponding back-link to X's list of
8136 back-links in VARS. */
8138 static void
8139 loc_exp_insert_dep (variable *var, rtx x, variable_table_type *vars)
8141 decl_or_value dv;
8142 variable *xvar;
8143 loc_exp_dep *led;
8145 dv = dv_from_rtx (x);
8147 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8148 an additional look up? */
8149 xvar = vars->find_with_hash (dv, dv_htab_hash (dv));
8151 if (!xvar)
8153 xvar = variable_from_dropped (dv, NO_INSERT);
8154 gcc_checking_assert (xvar);
8157 /* No point in adding the same backlink more than once. This may
8158 arise if say the same value appears in two complex expressions in
8159 the same loc_list, or even more than once in a single
8160 expression. */
8161 if (VAR_LOC_DEP_LST (xvar) && VAR_LOC_DEP_LST (xvar)->dv == var->dv)
8162 return;
8164 if (var->onepart == NOT_ONEPART)
8165 led = new loc_exp_dep;
8166 else
8168 loc_exp_dep empty;
8169 memset (&empty, 0, sizeof (empty));
8170 VAR_LOC_DEP_VEC (var)->quick_push (empty);
8171 led = &VAR_LOC_DEP_VEC (var)->last ();
8173 led->dv = var->dv;
8174 led->value = x;
8176 loc_exp_dep_alloc (xvar, 0);
8177 led->pprev = VAR_LOC_DEP_LSTP (xvar);
8178 led->next = *led->pprev;
8179 if (led->next)
8180 led->next->pprev = &led->next;
8181 *led->pprev = led;
8184 /* Create active dependencies of VAR on COUNT values starting at
8185 VALUE, and corresponding back-links to the entries in VARS. Return
8186 true if we found any pending-recursion results. */
8188 static bool
8189 loc_exp_dep_set (variable *var, rtx result, rtx *value, int count,
8190 variable_table_type *vars)
8192 bool pending_recursion = false;
8194 gcc_checking_assert (VAR_LOC_DEP_VEC (var) == NULL
8195 || VAR_LOC_DEP_VEC (var)->is_empty ());
8197 /* Set up all dependencies from last_child (as set up at the end of
8198 the loop above) to the end. */
8199 loc_exp_dep_alloc (var, count);
8201 while (count--)
8203 rtx x = *value++;
8205 if (!pending_recursion)
8206 pending_recursion = !result && VALUE_RECURSED_INTO (x);
8208 loc_exp_insert_dep (var, x, vars);
8211 return pending_recursion;
8214 /* Notify the back-links of IVAR that are pending recursion that we
8215 have found a non-NIL value for it, so they are cleared for another
8216 attempt to compute a current location. */
8218 static void
8219 notify_dependents_of_resolved_value (variable *ivar, variable_table_type *vars)
8221 loc_exp_dep *led, *next;
8223 for (led = VAR_LOC_DEP_LST (ivar); led; led = next)
8225 decl_or_value dv = led->dv;
8226 variable *var;
8228 next = led->next;
8230 if (dv_is_value_p (dv))
8232 rtx value = dv_as_value (dv);
8234 /* If we have already resolved it, leave it alone. */
8235 if (!VALUE_RECURSED_INTO (value))
8236 continue;
8238 /* Check that VALUE_RECURSED_INTO, true from the test above,
8239 implies NO_LOC_P. */
8240 gcc_checking_assert (NO_LOC_P (value));
8242 /* We won't notify variables that are being expanded,
8243 because their dependency list is cleared before
8244 recursing. */
8245 NO_LOC_P (value) = false;
8246 VALUE_RECURSED_INTO (value) = false;
8248 gcc_checking_assert (dv_changed_p (dv));
8250 else
8252 gcc_checking_assert (dv_onepart_p (dv) != NOT_ONEPART);
8253 if (!dv_changed_p (dv))
8254 continue;
8257 var = vars->find_with_hash (dv, dv_htab_hash (dv));
8259 if (!var)
8260 var = variable_from_dropped (dv, NO_INSERT);
8262 if (var)
8263 notify_dependents_of_resolved_value (var, vars);
8265 if (next)
8266 next->pprev = led->pprev;
8267 if (led->pprev)
8268 *led->pprev = next;
8269 led->next = NULL;
8270 led->pprev = NULL;
8274 static rtx vt_expand_loc_callback (rtx x, bitmap regs,
8275 int max_depth, void *data);
8277 /* Return the combined depth, when one sub-expression evaluated to
8278 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8280 static inline expand_depth
8281 update_depth (expand_depth saved_depth, expand_depth best_depth)
8283 /* If we didn't find anything, stick with what we had. */
8284 if (!best_depth.complexity)
8285 return saved_depth;
8287 /* If we found hadn't found anything, use the depth of the current
8288 expression. Do NOT add one extra level, we want to compute the
8289 maximum depth among sub-expressions. We'll increment it later,
8290 if appropriate. */
8291 if (!saved_depth.complexity)
8292 return best_depth;
8294 /* Combine the entryval count so that regardless of which one we
8295 return, the entryval count is accurate. */
8296 best_depth.entryvals = saved_depth.entryvals
8297 = best_depth.entryvals + saved_depth.entryvals;
8299 if (saved_depth.complexity < best_depth.complexity)
8300 return best_depth;
8301 else
8302 return saved_depth;
8305 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8306 DATA for cselib expand callback. If PENDRECP is given, indicate in
8307 it whether any sub-expression couldn't be fully evaluated because
8308 it is pending recursion resolution. */
8310 static inline rtx
8311 vt_expand_var_loc_chain (variable *var, bitmap regs, void *data,
8312 bool *pendrecp)
8314 struct expand_loc_callback_data *elcd
8315 = (struct expand_loc_callback_data *) data;
8316 location_chain *loc, *next;
8317 rtx result = NULL;
8318 int first_child, result_first_child, last_child;
8319 bool pending_recursion;
8320 rtx loc_from = NULL;
8321 struct elt_loc_list *cloc = NULL;
8322 expand_depth depth = { 0, 0 }, saved_depth = elcd->depth;
8323 int wanted_entryvals, found_entryvals = 0;
8325 /* Clear all backlinks pointing at this, so that we're not notified
8326 while we're active. */
8327 loc_exp_dep_clear (var);
8329 retry:
8330 if (var->onepart == ONEPART_VALUE)
8332 cselib_val *val = CSELIB_VAL_PTR (dv_as_value (var->dv));
8334 gcc_checking_assert (cselib_preserved_value_p (val));
8336 cloc = val->locs;
8339 first_child = result_first_child = last_child
8340 = elcd->expanding.length ();
8342 wanted_entryvals = found_entryvals;
8344 /* Attempt to expand each available location in turn. */
8345 for (next = loc = var->n_var_parts ? var->var_part[0].loc_chain : NULL;
8346 loc || cloc; loc = next)
8348 result_first_child = last_child;
8350 if (!loc)
8352 loc_from = cloc->loc;
8353 next = loc;
8354 cloc = cloc->next;
8355 if (unsuitable_loc (loc_from))
8356 continue;
8358 else
8360 loc_from = loc->loc;
8361 next = loc->next;
8364 gcc_checking_assert (!unsuitable_loc (loc_from));
8366 elcd->depth.complexity = elcd->depth.entryvals = 0;
8367 result = cselib_expand_value_rtx_cb (loc_from, regs, EXPR_DEPTH,
8368 vt_expand_loc_callback, data);
8369 last_child = elcd->expanding.length ();
8371 if (result)
8373 depth = elcd->depth;
8375 gcc_checking_assert (depth.complexity
8376 || result_first_child == last_child);
8378 if (last_child - result_first_child != 1)
8380 if (!depth.complexity && GET_CODE (result) == ENTRY_VALUE)
8381 depth.entryvals++;
8382 depth.complexity++;
8385 if (depth.complexity <= EXPR_USE_DEPTH)
8387 if (depth.entryvals <= wanted_entryvals)
8388 break;
8389 else if (!found_entryvals || depth.entryvals < found_entryvals)
8390 found_entryvals = depth.entryvals;
8393 result = NULL;
8396 /* Set it up in case we leave the loop. */
8397 depth.complexity = depth.entryvals = 0;
8398 loc_from = NULL;
8399 result_first_child = first_child;
8402 if (!loc_from && wanted_entryvals < found_entryvals)
8404 /* We found entries with ENTRY_VALUEs and skipped them. Since
8405 we could not find any expansions without ENTRY_VALUEs, but we
8406 found at least one with them, go back and get an entry with
8407 the minimum number ENTRY_VALUE count that we found. We could
8408 avoid looping, but since each sub-loc is already resolved,
8409 the re-expansion should be trivial. ??? Should we record all
8410 attempted locs as dependencies, so that we retry the
8411 expansion should any of them change, in the hope it can give
8412 us a new entry without an ENTRY_VALUE? */
8413 elcd->expanding.truncate (first_child);
8414 goto retry;
8417 /* Register all encountered dependencies as active. */
8418 pending_recursion = loc_exp_dep_set
8419 (var, result, elcd->expanding.address () + result_first_child,
8420 last_child - result_first_child, elcd->vars);
8422 elcd->expanding.truncate (first_child);
8424 /* Record where the expansion came from. */
8425 gcc_checking_assert (!result || !pending_recursion);
8426 VAR_LOC_FROM (var) = loc_from;
8427 VAR_LOC_DEPTH (var) = depth;
8429 gcc_checking_assert (!depth.complexity == !result);
8431 elcd->depth = update_depth (saved_depth, depth);
8433 /* Indicate whether any of the dependencies are pending recursion
8434 resolution. */
8435 if (pendrecp)
8436 *pendrecp = pending_recursion;
8438 if (!pendrecp || !pending_recursion)
8439 var->var_part[0].cur_loc = result;
8441 return result;
8444 /* Callback for cselib_expand_value, that looks for expressions
8445 holding the value in the var-tracking hash tables. Return X for
8446 standard processing, anything else is to be used as-is. */
8448 static rtx
8449 vt_expand_loc_callback (rtx x, bitmap regs,
8450 int max_depth ATTRIBUTE_UNUSED,
8451 void *data)
8453 struct expand_loc_callback_data *elcd
8454 = (struct expand_loc_callback_data *) data;
8455 decl_or_value dv;
8456 variable *var;
8457 rtx result, subreg;
8458 bool pending_recursion = false;
8459 bool from_empty = false;
8461 switch (GET_CODE (x))
8463 case SUBREG:
8464 subreg = cselib_expand_value_rtx_cb (SUBREG_REG (x), regs,
8465 EXPR_DEPTH,
8466 vt_expand_loc_callback, data);
8468 if (!subreg)
8469 return NULL;
8471 result = simplify_gen_subreg (GET_MODE (x), subreg,
8472 GET_MODE (SUBREG_REG (x)),
8473 SUBREG_BYTE (x));
8475 /* Invalid SUBREGs are ok in debug info. ??? We could try
8476 alternate expansions for the VALUE as well. */
8477 if (!result)
8478 result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
8480 return result;
8482 case DEBUG_EXPR:
8483 case VALUE:
8484 dv = dv_from_rtx (x);
8485 break;
8487 default:
8488 return x;
8491 elcd->expanding.safe_push (x);
8493 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8494 gcc_checking_assert (!VALUE_RECURSED_INTO (x) || NO_LOC_P (x));
8496 if (NO_LOC_P (x))
8498 gcc_checking_assert (VALUE_RECURSED_INTO (x) || !dv_changed_p (dv));
8499 return NULL;
8502 var = elcd->vars->find_with_hash (dv, dv_htab_hash (dv));
8504 if (!var)
8506 from_empty = true;
8507 var = variable_from_dropped (dv, INSERT);
8510 gcc_checking_assert (var);
8512 if (!dv_changed_p (dv))
8514 gcc_checking_assert (!NO_LOC_P (x));
8515 gcc_checking_assert (var->var_part[0].cur_loc);
8516 gcc_checking_assert (VAR_LOC_1PAUX (var));
8517 gcc_checking_assert (VAR_LOC_1PAUX (var)->depth.complexity);
8519 elcd->depth = update_depth (elcd->depth, VAR_LOC_1PAUX (var)->depth);
8521 return var->var_part[0].cur_loc;
8524 VALUE_RECURSED_INTO (x) = true;
8525 /* This is tentative, but it makes some tests simpler. */
8526 NO_LOC_P (x) = true;
8528 gcc_checking_assert (var->n_var_parts == 1 || from_empty);
8530 result = vt_expand_var_loc_chain (var, regs, data, &pending_recursion);
8532 if (pending_recursion)
8534 gcc_checking_assert (!result);
8535 elcd->pending.safe_push (x);
8537 else
8539 NO_LOC_P (x) = !result;
8540 VALUE_RECURSED_INTO (x) = false;
8541 set_dv_changed (dv, false);
8543 if (result)
8544 notify_dependents_of_resolved_value (var, elcd->vars);
8547 return result;
8550 /* While expanding variables, we may encounter recursion cycles
8551 because of mutual (possibly indirect) dependencies between two
8552 particular variables (or values), say A and B. If we're trying to
8553 expand A when we get to B, which in turn attempts to expand A, if
8554 we can't find any other expansion for B, we'll add B to this
8555 pending-recursion stack, and tentatively return NULL for its
8556 location. This tentative value will be used for any other
8557 occurrences of B, unless A gets some other location, in which case
8558 it will notify B that it is worth another try at computing a
8559 location for it, and it will use the location computed for A then.
8560 At the end of the expansion, the tentative NULL locations become
8561 final for all members of PENDING that didn't get a notification.
8562 This function performs this finalization of NULL locations. */
8564 static void
8565 resolve_expansions_pending_recursion (vec<rtx, va_heap> *pending)
8567 while (!pending->is_empty ())
8569 rtx x = pending->pop ();
8570 decl_or_value dv;
8572 if (!VALUE_RECURSED_INTO (x))
8573 continue;
8575 gcc_checking_assert (NO_LOC_P (x));
8576 VALUE_RECURSED_INTO (x) = false;
8577 dv = dv_from_rtx (x);
8578 gcc_checking_assert (dv_changed_p (dv));
8579 set_dv_changed (dv, false);
8583 /* Initialize expand_loc_callback_data D with variable hash table V.
8584 It must be a macro because of alloca (vec stack). */
8585 #define INIT_ELCD(d, v) \
8586 do \
8588 (d).vars = (v); \
8589 (d).depth.complexity = (d).depth.entryvals = 0; \
8591 while (0)
8592 /* Finalize expand_loc_callback_data D, resolved to location L. */
8593 #define FINI_ELCD(d, l) \
8594 do \
8596 resolve_expansions_pending_recursion (&(d).pending); \
8597 (d).pending.release (); \
8598 (d).expanding.release (); \
8600 if ((l) && MEM_P (l)) \
8601 (l) = targetm.delegitimize_address (l); \
8603 while (0)
8605 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8606 equivalences in VARS, updating their CUR_LOCs in the process. */
8608 static rtx
8609 vt_expand_loc (rtx loc, variable_table_type *vars)
8611 struct expand_loc_callback_data data;
8612 rtx result;
8614 if (!MAY_HAVE_DEBUG_BIND_INSNS)
8615 return loc;
8617 INIT_ELCD (data, vars);
8619 result = cselib_expand_value_rtx_cb (loc, scratch_regs, EXPR_DEPTH,
8620 vt_expand_loc_callback, &data);
8622 FINI_ELCD (data, result);
8624 return result;
8627 /* Expand the one-part VARiable to a location, using the equivalences
8628 in VARS, updating their CUR_LOCs in the process. */
8630 static rtx
8631 vt_expand_1pvar (variable *var, variable_table_type *vars)
8633 struct expand_loc_callback_data data;
8634 rtx loc;
8636 gcc_checking_assert (var->onepart && var->n_var_parts == 1);
8638 if (!dv_changed_p (var->dv))
8639 return var->var_part[0].cur_loc;
8641 INIT_ELCD (data, vars);
8643 loc = vt_expand_var_loc_chain (var, scratch_regs, &data, NULL);
8645 gcc_checking_assert (data.expanding.is_empty ());
8647 FINI_ELCD (data, loc);
8649 return loc;
8652 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8653 additional parameters: WHERE specifies whether the note shall be emitted
8654 before or after instruction INSN. */
8657 emit_note_insn_var_location (variable **varp, emit_note_data *data)
8659 variable *var = *varp;
8660 rtx_insn *insn = data->insn;
8661 enum emit_note_where where = data->where;
8662 variable_table_type *vars = data->vars;
8663 rtx_note *note;
8664 rtx note_vl;
8665 int i, j, n_var_parts;
8666 bool complete;
8667 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
8668 HOST_WIDE_INT last_limit;
8669 tree type_size_unit;
8670 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
8671 rtx loc[MAX_VAR_PARTS];
8672 tree decl;
8673 location_chain *lc;
8675 gcc_checking_assert (var->onepart == NOT_ONEPART
8676 || var->onepart == ONEPART_VDECL);
8678 decl = dv_as_decl (var->dv);
8680 complete = true;
8681 last_limit = 0;
8682 n_var_parts = 0;
8683 if (!var->onepart)
8684 for (i = 0; i < var->n_var_parts; i++)
8685 if (var->var_part[i].cur_loc == NULL && var->var_part[i].loc_chain)
8686 var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
8687 for (i = 0; i < var->n_var_parts; i++)
8689 machine_mode mode, wider_mode;
8690 rtx loc2;
8691 HOST_WIDE_INT offset;
8693 if (i == 0 && var->onepart)
8695 gcc_checking_assert (var->n_var_parts == 1);
8696 offset = 0;
8697 initialized = VAR_INIT_STATUS_INITIALIZED;
8698 loc2 = vt_expand_1pvar (var, vars);
8700 else
8702 if (last_limit < VAR_PART_OFFSET (var, i))
8704 complete = false;
8705 break;
8707 else if (last_limit > VAR_PART_OFFSET (var, i))
8708 continue;
8709 offset = VAR_PART_OFFSET (var, i);
8710 loc2 = var->var_part[i].cur_loc;
8711 if (loc2 && GET_CODE (loc2) == MEM
8712 && GET_CODE (XEXP (loc2, 0)) == VALUE)
8714 rtx depval = XEXP (loc2, 0);
8716 loc2 = vt_expand_loc (loc2, vars);
8718 if (loc2)
8719 loc_exp_insert_dep (var, depval, vars);
8721 if (!loc2)
8723 complete = false;
8724 continue;
8726 gcc_checking_assert (GET_CODE (loc2) != VALUE);
8727 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
8728 if (var->var_part[i].cur_loc == lc->loc)
8730 initialized = lc->init;
8731 break;
8733 gcc_assert (lc);
8736 offsets[n_var_parts] = offset;
8737 if (!loc2)
8739 complete = false;
8740 continue;
8742 loc[n_var_parts] = loc2;
8743 mode = GET_MODE (var->var_part[i].cur_loc);
8744 if (mode == VOIDmode && var->onepart)
8745 mode = DECL_MODE (decl);
8746 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
8748 /* Attempt to merge adjacent registers or memory. */
8749 for (j = i + 1; j < var->n_var_parts; j++)
8750 if (last_limit <= VAR_PART_OFFSET (var, j))
8751 break;
8752 if (j < var->n_var_parts
8753 && GET_MODE_WIDER_MODE (mode).exists (&wider_mode)
8754 && var->var_part[j].cur_loc
8755 && mode == GET_MODE (var->var_part[j].cur_loc)
8756 && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
8757 && last_limit == (var->onepart ? 0 : VAR_PART_OFFSET (var, j))
8758 && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
8759 && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
8761 rtx new_loc = NULL;
8763 if (REG_P (loc[n_var_parts])
8764 && hard_regno_nregs (REGNO (loc[n_var_parts]), mode) * 2
8765 == hard_regno_nregs (REGNO (loc[n_var_parts]), wider_mode)
8766 && end_hard_regno (mode, REGNO (loc[n_var_parts]))
8767 == REGNO (loc2))
8769 if (! WORDS_BIG_ENDIAN && ! BYTES_BIG_ENDIAN)
8770 new_loc = simplify_subreg (wider_mode, loc[n_var_parts],
8771 mode, 0);
8772 else if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
8773 new_loc = simplify_subreg (wider_mode, loc2, mode, 0);
8774 if (new_loc)
8776 if (!REG_P (new_loc)
8777 || REGNO (new_loc) != REGNO (loc[n_var_parts]))
8778 new_loc = NULL;
8779 else
8780 REG_ATTRS (new_loc) = REG_ATTRS (loc[n_var_parts]);
8783 else if (MEM_P (loc[n_var_parts])
8784 && GET_CODE (XEXP (loc2, 0)) == PLUS
8785 && REG_P (XEXP (XEXP (loc2, 0), 0))
8786 && CONST_INT_P (XEXP (XEXP (loc2, 0), 1)))
8788 if ((REG_P (XEXP (loc[n_var_parts], 0))
8789 && rtx_equal_p (XEXP (loc[n_var_parts], 0),
8790 XEXP (XEXP (loc2, 0), 0))
8791 && INTVAL (XEXP (XEXP (loc2, 0), 1))
8792 == GET_MODE_SIZE (mode))
8793 || (GET_CODE (XEXP (loc[n_var_parts], 0)) == PLUS
8794 && CONST_INT_P (XEXP (XEXP (loc[n_var_parts], 0), 1))
8795 && rtx_equal_p (XEXP (XEXP (loc[n_var_parts], 0), 0),
8796 XEXP (XEXP (loc2, 0), 0))
8797 && INTVAL (XEXP (XEXP (loc[n_var_parts], 0), 1))
8798 + GET_MODE_SIZE (mode)
8799 == INTVAL (XEXP (XEXP (loc2, 0), 1))))
8800 new_loc = adjust_address_nv (loc[n_var_parts],
8801 wider_mode, 0);
8804 if (new_loc)
8806 loc[n_var_parts] = new_loc;
8807 mode = wider_mode;
8808 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
8809 i = j;
8812 ++n_var_parts;
8814 type_size_unit = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8815 if ((unsigned HOST_WIDE_INT) last_limit < TREE_INT_CST_LOW (type_size_unit))
8816 complete = false;
8818 if (! flag_var_tracking_uninit)
8819 initialized = VAR_INIT_STATUS_INITIALIZED;
8821 note_vl = NULL_RTX;
8822 if (!complete)
8823 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, NULL_RTX, initialized);
8824 else if (n_var_parts == 1)
8826 rtx expr_list;
8828 if (offsets[0] || GET_CODE (loc[0]) == PARALLEL)
8829 expr_list = gen_rtx_EXPR_LIST (VOIDmode, loc[0], GEN_INT (offsets[0]));
8830 else
8831 expr_list = loc[0];
8833 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, expr_list, initialized);
8835 else if (n_var_parts)
8837 rtx parallel;
8839 for (i = 0; i < n_var_parts; i++)
8840 loc[i]
8841 = gen_rtx_EXPR_LIST (VOIDmode, loc[i], GEN_INT (offsets[i]));
8843 parallel = gen_rtx_PARALLEL (VOIDmode,
8844 gen_rtvec_v (n_var_parts, loc));
8845 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl,
8846 parallel, initialized);
8849 if (where != EMIT_NOTE_BEFORE_INSN)
8851 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8852 if (where == EMIT_NOTE_AFTER_CALL_INSN)
8853 NOTE_DURING_CALL_P (note) = true;
8855 else
8857 /* Make sure that the call related notes come first. */
8858 while (NEXT_INSN (insn)
8859 && NOTE_P (insn)
8860 && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8861 && NOTE_DURING_CALL_P (insn))
8862 || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
8863 insn = NEXT_INSN (insn);
8864 if (NOTE_P (insn)
8865 && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8866 && NOTE_DURING_CALL_P (insn))
8867 || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
8868 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8869 else
8870 note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
8872 NOTE_VAR_LOCATION (note) = note_vl;
8874 set_dv_changed (var->dv, false);
8875 gcc_assert (var->in_changed_variables);
8876 var->in_changed_variables = false;
8877 changed_variables->clear_slot (varp);
8879 /* Continue traversing the hash table. */
8880 return 1;
8883 /* While traversing changed_variables, push onto DATA (a stack of RTX
8884 values) entries that aren't user variables. */
8887 var_track_values_to_stack (variable **slot,
8888 vec<rtx, va_heap> *changed_values_stack)
8890 variable *var = *slot;
8892 if (var->onepart == ONEPART_VALUE)
8893 changed_values_stack->safe_push (dv_as_value (var->dv));
8894 else if (var->onepart == ONEPART_DEXPR)
8895 changed_values_stack->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var->dv)));
8897 return 1;
8900 /* Remove from changed_variables the entry whose DV corresponds to
8901 value or debug_expr VAL. */
8902 static void
8903 remove_value_from_changed_variables (rtx val)
8905 decl_or_value dv = dv_from_rtx (val);
8906 variable **slot;
8907 variable *var;
8909 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8910 NO_INSERT);
8911 var = *slot;
8912 var->in_changed_variables = false;
8913 changed_variables->clear_slot (slot);
8916 /* If VAL (a value or debug_expr) has backlinks to variables actively
8917 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8918 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8919 have dependencies of their own to notify. */
8921 static void
8922 notify_dependents_of_changed_value (rtx val, variable_table_type *htab,
8923 vec<rtx, va_heap> *changed_values_stack)
8925 variable **slot;
8926 variable *var;
8927 loc_exp_dep *led;
8928 decl_or_value dv = dv_from_rtx (val);
8930 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8931 NO_INSERT);
8932 if (!slot)
8933 slot = htab->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT);
8934 if (!slot)
8935 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv),
8936 NO_INSERT);
8937 var = *slot;
8939 while ((led = VAR_LOC_DEP_LST (var)))
8941 decl_or_value ldv = led->dv;
8942 variable *ivar;
8944 /* Deactivate and remove the backlink, as it was “used up”. It
8945 makes no sense to attempt to notify the same entity again:
8946 either it will be recomputed and re-register an active
8947 dependency, or it will still have the changed mark. */
8948 if (led->next)
8949 led->next->pprev = led->pprev;
8950 if (led->pprev)
8951 *led->pprev = led->next;
8952 led->next = NULL;
8953 led->pprev = NULL;
8955 if (dv_changed_p (ldv))
8956 continue;
8958 switch (dv_onepart_p (ldv))
8960 case ONEPART_VALUE:
8961 case ONEPART_DEXPR:
8962 set_dv_changed (ldv, true);
8963 changed_values_stack->safe_push (dv_as_rtx (ldv));
8964 break;
8966 case ONEPART_VDECL:
8967 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8968 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar));
8969 variable_was_changed (ivar, NULL);
8970 break;
8972 case NOT_ONEPART:
8973 delete led;
8974 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8975 if (ivar)
8977 int i = ivar->n_var_parts;
8978 while (i--)
8980 rtx loc = ivar->var_part[i].cur_loc;
8982 if (loc && GET_CODE (loc) == MEM
8983 && XEXP (loc, 0) == val)
8985 variable_was_changed (ivar, NULL);
8986 break;
8990 break;
8992 default:
8993 gcc_unreachable ();
8998 /* Take out of changed_variables any entries that don't refer to use
8999 variables. Back-propagate change notifications from values and
9000 debug_exprs to their active dependencies in HTAB or in
9001 CHANGED_VARIABLES. */
9003 static void
9004 process_changed_values (variable_table_type *htab)
9006 int i, n;
9007 rtx val;
9008 auto_vec<rtx, 20> changed_values_stack;
9010 /* Move values from changed_variables to changed_values_stack. */
9011 changed_variables
9012 ->traverse <vec<rtx, va_heap>*, var_track_values_to_stack>
9013 (&changed_values_stack);
9015 /* Back-propagate change notifications in values while popping
9016 them from the stack. */
9017 for (n = i = changed_values_stack.length ();
9018 i > 0; i = changed_values_stack.length ())
9020 val = changed_values_stack.pop ();
9021 notify_dependents_of_changed_value (val, htab, &changed_values_stack);
9023 /* This condition will hold when visiting each of the entries
9024 originally in changed_variables. We can't remove them
9025 earlier because this could drop the backlinks before we got a
9026 chance to use them. */
9027 if (i == n)
9029 remove_value_from_changed_variables (val);
9030 n--;
9035 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
9036 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
9037 the notes shall be emitted before of after instruction INSN. */
9039 static void
9040 emit_notes_for_changes (rtx_insn *insn, enum emit_note_where where,
9041 shared_hash *vars)
9043 emit_note_data data;
9044 variable_table_type *htab = shared_hash_htab (vars);
9046 if (!changed_variables->elements ())
9047 return;
9049 if (MAY_HAVE_DEBUG_BIND_INSNS)
9050 process_changed_values (htab);
9052 data.insn = insn;
9053 data.where = where;
9054 data.vars = htab;
9056 changed_variables
9057 ->traverse <emit_note_data*, emit_note_insn_var_location> (&data);
9060 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9061 same variable in hash table DATA or is not there at all. */
9064 emit_notes_for_differences_1 (variable **slot, variable_table_type *new_vars)
9066 variable *old_var, *new_var;
9068 old_var = *slot;
9069 new_var = new_vars->find_with_hash (old_var->dv, dv_htab_hash (old_var->dv));
9071 if (!new_var)
9073 /* Variable has disappeared. */
9074 variable *empty_var = NULL;
9076 if (old_var->onepart == ONEPART_VALUE
9077 || old_var->onepart == ONEPART_DEXPR)
9079 empty_var = variable_from_dropped (old_var->dv, NO_INSERT);
9080 if (empty_var)
9082 gcc_checking_assert (!empty_var->in_changed_variables);
9083 if (!VAR_LOC_1PAUX (old_var))
9085 VAR_LOC_1PAUX (old_var) = VAR_LOC_1PAUX (empty_var);
9086 VAR_LOC_1PAUX (empty_var) = NULL;
9088 else
9089 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
9093 if (!empty_var)
9095 empty_var = onepart_pool_allocate (old_var->onepart);
9096 empty_var->dv = old_var->dv;
9097 empty_var->refcount = 0;
9098 empty_var->n_var_parts = 0;
9099 empty_var->onepart = old_var->onepart;
9100 empty_var->in_changed_variables = false;
9103 if (empty_var->onepart)
9105 /* Propagate the auxiliary data to (ultimately)
9106 changed_variables. */
9107 empty_var->var_part[0].loc_chain = NULL;
9108 empty_var->var_part[0].cur_loc = NULL;
9109 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (old_var);
9110 VAR_LOC_1PAUX (old_var) = NULL;
9112 variable_was_changed (empty_var, NULL);
9113 /* Continue traversing the hash table. */
9114 return 1;
9116 /* Update cur_loc and one-part auxiliary data, before new_var goes
9117 through variable_was_changed. */
9118 if (old_var != new_var && new_var->onepart)
9120 gcc_checking_assert (VAR_LOC_1PAUX (new_var) == NULL);
9121 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (old_var);
9122 VAR_LOC_1PAUX (old_var) = NULL;
9123 new_var->var_part[0].cur_loc = old_var->var_part[0].cur_loc;
9125 if (variable_different_p (old_var, new_var))
9126 variable_was_changed (new_var, NULL);
9128 /* Continue traversing the hash table. */
9129 return 1;
9132 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9133 table DATA. */
9136 emit_notes_for_differences_2 (variable **slot, variable_table_type *old_vars)
9138 variable *old_var, *new_var;
9140 new_var = *slot;
9141 old_var = old_vars->find_with_hash (new_var->dv, dv_htab_hash (new_var->dv));
9142 if (!old_var)
9144 int i;
9145 for (i = 0; i < new_var->n_var_parts; i++)
9146 new_var->var_part[i].cur_loc = NULL;
9147 variable_was_changed (new_var, NULL);
9150 /* Continue traversing the hash table. */
9151 return 1;
9154 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9155 NEW_SET. */
9157 static void
9158 emit_notes_for_differences (rtx_insn *insn, dataflow_set *old_set,
9159 dataflow_set *new_set)
9161 shared_hash_htab (old_set->vars)
9162 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9163 (shared_hash_htab (new_set->vars));
9164 shared_hash_htab (new_set->vars)
9165 ->traverse <variable_table_type *, emit_notes_for_differences_2>
9166 (shared_hash_htab (old_set->vars));
9167 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
9170 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9172 static rtx_insn *
9173 next_non_note_insn_var_location (rtx_insn *insn)
9175 while (insn)
9177 insn = NEXT_INSN (insn);
9178 if (insn == 0
9179 || !NOTE_P (insn)
9180 || NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION)
9181 break;
9184 return insn;
9187 /* Emit the notes for changes of location parts in the basic block BB. */
9189 static void
9190 emit_notes_in_bb (basic_block bb, dataflow_set *set)
9192 unsigned int i;
9193 micro_operation *mo;
9195 dataflow_set_clear (set);
9196 dataflow_set_copy (set, &VTI (bb)->in);
9198 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
9200 rtx_insn *insn = mo->insn;
9201 rtx_insn *next_insn = next_non_note_insn_var_location (insn);
9203 switch (mo->type)
9205 case MO_CALL:
9206 dataflow_set_clear_at_call (set, insn);
9207 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
9209 rtx arguments = mo->u.loc, *p = &arguments;
9210 rtx_note *note;
9211 while (*p)
9213 XEXP (XEXP (*p, 0), 1)
9214 = vt_expand_loc (XEXP (XEXP (*p, 0), 1),
9215 shared_hash_htab (set->vars));
9216 /* If expansion is successful, keep it in the list. */
9217 if (XEXP (XEXP (*p, 0), 1))
9218 p = &XEXP (*p, 1);
9219 /* Otherwise, if the following item is data_value for it,
9220 drop it too too. */
9221 else if (XEXP (*p, 1)
9222 && REG_P (XEXP (XEXP (*p, 0), 0))
9223 && MEM_P (XEXP (XEXP (XEXP (*p, 1), 0), 0))
9224 && REG_P (XEXP (XEXP (XEXP (XEXP (*p, 1), 0), 0),
9226 && REGNO (XEXP (XEXP (*p, 0), 0))
9227 == REGNO (XEXP (XEXP (XEXP (XEXP (*p, 1), 0),
9228 0), 0)))
9229 *p = XEXP (XEXP (*p, 1), 1);
9230 /* Just drop this item. */
9231 else
9232 *p = XEXP (*p, 1);
9234 note = emit_note_after (NOTE_INSN_CALL_ARG_LOCATION, insn);
9235 NOTE_VAR_LOCATION (note) = arguments;
9237 break;
9239 case MO_USE:
9241 rtx loc = mo->u.loc;
9243 if (REG_P (loc))
9244 var_reg_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9245 else
9246 var_mem_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9248 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9250 break;
9252 case MO_VAL_LOC:
9254 rtx loc = mo->u.loc;
9255 rtx val, vloc;
9256 tree var;
9258 if (GET_CODE (loc) == CONCAT)
9260 val = XEXP (loc, 0);
9261 vloc = XEXP (loc, 1);
9263 else
9265 val = NULL_RTX;
9266 vloc = loc;
9269 var = PAT_VAR_LOCATION_DECL (vloc);
9271 clobber_variable_part (set, NULL_RTX,
9272 dv_from_decl (var), 0, NULL_RTX);
9273 if (val)
9275 if (VAL_NEEDS_RESOLUTION (loc))
9276 val_resolve (set, val, PAT_VAR_LOCATION_LOC (vloc), insn);
9277 set_variable_part (set, val, dv_from_decl (var), 0,
9278 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9279 INSERT);
9281 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
9282 set_variable_part (set, PAT_VAR_LOCATION_LOC (vloc),
9283 dv_from_decl (var), 0,
9284 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9285 INSERT);
9287 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9289 break;
9291 case MO_VAL_USE:
9293 rtx loc = mo->u.loc;
9294 rtx val, vloc, uloc;
9296 vloc = uloc = XEXP (loc, 1);
9297 val = XEXP (loc, 0);
9299 if (GET_CODE (val) == CONCAT)
9301 uloc = XEXP (val, 1);
9302 val = XEXP (val, 0);
9305 if (VAL_NEEDS_RESOLUTION (loc))
9306 val_resolve (set, val, vloc, insn);
9307 else
9308 val_store (set, val, uloc, insn, false);
9310 if (VAL_HOLDS_TRACK_EXPR (loc))
9312 if (GET_CODE (uloc) == REG)
9313 var_reg_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9314 NULL);
9315 else if (GET_CODE (uloc) == MEM)
9316 var_mem_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9317 NULL);
9320 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9322 break;
9324 case MO_VAL_SET:
9326 rtx loc = mo->u.loc;
9327 rtx val, vloc, uloc;
9328 rtx dstv, srcv;
9330 vloc = loc;
9331 uloc = XEXP (vloc, 1);
9332 val = XEXP (vloc, 0);
9333 vloc = uloc;
9335 if (GET_CODE (uloc) == SET)
9337 dstv = SET_DEST (uloc);
9338 srcv = SET_SRC (uloc);
9340 else
9342 dstv = uloc;
9343 srcv = NULL;
9346 if (GET_CODE (val) == CONCAT)
9348 dstv = vloc = XEXP (val, 1);
9349 val = XEXP (val, 0);
9352 if (GET_CODE (vloc) == SET)
9354 srcv = SET_SRC (vloc);
9356 gcc_assert (val != srcv);
9357 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
9359 dstv = vloc = SET_DEST (vloc);
9361 if (VAL_NEEDS_RESOLUTION (loc))
9362 val_resolve (set, val, srcv, insn);
9364 else if (VAL_NEEDS_RESOLUTION (loc))
9366 gcc_assert (GET_CODE (uloc) == SET
9367 && GET_CODE (SET_SRC (uloc)) == REG);
9368 val_resolve (set, val, SET_SRC (uloc), insn);
9371 if (VAL_HOLDS_TRACK_EXPR (loc))
9373 if (VAL_EXPR_IS_CLOBBERED (loc))
9375 if (REG_P (uloc))
9376 var_reg_delete (set, uloc, true);
9377 else if (MEM_P (uloc))
9379 gcc_assert (MEM_P (dstv));
9380 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
9381 var_mem_delete (set, dstv, true);
9384 else
9386 bool copied_p = VAL_EXPR_IS_COPIED (loc);
9387 rtx src = NULL, dst = uloc;
9388 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
9390 if (GET_CODE (uloc) == SET)
9392 src = SET_SRC (uloc);
9393 dst = SET_DEST (uloc);
9396 if (copied_p)
9398 status = find_src_status (set, src);
9400 src = find_src_set_src (set, src);
9403 if (REG_P (dst))
9404 var_reg_delete_and_set (set, dst, !copied_p,
9405 status, srcv);
9406 else if (MEM_P (dst))
9408 gcc_assert (MEM_P (dstv));
9409 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
9410 var_mem_delete_and_set (set, dstv, !copied_p,
9411 status, srcv);
9415 else if (REG_P (uloc))
9416 var_regno_delete (set, REGNO (uloc));
9417 else if (MEM_P (uloc))
9419 gcc_checking_assert (GET_CODE (vloc) == MEM);
9420 gcc_checking_assert (vloc == dstv);
9421 if (vloc != dstv)
9422 clobber_overlapping_mems (set, vloc);
9425 val_store (set, val, dstv, insn, true);
9427 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9428 set->vars);
9430 break;
9432 case MO_SET:
9434 rtx loc = mo->u.loc;
9435 rtx set_src = NULL;
9437 if (GET_CODE (loc) == SET)
9439 set_src = SET_SRC (loc);
9440 loc = SET_DEST (loc);
9443 if (REG_P (loc))
9444 var_reg_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9445 set_src);
9446 else
9447 var_mem_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9448 set_src);
9450 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9451 set->vars);
9453 break;
9455 case MO_COPY:
9457 rtx loc = mo->u.loc;
9458 enum var_init_status src_status;
9459 rtx set_src = NULL;
9461 if (GET_CODE (loc) == SET)
9463 set_src = SET_SRC (loc);
9464 loc = SET_DEST (loc);
9467 src_status = find_src_status (set, set_src);
9468 set_src = find_src_set_src (set, set_src);
9470 if (REG_P (loc))
9471 var_reg_delete_and_set (set, loc, false, src_status, set_src);
9472 else
9473 var_mem_delete_and_set (set, loc, false, src_status, set_src);
9475 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9476 set->vars);
9478 break;
9480 case MO_USE_NO_VAR:
9482 rtx loc = mo->u.loc;
9484 if (REG_P (loc))
9485 var_reg_delete (set, loc, false);
9486 else
9487 var_mem_delete (set, loc, false);
9489 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9491 break;
9493 case MO_CLOBBER:
9495 rtx loc = mo->u.loc;
9497 if (REG_P (loc))
9498 var_reg_delete (set, loc, true);
9499 else
9500 var_mem_delete (set, loc, true);
9502 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9503 set->vars);
9505 break;
9507 case MO_ADJUST:
9508 set->stack_adjust += mo->u.adjust;
9509 break;
9514 /* Emit notes for the whole function. */
9516 static void
9517 vt_emit_notes (void)
9519 basic_block bb;
9520 dataflow_set cur;
9522 gcc_assert (!changed_variables->elements ());
9524 /* Free memory occupied by the out hash tables, as they aren't used
9525 anymore. */
9526 FOR_EACH_BB_FN (bb, cfun)
9527 dataflow_set_clear (&VTI (bb)->out);
9529 /* Enable emitting notes by functions (mainly by set_variable_part and
9530 delete_variable_part). */
9531 emit_notes = true;
9533 if (MAY_HAVE_DEBUG_BIND_INSNS)
9534 dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
9536 dataflow_set_init (&cur);
9538 FOR_EACH_BB_FN (bb, cfun)
9540 /* Emit the notes for changes of variable locations between two
9541 subsequent basic blocks. */
9542 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
9544 if (MAY_HAVE_DEBUG_BIND_INSNS)
9545 local_get_addr_cache = new hash_map<rtx, rtx>;
9547 /* Emit the notes for the changes in the basic block itself. */
9548 emit_notes_in_bb (bb, &cur);
9550 if (MAY_HAVE_DEBUG_BIND_INSNS)
9551 delete local_get_addr_cache;
9552 local_get_addr_cache = NULL;
9554 /* Free memory occupied by the in hash table, we won't need it
9555 again. */
9556 dataflow_set_clear (&VTI (bb)->in);
9559 if (flag_checking)
9560 shared_hash_htab (cur.vars)
9561 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9562 (shared_hash_htab (empty_shared_hash));
9564 dataflow_set_destroy (&cur);
9566 if (MAY_HAVE_DEBUG_BIND_INSNS)
9567 delete dropped_values;
9568 dropped_values = NULL;
9570 emit_notes = false;
9573 /* If there is a declaration and offset associated with register/memory RTL
9574 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9576 static bool
9577 vt_get_decl_and_offset (rtx rtl, tree *declp, poly_int64 *offsetp)
9579 if (REG_P (rtl))
9581 if (REG_ATTRS (rtl))
9583 *declp = REG_EXPR (rtl);
9584 *offsetp = REG_OFFSET (rtl);
9585 return true;
9588 else if (GET_CODE (rtl) == PARALLEL)
9590 tree decl = NULL_TREE;
9591 HOST_WIDE_INT offset = MAX_VAR_PARTS;
9592 int len = XVECLEN (rtl, 0), i;
9594 for (i = 0; i < len; i++)
9596 rtx reg = XEXP (XVECEXP (rtl, 0, i), 0);
9597 if (!REG_P (reg) || !REG_ATTRS (reg))
9598 break;
9599 if (!decl)
9600 decl = REG_EXPR (reg);
9601 if (REG_EXPR (reg) != decl)
9602 break;
9603 HOST_WIDE_INT this_offset;
9604 if (!track_offset_p (REG_OFFSET (reg), &this_offset))
9605 break;
9606 offset = MIN (offset, this_offset);
9609 if (i == len)
9611 *declp = decl;
9612 *offsetp = offset;
9613 return true;
9616 else if (MEM_P (rtl))
9618 if (MEM_ATTRS (rtl))
9620 *declp = MEM_EXPR (rtl);
9621 *offsetp = int_mem_offset (rtl);
9622 return true;
9625 return false;
9628 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9629 of VAL. */
9631 static void
9632 record_entry_value (cselib_val *val, rtx rtl)
9634 rtx ev = gen_rtx_ENTRY_VALUE (GET_MODE (rtl));
9636 ENTRY_VALUE_EXP (ev) = rtl;
9638 cselib_add_permanent_equiv (val, ev, get_insns ());
9641 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9643 static void
9644 vt_add_function_parameter (tree parm)
9646 rtx decl_rtl = DECL_RTL_IF_SET (parm);
9647 rtx incoming = DECL_INCOMING_RTL (parm);
9648 tree decl;
9649 machine_mode mode;
9650 poly_int64 offset;
9651 dataflow_set *out;
9652 decl_or_value dv;
9654 if (TREE_CODE (parm) != PARM_DECL)
9655 return;
9657 if (!decl_rtl || !incoming)
9658 return;
9660 if (GET_MODE (decl_rtl) == BLKmode || GET_MODE (incoming) == BLKmode)
9661 return;
9663 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9664 rewrite the incoming location of parameters passed on the stack
9665 into MEMs based on the argument pointer, so that incoming doesn't
9666 depend on a pseudo. */
9667 if (MEM_P (incoming)
9668 && (XEXP (incoming, 0) == crtl->args.internal_arg_pointer
9669 || (GET_CODE (XEXP (incoming, 0)) == PLUS
9670 && XEXP (XEXP (incoming, 0), 0)
9671 == crtl->args.internal_arg_pointer
9672 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
9674 HOST_WIDE_INT off = -FIRST_PARM_OFFSET (current_function_decl);
9675 if (GET_CODE (XEXP (incoming, 0)) == PLUS)
9676 off += INTVAL (XEXP (XEXP (incoming, 0), 1));
9677 incoming
9678 = replace_equiv_address_nv (incoming,
9679 plus_constant (Pmode,
9680 arg_pointer_rtx, off));
9683 #ifdef HAVE_window_save
9684 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9685 If the target machine has an explicit window save instruction, the
9686 actual entry value is the corresponding OUTGOING_REGNO instead. */
9687 if (HAVE_window_save && !crtl->uses_only_leaf_regs)
9689 if (REG_P (incoming)
9690 && HARD_REGISTER_P (incoming)
9691 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
9693 parm_reg p;
9694 p.incoming = incoming;
9695 incoming
9696 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
9697 OUTGOING_REGNO (REGNO (incoming)), 0);
9698 p.outgoing = incoming;
9699 vec_safe_push (windowed_parm_regs, p);
9701 else if (GET_CODE (incoming) == PARALLEL)
9703 rtx outgoing
9704 = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (XVECLEN (incoming, 0)));
9705 int i;
9707 for (i = 0; i < XVECLEN (incoming, 0); i++)
9709 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9710 parm_reg p;
9711 p.incoming = reg;
9712 reg = gen_rtx_REG_offset (reg, GET_MODE (reg),
9713 OUTGOING_REGNO (REGNO (reg)), 0);
9714 p.outgoing = reg;
9715 XVECEXP (outgoing, 0, i)
9716 = gen_rtx_EXPR_LIST (VOIDmode, reg,
9717 XEXP (XVECEXP (incoming, 0, i), 1));
9718 vec_safe_push (windowed_parm_regs, p);
9721 incoming = outgoing;
9723 else if (MEM_P (incoming)
9724 && REG_P (XEXP (incoming, 0))
9725 && HARD_REGISTER_P (XEXP (incoming, 0)))
9727 rtx reg = XEXP (incoming, 0);
9728 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
9730 parm_reg p;
9731 p.incoming = reg;
9732 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
9733 p.outgoing = reg;
9734 vec_safe_push (windowed_parm_regs, p);
9735 incoming = replace_equiv_address_nv (incoming, reg);
9739 #endif
9741 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
9743 if (MEM_P (incoming))
9745 /* This means argument is passed by invisible reference. */
9746 offset = 0;
9747 decl = parm;
9749 else
9751 if (!vt_get_decl_and_offset (decl_rtl, &decl, &offset))
9752 return;
9753 offset += byte_lowpart_offset (GET_MODE (incoming),
9754 GET_MODE (decl_rtl));
9758 if (!decl)
9759 return;
9761 if (parm != decl)
9763 /* If that DECL_RTL wasn't a pseudo that got spilled to
9764 memory, bail out. Otherwise, the spill slot sharing code
9765 will force the memory to reference spill_slot_decl (%sfp),
9766 so we don't match above. That's ok, the pseudo must have
9767 referenced the entire parameter, so just reset OFFSET. */
9768 if (decl != get_spill_slot_decl (false))
9769 return;
9770 offset = 0;
9773 HOST_WIDE_INT const_offset;
9774 if (!track_loc_p (incoming, parm, offset, false, &mode, &const_offset))
9775 return;
9777 out = &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out;
9779 dv = dv_from_decl (parm);
9781 if (target_for_debug_bind (parm)
9782 /* We can't deal with these right now, because this kind of
9783 variable is single-part. ??? We could handle parallels
9784 that describe multiple locations for the same single
9785 value, but ATM we don't. */
9786 && GET_CODE (incoming) != PARALLEL)
9788 cselib_val *val;
9789 rtx lowpart;
9791 /* ??? We shouldn't ever hit this, but it may happen because
9792 arguments passed by invisible reference aren't dealt with
9793 above: incoming-rtl will have Pmode rather than the
9794 expected mode for the type. */
9795 if (const_offset)
9796 return;
9798 lowpart = var_lowpart (mode, incoming);
9799 if (!lowpart)
9800 return;
9802 val = cselib_lookup_from_insn (lowpart, mode, true,
9803 VOIDmode, get_insns ());
9805 /* ??? Float-typed values in memory are not handled by
9806 cselib. */
9807 if (val)
9809 preserve_value (val);
9810 set_variable_part (out, val->val_rtx, dv, const_offset,
9811 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9812 dv = dv_from_value (val->val_rtx);
9815 if (MEM_P (incoming))
9817 val = cselib_lookup_from_insn (XEXP (incoming, 0), mode, true,
9818 VOIDmode, get_insns ());
9819 if (val)
9821 preserve_value (val);
9822 incoming = replace_equiv_address_nv (incoming, val->val_rtx);
9827 if (REG_P (incoming))
9829 incoming = var_lowpart (mode, incoming);
9830 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
9831 attrs_list_insert (&out->regs[REGNO (incoming)], dv, const_offset,
9832 incoming);
9833 set_variable_part (out, incoming, dv, const_offset,
9834 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9835 if (dv_is_value_p (dv))
9837 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv)), incoming);
9838 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
9839 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm))))
9841 machine_mode indmode
9842 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm)));
9843 rtx mem = gen_rtx_MEM (indmode, incoming);
9844 cselib_val *val = cselib_lookup_from_insn (mem, indmode, true,
9845 VOIDmode,
9846 get_insns ());
9847 if (val)
9849 preserve_value (val);
9850 record_entry_value (val, mem);
9851 set_variable_part (out, mem, dv_from_value (val->val_rtx), 0,
9852 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9857 else if (GET_CODE (incoming) == PARALLEL && !dv_onepart_p (dv))
9859 int i;
9861 for (i = 0; i < XVECLEN (incoming, 0); i++)
9863 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9864 /* vt_get_decl_and_offset has already checked that the offset
9865 is a valid variable part. */
9866 const_offset = get_tracked_reg_offset (reg);
9867 gcc_assert (REGNO (reg) < FIRST_PSEUDO_REGISTER);
9868 attrs_list_insert (&out->regs[REGNO (reg)], dv, const_offset, reg);
9869 set_variable_part (out, reg, dv, const_offset,
9870 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9873 else if (MEM_P (incoming))
9875 incoming = var_lowpart (mode, incoming);
9876 set_variable_part (out, incoming, dv, const_offset,
9877 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9881 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9883 static void
9884 vt_add_function_parameters (void)
9886 tree parm;
9888 for (parm = DECL_ARGUMENTS (current_function_decl);
9889 parm; parm = DECL_CHAIN (parm))
9890 if (!POINTER_BOUNDS_P (parm))
9891 vt_add_function_parameter (parm);
9893 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl)))
9895 tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
9897 if (TREE_CODE (vexpr) == INDIRECT_REF)
9898 vexpr = TREE_OPERAND (vexpr, 0);
9900 if (TREE_CODE (vexpr) == PARM_DECL
9901 && DECL_ARTIFICIAL (vexpr)
9902 && !DECL_IGNORED_P (vexpr)
9903 && DECL_NAMELESS (vexpr))
9904 vt_add_function_parameter (vexpr);
9908 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9909 ensure it isn't flushed during cselib_reset_table.
9910 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9911 has been eliminated. */
9913 static void
9914 vt_init_cfa_base (void)
9916 cselib_val *val;
9918 #ifdef FRAME_POINTER_CFA_OFFSET
9919 cfa_base_rtx = frame_pointer_rtx;
9920 cfa_base_offset = -FRAME_POINTER_CFA_OFFSET (current_function_decl);
9921 #else
9922 cfa_base_rtx = arg_pointer_rtx;
9923 cfa_base_offset = -ARG_POINTER_CFA_OFFSET (current_function_decl);
9924 #endif
9925 if (cfa_base_rtx == hard_frame_pointer_rtx
9926 || !fixed_regs[REGNO (cfa_base_rtx)])
9928 cfa_base_rtx = NULL_RTX;
9929 return;
9931 if (!MAY_HAVE_DEBUG_BIND_INSNS)
9932 return;
9934 /* Tell alias analysis that cfa_base_rtx should share
9935 find_base_term value with stack pointer or hard frame pointer. */
9936 if (!frame_pointer_needed)
9937 vt_equate_reg_base_value (cfa_base_rtx, stack_pointer_rtx);
9938 else if (!crtl->stack_realign_tried)
9939 vt_equate_reg_base_value (cfa_base_rtx, hard_frame_pointer_rtx);
9941 val = cselib_lookup_from_insn (cfa_base_rtx, GET_MODE (cfa_base_rtx), 1,
9942 VOIDmode, get_insns ());
9943 preserve_value (val);
9944 cselib_preserve_cfa_base_value (val, REGNO (cfa_base_rtx));
9947 /* Reemit INSN, a MARKER_DEBUG_INSN, as a note. */
9949 static rtx_insn *
9950 reemit_marker_as_note (rtx_insn *insn)
9952 gcc_checking_assert (DEBUG_MARKER_INSN_P (insn));
9954 enum insn_note kind = INSN_DEBUG_MARKER_KIND (insn);
9956 switch (kind)
9958 case NOTE_INSN_BEGIN_STMT:
9960 rtx_insn *note = NULL;
9961 if (cfun->debug_nonbind_markers)
9963 note = emit_note_before (kind, insn);
9964 NOTE_MARKER_LOCATION (note) = INSN_LOCATION (insn);
9966 delete_insn (insn);
9967 return note;
9970 default:
9971 gcc_unreachable ();
9975 /* Allocate and initialize the data structures for variable tracking
9976 and parse the RTL to get the micro operations. */
9978 static bool
9979 vt_initialize (void)
9981 basic_block bb;
9982 HOST_WIDE_INT fp_cfa_offset = -1;
9984 alloc_aux_for_blocks (sizeof (variable_tracking_info));
9986 empty_shared_hash = shared_hash_pool.allocate ();
9987 empty_shared_hash->refcount = 1;
9988 empty_shared_hash->htab = new variable_table_type (1);
9989 changed_variables = new variable_table_type (10);
9991 /* Init the IN and OUT sets. */
9992 FOR_ALL_BB_FN (bb, cfun)
9994 VTI (bb)->visited = false;
9995 VTI (bb)->flooded = false;
9996 dataflow_set_init (&VTI (bb)->in);
9997 dataflow_set_init (&VTI (bb)->out);
9998 VTI (bb)->permp = NULL;
10001 if (MAY_HAVE_DEBUG_BIND_INSNS)
10003 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
10004 scratch_regs = BITMAP_ALLOC (NULL);
10005 preserved_values.create (256);
10006 global_get_addr_cache = new hash_map<rtx, rtx>;
10008 else
10010 scratch_regs = NULL;
10011 global_get_addr_cache = NULL;
10014 if (MAY_HAVE_DEBUG_BIND_INSNS)
10016 rtx reg, expr;
10017 int ofst;
10018 cselib_val *val;
10020 #ifdef FRAME_POINTER_CFA_OFFSET
10021 reg = frame_pointer_rtx;
10022 ofst = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10023 #else
10024 reg = arg_pointer_rtx;
10025 ofst = ARG_POINTER_CFA_OFFSET (current_function_decl);
10026 #endif
10028 ofst -= INCOMING_FRAME_SP_OFFSET;
10030 val = cselib_lookup_from_insn (reg, GET_MODE (reg), 1,
10031 VOIDmode, get_insns ());
10032 preserve_value (val);
10033 if (reg != hard_frame_pointer_rtx && fixed_regs[REGNO (reg)])
10034 cselib_preserve_cfa_base_value (val, REGNO (reg));
10035 expr = plus_constant (GET_MODE (stack_pointer_rtx),
10036 stack_pointer_rtx, -ofst);
10037 cselib_add_permanent_equiv (val, expr, get_insns ());
10039 if (ofst)
10041 val = cselib_lookup_from_insn (stack_pointer_rtx,
10042 GET_MODE (stack_pointer_rtx), 1,
10043 VOIDmode, get_insns ());
10044 preserve_value (val);
10045 expr = plus_constant (GET_MODE (reg), reg, ofst);
10046 cselib_add_permanent_equiv (val, expr, get_insns ());
10050 /* In order to factor out the adjustments made to the stack pointer or to
10051 the hard frame pointer and thus be able to use DW_OP_fbreg operations
10052 instead of individual location lists, we're going to rewrite MEMs based
10053 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
10054 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
10055 resp. arg_pointer_rtx. We can do this either when there is no frame
10056 pointer in the function and stack adjustments are consistent for all
10057 basic blocks or when there is a frame pointer and no stack realignment.
10058 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
10059 has been eliminated. */
10060 if (!frame_pointer_needed)
10062 rtx reg, elim;
10064 if (!vt_stack_adjustments ())
10065 return false;
10067 #ifdef FRAME_POINTER_CFA_OFFSET
10068 reg = frame_pointer_rtx;
10069 #else
10070 reg = arg_pointer_rtx;
10071 #endif
10072 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10073 if (elim != reg)
10075 if (GET_CODE (elim) == PLUS)
10076 elim = XEXP (elim, 0);
10077 if (elim == stack_pointer_rtx)
10078 vt_init_cfa_base ();
10081 else if (!crtl->stack_realign_tried)
10083 rtx reg, elim;
10085 #ifdef FRAME_POINTER_CFA_OFFSET
10086 reg = frame_pointer_rtx;
10087 fp_cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10088 #else
10089 reg = arg_pointer_rtx;
10090 fp_cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10091 #endif
10092 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10093 if (elim != reg)
10095 if (GET_CODE (elim) == PLUS)
10097 fp_cfa_offset -= INTVAL (XEXP (elim, 1));
10098 elim = XEXP (elim, 0);
10100 if (elim != hard_frame_pointer_rtx)
10101 fp_cfa_offset = -1;
10103 else
10104 fp_cfa_offset = -1;
10107 /* If the stack is realigned and a DRAP register is used, we're going to
10108 rewrite MEMs based on it representing incoming locations of parameters
10109 passed on the stack into MEMs based on the argument pointer. Although
10110 we aren't going to rewrite other MEMs, we still need to initialize the
10111 virtual CFA pointer in order to ensure that the argument pointer will
10112 be seen as a constant throughout the function.
10114 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10115 else if (stack_realign_drap)
10117 rtx reg, elim;
10119 #ifdef FRAME_POINTER_CFA_OFFSET
10120 reg = frame_pointer_rtx;
10121 #else
10122 reg = arg_pointer_rtx;
10123 #endif
10124 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10125 if (elim != reg)
10127 if (GET_CODE (elim) == PLUS)
10128 elim = XEXP (elim, 0);
10129 if (elim == hard_frame_pointer_rtx)
10130 vt_init_cfa_base ();
10134 hard_frame_pointer_adjustment = -1;
10136 vt_add_function_parameters ();
10138 FOR_EACH_BB_FN (bb, cfun)
10140 rtx_insn *insn;
10141 HOST_WIDE_INT pre, post = 0;
10142 basic_block first_bb, last_bb;
10144 if (MAY_HAVE_DEBUG_BIND_INSNS)
10146 cselib_record_sets_hook = add_with_sets;
10147 if (dump_file && (dump_flags & TDF_DETAILS))
10148 fprintf (dump_file, "first value: %i\n",
10149 cselib_get_next_uid ());
10152 first_bb = bb;
10153 for (;;)
10155 edge e;
10156 if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
10157 || ! single_pred_p (bb->next_bb))
10158 break;
10159 e = find_edge (bb, bb->next_bb);
10160 if (! e || (e->flags & EDGE_FALLTHRU) == 0)
10161 break;
10162 bb = bb->next_bb;
10164 last_bb = bb;
10166 /* Add the micro-operations to the vector. */
10167 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
10169 HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
10170 VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
10172 rtx_insn *next;
10173 FOR_BB_INSNS_SAFE (bb, insn, next)
10175 if (INSN_P (insn))
10177 if (!frame_pointer_needed)
10179 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
10180 if (pre)
10182 micro_operation mo;
10183 mo.type = MO_ADJUST;
10184 mo.u.adjust = pre;
10185 mo.insn = insn;
10186 if (dump_file && (dump_flags & TDF_DETAILS))
10187 log_op_type (PATTERN (insn), bb, insn,
10188 MO_ADJUST, dump_file);
10189 VTI (bb)->mos.safe_push (mo);
10190 VTI (bb)->out.stack_adjust += pre;
10194 cselib_hook_called = false;
10195 adjust_insn (bb, insn);
10196 if (DEBUG_MARKER_INSN_P (insn))
10198 reemit_marker_as_note (insn);
10199 continue;
10202 if (MAY_HAVE_DEBUG_BIND_INSNS)
10204 if (CALL_P (insn))
10205 prepare_call_arguments (bb, insn);
10206 cselib_process_insn (insn);
10207 if (dump_file && (dump_flags & TDF_DETAILS))
10209 print_rtl_single (dump_file, insn);
10210 dump_cselib_table (dump_file);
10213 if (!cselib_hook_called)
10214 add_with_sets (insn, 0, 0);
10215 cancel_changes (0);
10217 if (!frame_pointer_needed && post)
10219 micro_operation mo;
10220 mo.type = MO_ADJUST;
10221 mo.u.adjust = post;
10222 mo.insn = insn;
10223 if (dump_file && (dump_flags & TDF_DETAILS))
10224 log_op_type (PATTERN (insn), bb, insn,
10225 MO_ADJUST, dump_file);
10226 VTI (bb)->mos.safe_push (mo);
10227 VTI (bb)->out.stack_adjust += post;
10230 if (fp_cfa_offset != -1
10231 && hard_frame_pointer_adjustment == -1
10232 && fp_setter_insn (insn))
10234 vt_init_cfa_base ();
10235 hard_frame_pointer_adjustment = fp_cfa_offset;
10236 /* Disassociate sp from fp now. */
10237 if (MAY_HAVE_DEBUG_BIND_INSNS)
10239 cselib_val *v;
10240 cselib_invalidate_rtx (stack_pointer_rtx);
10241 v = cselib_lookup (stack_pointer_rtx, Pmode, 1,
10242 VOIDmode);
10243 if (v && !cselib_preserved_value_p (v))
10245 cselib_set_value_sp_based (v);
10246 preserve_value (v);
10252 gcc_assert (offset == VTI (bb)->out.stack_adjust);
10255 bb = last_bb;
10257 if (MAY_HAVE_DEBUG_BIND_INSNS)
10259 cselib_preserve_only_values ();
10260 cselib_reset_table (cselib_get_next_uid ());
10261 cselib_record_sets_hook = NULL;
10265 hard_frame_pointer_adjustment = -1;
10266 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flooded = true;
10267 cfa_base_rtx = NULL_RTX;
10268 return true;
10271 /* This is *not* reset after each function. It gives each
10272 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10273 a unique label number. */
10275 static int debug_label_num = 1;
10277 /* Remove from the insn stream all debug insns used for variable
10278 tracking at assignments. */
10280 static void
10281 delete_vta_debug_insns (void)
10283 basic_block bb;
10284 rtx_insn *insn, *next;
10286 if (!MAY_HAVE_DEBUG_INSNS)
10287 return;
10289 FOR_EACH_BB_FN (bb, cfun)
10291 FOR_BB_INSNS_SAFE (bb, insn, next)
10292 if (DEBUG_INSN_P (insn))
10294 if (DEBUG_MARKER_INSN_P (insn))
10296 reemit_marker_as_note (insn);
10297 continue;
10300 tree decl = INSN_VAR_LOCATION_DECL (insn);
10301 if (TREE_CODE (decl) == LABEL_DECL
10302 && DECL_NAME (decl)
10303 && !DECL_RTL_SET_P (decl))
10305 PUT_CODE (insn, NOTE);
10306 NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
10307 NOTE_DELETED_LABEL_NAME (insn)
10308 = IDENTIFIER_POINTER (DECL_NAME (decl));
10309 SET_DECL_RTL (decl, insn);
10310 CODE_LABEL_NUMBER (insn) = debug_label_num++;
10312 else
10313 delete_insn (insn);
10318 /* Run a fast, BB-local only version of var tracking, to take care of
10319 information that we don't do global analysis on, such that not all
10320 information is lost. If SKIPPED holds, we're skipping the global
10321 pass entirely, so we should try to use information it would have
10322 handled as well.. */
10324 static void
10325 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
10327 /* ??? Just skip it all for now. */
10328 delete_vta_debug_insns ();
10331 /* Free the data structures needed for variable tracking. */
10333 static void
10334 vt_finalize (void)
10336 basic_block bb;
10338 FOR_EACH_BB_FN (bb, cfun)
10340 VTI (bb)->mos.release ();
10343 FOR_ALL_BB_FN (bb, cfun)
10345 dataflow_set_destroy (&VTI (bb)->in);
10346 dataflow_set_destroy (&VTI (bb)->out);
10347 if (VTI (bb)->permp)
10349 dataflow_set_destroy (VTI (bb)->permp);
10350 XDELETE (VTI (bb)->permp);
10353 free_aux_for_blocks ();
10354 delete empty_shared_hash->htab;
10355 empty_shared_hash->htab = NULL;
10356 delete changed_variables;
10357 changed_variables = NULL;
10358 attrs_pool.release ();
10359 var_pool.release ();
10360 location_chain_pool.release ();
10361 shared_hash_pool.release ();
10363 if (MAY_HAVE_DEBUG_BIND_INSNS)
10365 if (global_get_addr_cache)
10366 delete global_get_addr_cache;
10367 global_get_addr_cache = NULL;
10368 loc_exp_dep_pool.release ();
10369 valvar_pool.release ();
10370 preserved_values.release ();
10371 cselib_finish ();
10372 BITMAP_FREE (scratch_regs);
10373 scratch_regs = NULL;
10376 #ifdef HAVE_window_save
10377 vec_free (windowed_parm_regs);
10378 #endif
10380 if (vui_vec)
10381 XDELETEVEC (vui_vec);
10382 vui_vec = NULL;
10383 vui_allocated = 0;
10386 /* The entry point to variable tracking pass. */
10388 static inline unsigned int
10389 variable_tracking_main_1 (void)
10391 bool success;
10393 /* We won't be called as a separate pass if flag_var_tracking is not
10394 set, but final may call us to turn debug markers into notes. */
10395 if ((!flag_var_tracking && MAY_HAVE_DEBUG_INSNS)
10396 || flag_var_tracking_assignments < 0
10397 /* Var-tracking right now assumes the IR doesn't contain
10398 any pseudos at this point. */
10399 || targetm.no_register_allocation)
10401 delete_vta_debug_insns ();
10402 return 0;
10405 if (!flag_var_tracking)
10406 return 0;
10408 if (n_basic_blocks_for_fn (cfun) > 500
10409 && n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
10411 vt_debug_insns_local (true);
10412 return 0;
10415 mark_dfs_back_edges ();
10416 if (!vt_initialize ())
10418 vt_finalize ();
10419 vt_debug_insns_local (true);
10420 return 0;
10423 success = vt_find_locations ();
10425 if (!success && flag_var_tracking_assignments > 0)
10427 vt_finalize ();
10429 delete_vta_debug_insns ();
10431 /* This is later restored by our caller. */
10432 flag_var_tracking_assignments = 0;
10434 success = vt_initialize ();
10435 gcc_assert (success);
10437 success = vt_find_locations ();
10440 if (!success)
10442 vt_finalize ();
10443 vt_debug_insns_local (false);
10444 return 0;
10447 if (dump_file && (dump_flags & TDF_DETAILS))
10449 dump_dataflow_sets ();
10450 dump_reg_info (dump_file);
10451 dump_flow_info (dump_file, dump_flags);
10454 timevar_push (TV_VAR_TRACKING_EMIT);
10455 vt_emit_notes ();
10456 timevar_pop (TV_VAR_TRACKING_EMIT);
10458 vt_finalize ();
10459 vt_debug_insns_local (false);
10460 return 0;
10463 unsigned int
10464 variable_tracking_main (void)
10466 unsigned int ret;
10467 int save = flag_var_tracking_assignments;
10469 ret = variable_tracking_main_1 ();
10471 flag_var_tracking_assignments = save;
10473 return ret;
10476 namespace {
10478 const pass_data pass_data_variable_tracking =
10480 RTL_PASS, /* type */
10481 "vartrack", /* name */
10482 OPTGROUP_NONE, /* optinfo_flags */
10483 TV_VAR_TRACKING, /* tv_id */
10484 0, /* properties_required */
10485 0, /* properties_provided */
10486 0, /* properties_destroyed */
10487 0, /* todo_flags_start */
10488 0, /* todo_flags_finish */
10491 class pass_variable_tracking : public rtl_opt_pass
10493 public:
10494 pass_variable_tracking (gcc::context *ctxt)
10495 : rtl_opt_pass (pass_data_variable_tracking, ctxt)
10498 /* opt_pass methods: */
10499 virtual bool gate (function *)
10501 return (flag_var_tracking && !targetm.delay_vartrack);
10504 virtual unsigned int execute (function *)
10506 return variable_tracking_main ();
10509 }; // class pass_variable_tracking
10511 } // anon namespace
10513 rtl_opt_pass *
10514 make_pass_variable_tracking (gcc::context *ctxt)
10516 return new pass_variable_tracking (ctxt);