Daily bump.
[official-gcc.git] / gcc / var-tracking.c
blob56a701c283e87d3636e2130447fd6320a3ffd0e5
1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2018 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 poly_int64 size;
1020 switch (GET_CODE (loc))
1022 case REG:
1023 /* Don't do any sp or fp replacements outside of MEM addresses
1024 on the LHS. */
1025 if (amd->mem_mode == VOIDmode && amd->store)
1026 return loc;
1027 if (loc == stack_pointer_rtx
1028 && !frame_pointer_needed
1029 && cfa_base_rtx)
1030 return compute_cfa_pointer (amd->stack_adjust);
1031 else if (loc == hard_frame_pointer_rtx
1032 && frame_pointer_needed
1033 && hard_frame_pointer_adjustment != -1
1034 && cfa_base_rtx)
1035 return compute_cfa_pointer (hard_frame_pointer_adjustment);
1036 gcc_checking_assert (loc != virtual_incoming_args_rtx);
1037 return loc;
1038 case MEM:
1039 mem = loc;
1040 if (!amd->store)
1042 mem = targetm.delegitimize_address (mem);
1043 if (mem != loc && !MEM_P (mem))
1044 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
1047 addr = XEXP (mem, 0);
1048 mem_mode_save = amd->mem_mode;
1049 amd->mem_mode = GET_MODE (mem);
1050 store_save = amd->store;
1051 amd->store = false;
1052 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1053 amd->store = store_save;
1054 amd->mem_mode = mem_mode_save;
1055 if (mem == loc)
1056 addr = targetm.delegitimize_address (addr);
1057 if (addr != XEXP (mem, 0))
1058 mem = replace_equiv_address_nv (mem, addr);
1059 if (!amd->store)
1060 mem = avoid_constant_pool_reference (mem);
1061 return mem;
1062 case PRE_INC:
1063 case PRE_DEC:
1064 size = GET_MODE_SIZE (amd->mem_mode);
1065 addr = plus_constant (GET_MODE (loc), XEXP (loc, 0),
1066 GET_CODE (loc) == PRE_INC ? size : -size);
1067 /* FALLTHRU */
1068 case POST_INC:
1069 case POST_DEC:
1070 if (addr == loc)
1071 addr = XEXP (loc, 0);
1072 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
1073 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1074 size = GET_MODE_SIZE (amd->mem_mode);
1075 tem = plus_constant (GET_MODE (loc), XEXP (loc, 0),
1076 (GET_CODE (loc) == PRE_INC
1077 || GET_CODE (loc) == POST_INC) ? size : -size);
1078 store_save = amd->store;
1079 amd->store = false;
1080 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
1081 amd->store = store_save;
1082 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1083 return addr;
1084 case PRE_MODIFY:
1085 addr = XEXP (loc, 1);
1086 /* FALLTHRU */
1087 case POST_MODIFY:
1088 if (addr == loc)
1089 addr = XEXP (loc, 0);
1090 gcc_assert (amd->mem_mode != VOIDmode);
1091 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1092 store_save = amd->store;
1093 amd->store = false;
1094 tem = simplify_replace_fn_rtx (XEXP (loc, 1), old_rtx,
1095 adjust_mems, data);
1096 amd->store = store_save;
1097 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem));
1098 return addr;
1099 case SUBREG:
1100 /* First try without delegitimization of whole MEMs and
1101 avoid_constant_pool_reference, which is more likely to succeed. */
1102 store_save = amd->store;
1103 amd->store = true;
1104 addr = simplify_replace_fn_rtx (SUBREG_REG (loc), old_rtx, adjust_mems,
1105 data);
1106 amd->store = store_save;
1107 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1108 if (mem == SUBREG_REG (loc))
1110 tem = loc;
1111 goto finish_subreg;
1113 tem = simplify_gen_subreg (GET_MODE (loc), mem,
1114 GET_MODE (SUBREG_REG (loc)),
1115 SUBREG_BYTE (loc));
1116 if (tem)
1117 goto finish_subreg;
1118 tem = simplify_gen_subreg (GET_MODE (loc), addr,
1119 GET_MODE (SUBREG_REG (loc)),
1120 SUBREG_BYTE (loc));
1121 if (tem == NULL_RTX)
1122 tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
1123 finish_subreg:
1124 if (MAY_HAVE_DEBUG_BIND_INSNS
1125 && GET_CODE (tem) == SUBREG
1126 && (GET_CODE (SUBREG_REG (tem)) == PLUS
1127 || GET_CODE (SUBREG_REG (tem)) == MINUS
1128 || GET_CODE (SUBREG_REG (tem)) == MULT
1129 || GET_CODE (SUBREG_REG (tem)) == ASHIFT)
1130 && is_a <scalar_int_mode> (GET_MODE (tem), &tem_mode)
1131 && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (tem)),
1132 &tem_subreg_mode)
1133 && (GET_MODE_PRECISION (tem_mode)
1134 < GET_MODE_PRECISION (tem_subreg_mode))
1135 && subreg_lowpart_p (tem)
1136 && use_narrower_mode_test (SUBREG_REG (tem), tem))
1137 return use_narrower_mode (SUBREG_REG (tem), tem_mode, tem_subreg_mode);
1138 return tem;
1139 case ASM_OPERANDS:
1140 /* Don't do any replacements in second and following
1141 ASM_OPERANDS of inline-asm with multiple sets.
1142 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1143 and ASM_OPERANDS_LABEL_VEC need to be equal between
1144 all the ASM_OPERANDs in the insn and adjust_insn will
1145 fix this up. */
1146 if (ASM_OPERANDS_OUTPUT_IDX (loc) != 0)
1147 return loc;
1148 break;
1149 default:
1150 break;
1152 return NULL_RTX;
1155 /* Helper function for replacement of uses. */
1157 static void
1158 adjust_mem_uses (rtx *x, void *data)
1160 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX, adjust_mems, data);
1161 if (new_x != *x)
1162 validate_change (NULL_RTX, x, new_x, true);
1165 /* Helper function for replacement of stores. */
1167 static void
1168 adjust_mem_stores (rtx loc, const_rtx expr, void *data)
1170 if (MEM_P (loc))
1172 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr), NULL_RTX,
1173 adjust_mems, data);
1174 if (new_dest != SET_DEST (expr))
1176 rtx xexpr = CONST_CAST_RTX (expr);
1177 validate_change (NULL_RTX, &SET_DEST (xexpr), new_dest, true);
1182 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1183 replace them with their value in the insn and add the side-effects
1184 as other sets to the insn. */
1186 static void
1187 adjust_insn (basic_block bb, rtx_insn *insn)
1189 rtx set;
1191 #ifdef HAVE_window_save
1192 /* If the target machine has an explicit window save instruction, the
1193 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1194 if (RTX_FRAME_RELATED_P (insn)
1195 && find_reg_note (insn, REG_CFA_WINDOW_SAVE, NULL_RTX))
1197 unsigned int i, nregs = vec_safe_length (windowed_parm_regs);
1198 rtx rtl = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs * 2));
1199 parm_reg *p;
1201 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)
1203 XVECEXP (rtl, 0, i * 2)
1204 = gen_rtx_SET (p->incoming, p->outgoing);
1205 /* Do not clobber the attached DECL, but only the REG. */
1206 XVECEXP (rtl, 0, i * 2 + 1)
1207 = gen_rtx_CLOBBER (GET_MODE (p->outgoing),
1208 gen_raw_REG (GET_MODE (p->outgoing),
1209 REGNO (p->outgoing)));
1212 validate_change (NULL_RTX, &PATTERN (insn), rtl, true);
1213 return;
1215 #endif
1217 adjust_mem_data amd;
1218 amd.mem_mode = VOIDmode;
1219 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
1221 amd.store = true;
1222 note_stores (PATTERN (insn), adjust_mem_stores, &amd);
1224 amd.store = false;
1225 if (GET_CODE (PATTERN (insn)) == PARALLEL
1226 && asm_noperands (PATTERN (insn)) > 0
1227 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1229 rtx body, set0;
1230 int i;
1232 /* inline-asm with multiple sets is tiny bit more complicated,
1233 because the 3 vectors in ASM_OPERANDS need to be shared between
1234 all ASM_OPERANDS in the instruction. adjust_mems will
1235 not touch ASM_OPERANDS other than the first one, asm_noperands
1236 test above needs to be called before that (otherwise it would fail)
1237 and afterwards this code fixes it up. */
1238 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1239 body = PATTERN (insn);
1240 set0 = XVECEXP (body, 0, 0);
1241 gcc_checking_assert (GET_CODE (set0) == SET
1242 && GET_CODE (SET_SRC (set0)) == ASM_OPERANDS
1243 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0)) == 0);
1244 for (i = 1; i < XVECLEN (body, 0); i++)
1245 if (GET_CODE (XVECEXP (body, 0, i)) != SET)
1246 break;
1247 else
1249 set = XVECEXP (body, 0, i);
1250 gcc_checking_assert (GET_CODE (SET_SRC (set)) == ASM_OPERANDS
1251 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set))
1252 == i);
1253 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set))
1254 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))
1255 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set))
1256 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))
1257 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set))
1258 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0)))
1260 rtx newsrc = shallow_copy_rtx (SET_SRC (set));
1261 ASM_OPERANDS_INPUT_VEC (newsrc)
1262 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0));
1263 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc)
1264 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0));
1265 ASM_OPERANDS_LABEL_VEC (newsrc)
1266 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0));
1267 validate_change (NULL_RTX, &SET_SRC (set), newsrc, true);
1271 else
1272 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1274 /* For read-only MEMs containing some constant, prefer those
1275 constants. */
1276 set = single_set (insn);
1277 if (set && MEM_P (SET_SRC (set)) && MEM_READONLY_P (SET_SRC (set)))
1279 rtx note = find_reg_equal_equiv_note (insn);
1281 if (note && CONSTANT_P (XEXP (note, 0)))
1282 validate_change (NULL_RTX, &SET_SRC (set), XEXP (note, 0), true);
1285 if (!amd.side_effects.is_empty ())
1287 rtx *pat, new_pat;
1288 int i, oldn;
1290 pat = &PATTERN (insn);
1291 if (GET_CODE (*pat) == COND_EXEC)
1292 pat = &COND_EXEC_CODE (*pat);
1293 if (GET_CODE (*pat) == PARALLEL)
1294 oldn = XVECLEN (*pat, 0);
1295 else
1296 oldn = 1;
1297 unsigned int newn = amd.side_effects.length ();
1298 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn));
1299 if (GET_CODE (*pat) == PARALLEL)
1300 for (i = 0; i < oldn; i++)
1301 XVECEXP (new_pat, 0, i) = XVECEXP (*pat, 0, i);
1302 else
1303 XVECEXP (new_pat, 0, 0) = *pat;
1305 rtx effect;
1306 unsigned int j;
1307 FOR_EACH_VEC_ELT_REVERSE (amd.side_effects, j, effect)
1308 XVECEXP (new_pat, 0, j + oldn) = effect;
1309 validate_change (NULL_RTX, pat, new_pat, true);
1313 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1314 static inline rtx
1315 dv_as_rtx (decl_or_value dv)
1317 tree decl;
1319 if (dv_is_value_p (dv))
1320 return dv_as_value (dv);
1322 decl = dv_as_decl (dv);
1324 gcc_checking_assert (TREE_CODE (decl) == DEBUG_EXPR_DECL);
1325 return DECL_RTL_KNOWN_SET (decl);
1328 /* Return nonzero if a decl_or_value must not have more than one
1329 variable part. The returned value discriminates among various
1330 kinds of one-part DVs ccording to enum onepart_enum. */
1331 static inline onepart_enum
1332 dv_onepart_p (decl_or_value dv)
1334 tree decl;
1336 if (!MAY_HAVE_DEBUG_BIND_INSNS)
1337 return NOT_ONEPART;
1339 if (dv_is_value_p (dv))
1340 return ONEPART_VALUE;
1342 decl = dv_as_decl (dv);
1344 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
1345 return ONEPART_DEXPR;
1347 if (target_for_debug_bind (decl) != NULL_TREE)
1348 return ONEPART_VDECL;
1350 return NOT_ONEPART;
1353 /* Return the variable pool to be used for a dv of type ONEPART. */
1354 static inline pool_allocator &
1355 onepart_pool (onepart_enum onepart)
1357 return onepart ? valvar_pool : var_pool;
1360 /* Allocate a variable_def from the corresponding variable pool. */
1361 static inline variable *
1362 onepart_pool_allocate (onepart_enum onepart)
1364 return (variable*) onepart_pool (onepart).allocate ();
1367 /* Build a decl_or_value out of a decl. */
1368 static inline decl_or_value
1369 dv_from_decl (tree decl)
1371 decl_or_value dv;
1372 dv = decl;
1373 gcc_checking_assert (dv_is_decl_p (dv));
1374 return dv;
1377 /* Build a decl_or_value out of a value. */
1378 static inline decl_or_value
1379 dv_from_value (rtx value)
1381 decl_or_value dv;
1382 dv = value;
1383 gcc_checking_assert (dv_is_value_p (dv));
1384 return dv;
1387 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1388 static inline decl_or_value
1389 dv_from_rtx (rtx x)
1391 decl_or_value dv;
1393 switch (GET_CODE (x))
1395 case DEBUG_EXPR:
1396 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x));
1397 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x)) == x);
1398 break;
1400 case VALUE:
1401 dv = dv_from_value (x);
1402 break;
1404 default:
1405 gcc_unreachable ();
1408 return dv;
1411 extern void debug_dv (decl_or_value dv);
1413 DEBUG_FUNCTION void
1414 debug_dv (decl_or_value dv)
1416 if (dv_is_value_p (dv))
1417 debug_rtx (dv_as_value (dv));
1418 else
1419 debug_generic_stmt (dv_as_decl (dv));
1422 static void loc_exp_dep_clear (variable *var);
1424 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1426 static void
1427 variable_htab_free (void *elem)
1429 int i;
1430 variable *var = (variable *) elem;
1431 location_chain *node, *next;
1433 gcc_checking_assert (var->refcount > 0);
1435 var->refcount--;
1436 if (var->refcount > 0)
1437 return;
1439 for (i = 0; i < var->n_var_parts; i++)
1441 for (node = var->var_part[i].loc_chain; node; node = next)
1443 next = node->next;
1444 delete node;
1446 var->var_part[i].loc_chain = NULL;
1448 if (var->onepart && VAR_LOC_1PAUX (var))
1450 loc_exp_dep_clear (var);
1451 if (VAR_LOC_DEP_LST (var))
1452 VAR_LOC_DEP_LST (var)->pprev = NULL;
1453 XDELETE (VAR_LOC_1PAUX (var));
1454 /* These may be reused across functions, so reset
1455 e.g. NO_LOC_P. */
1456 if (var->onepart == ONEPART_DEXPR)
1457 set_dv_changed (var->dv, true);
1459 onepart_pool (var->onepart).remove (var);
1462 /* Initialize the set (array) SET of attrs to empty lists. */
1464 static void
1465 init_attrs_list_set (attrs **set)
1467 int i;
1469 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1470 set[i] = NULL;
1473 /* Make the list *LISTP empty. */
1475 static void
1476 attrs_list_clear (attrs **listp)
1478 attrs *list, *next;
1480 for (list = *listp; list; list = next)
1482 next = list->next;
1483 delete list;
1485 *listp = NULL;
1488 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1490 static attrs *
1491 attrs_list_member (attrs *list, decl_or_value dv, HOST_WIDE_INT offset)
1493 for (; list; list = list->next)
1494 if (dv_as_opaque (list->dv) == dv_as_opaque (dv) && list->offset == offset)
1495 return list;
1496 return NULL;
1499 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1501 static void
1502 attrs_list_insert (attrs **listp, decl_or_value dv,
1503 HOST_WIDE_INT offset, rtx loc)
1505 attrs *list = new attrs;
1506 list->loc = loc;
1507 list->dv = dv;
1508 list->offset = offset;
1509 list->next = *listp;
1510 *listp = list;
1513 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1515 static void
1516 attrs_list_copy (attrs **dstp, attrs *src)
1518 attrs_list_clear (dstp);
1519 for (; src; src = src->next)
1521 attrs *n = new attrs;
1522 n->loc = src->loc;
1523 n->dv = src->dv;
1524 n->offset = src->offset;
1525 n->next = *dstp;
1526 *dstp = n;
1530 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1532 static void
1533 attrs_list_union (attrs **dstp, attrs *src)
1535 for (; src; src = src->next)
1537 if (!attrs_list_member (*dstp, src->dv, src->offset))
1538 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1542 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1543 *DSTP. */
1545 static void
1546 attrs_list_mpdv_union (attrs **dstp, attrs *src, attrs *src2)
1548 gcc_assert (!*dstp);
1549 for (; src; src = src->next)
1551 if (!dv_onepart_p (src->dv))
1552 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1554 for (src = src2; src; src = src->next)
1556 if (!dv_onepart_p (src->dv)
1557 && !attrs_list_member (*dstp, src->dv, src->offset))
1558 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1562 /* Shared hashtable support. */
1564 /* Return true if VARS is shared. */
1566 static inline bool
1567 shared_hash_shared (shared_hash *vars)
1569 return vars->refcount > 1;
1572 /* Return the hash table for VARS. */
1574 static inline variable_table_type *
1575 shared_hash_htab (shared_hash *vars)
1577 return vars->htab;
1580 /* Return true if VAR is shared, or maybe because VARS is shared. */
1582 static inline bool
1583 shared_var_p (variable *var, shared_hash *vars)
1585 /* Don't count an entry in the changed_variables table as a duplicate. */
1586 return ((var->refcount > 1 + (int) var->in_changed_variables)
1587 || shared_hash_shared (vars));
1590 /* Copy variables into a new hash table. */
1592 static shared_hash *
1593 shared_hash_unshare (shared_hash *vars)
1595 shared_hash *new_vars = new shared_hash;
1596 gcc_assert (vars->refcount > 1);
1597 new_vars->refcount = 1;
1598 new_vars->htab = new variable_table_type (vars->htab->elements () + 3);
1599 vars_copy (new_vars->htab, vars->htab);
1600 vars->refcount--;
1601 return new_vars;
1604 /* Increment reference counter on VARS and return it. */
1606 static inline shared_hash *
1607 shared_hash_copy (shared_hash *vars)
1609 vars->refcount++;
1610 return vars;
1613 /* Decrement reference counter and destroy hash table if not shared
1614 anymore. */
1616 static void
1617 shared_hash_destroy (shared_hash *vars)
1619 gcc_checking_assert (vars->refcount > 0);
1620 if (--vars->refcount == 0)
1622 delete vars->htab;
1623 delete vars;
1627 /* Unshare *PVARS if shared and return slot for DV. If INS is
1628 INSERT, insert it if not already present. */
1630 static inline variable **
1631 shared_hash_find_slot_unshare_1 (shared_hash **pvars, decl_or_value dv,
1632 hashval_t dvhash, enum insert_option ins)
1634 if (shared_hash_shared (*pvars))
1635 *pvars = shared_hash_unshare (*pvars);
1636 return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins);
1639 static inline variable **
1640 shared_hash_find_slot_unshare (shared_hash **pvars, decl_or_value dv,
1641 enum insert_option ins)
1643 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1646 /* Return slot for DV, if it is already present in the hash table.
1647 If it is not present, insert it only VARS is not shared, otherwise
1648 return NULL. */
1650 static inline variable **
1651 shared_hash_find_slot_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1653 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash,
1654 shared_hash_shared (vars)
1655 ? NO_INSERT : INSERT);
1658 static inline variable **
1659 shared_hash_find_slot (shared_hash *vars, decl_or_value dv)
1661 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1664 /* Return slot for DV only if it is already present in the hash table. */
1666 static inline variable **
1667 shared_hash_find_slot_noinsert_1 (shared_hash *vars, decl_or_value dv,
1668 hashval_t dvhash)
1670 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT);
1673 static inline variable **
1674 shared_hash_find_slot_noinsert (shared_hash *vars, decl_or_value dv)
1676 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1679 /* Return variable for DV or NULL if not already present in the hash
1680 table. */
1682 static inline variable *
1683 shared_hash_find_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1685 return shared_hash_htab (vars)->find_with_hash (dv, dvhash);
1688 static inline variable *
1689 shared_hash_find (shared_hash *vars, decl_or_value dv)
1691 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1694 /* Return true if TVAL is better than CVAL as a canonival value. We
1695 choose lowest-numbered VALUEs, using the RTX address as a
1696 tie-breaker. The idea is to arrange them into a star topology,
1697 such that all of them are at most one step away from the canonical
1698 value, and the canonical value has backlinks to all of them, in
1699 addition to all the actual locations. We don't enforce this
1700 topology throughout the entire dataflow analysis, though.
1703 static inline bool
1704 canon_value_cmp (rtx tval, rtx cval)
1706 return !cval
1707 || CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
1710 static bool dst_can_be_shared;
1712 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1714 static variable **
1715 unshare_variable (dataflow_set *set, variable **slot, variable *var,
1716 enum var_init_status initialized)
1718 variable *new_var;
1719 int i;
1721 new_var = onepart_pool_allocate (var->onepart);
1722 new_var->dv = var->dv;
1723 new_var->refcount = 1;
1724 var->refcount--;
1725 new_var->n_var_parts = var->n_var_parts;
1726 new_var->onepart = var->onepart;
1727 new_var->in_changed_variables = false;
1729 if (! flag_var_tracking_uninit)
1730 initialized = VAR_INIT_STATUS_INITIALIZED;
1732 for (i = 0; i < var->n_var_parts; i++)
1734 location_chain *node;
1735 location_chain **nextp;
1737 if (i == 0 && var->onepart)
1739 /* One-part auxiliary data is only used while emitting
1740 notes, so propagate it to the new variable in the active
1741 dataflow set. If we're not emitting notes, this will be
1742 a no-op. */
1743 gcc_checking_assert (!VAR_LOC_1PAUX (var) || emit_notes);
1744 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (var);
1745 VAR_LOC_1PAUX (var) = NULL;
1747 else
1748 VAR_PART_OFFSET (new_var, i) = VAR_PART_OFFSET (var, i);
1749 nextp = &new_var->var_part[i].loc_chain;
1750 for (node = var->var_part[i].loc_chain; node; node = node->next)
1752 location_chain *new_lc;
1754 new_lc = new location_chain;
1755 new_lc->next = NULL;
1756 if (node->init > initialized)
1757 new_lc->init = node->init;
1758 else
1759 new_lc->init = initialized;
1760 if (node->set_src && !(MEM_P (node->set_src)))
1761 new_lc->set_src = node->set_src;
1762 else
1763 new_lc->set_src = NULL;
1764 new_lc->loc = node->loc;
1766 *nextp = new_lc;
1767 nextp = &new_lc->next;
1770 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1773 dst_can_be_shared = false;
1774 if (shared_hash_shared (set->vars))
1775 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1776 else if (set->traversed_vars && set->vars != set->traversed_vars)
1777 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1778 *slot = new_var;
1779 if (var->in_changed_variables)
1781 variable **cslot
1782 = changed_variables->find_slot_with_hash (var->dv,
1783 dv_htab_hash (var->dv),
1784 NO_INSERT);
1785 gcc_assert (*cslot == (void *) var);
1786 var->in_changed_variables = false;
1787 variable_htab_free (var);
1788 *cslot = new_var;
1789 new_var->in_changed_variables = true;
1791 return slot;
1794 /* Copy all variables from hash table SRC to hash table DST. */
1796 static void
1797 vars_copy (variable_table_type *dst, variable_table_type *src)
1799 variable_iterator_type hi;
1800 variable *var;
1802 FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi)
1804 variable **dstp;
1805 var->refcount++;
1806 dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv),
1807 INSERT);
1808 *dstp = var;
1812 /* Map a decl to its main debug decl. */
1814 static inline tree
1815 var_debug_decl (tree decl)
1817 if (decl && VAR_P (decl) && DECL_HAS_DEBUG_EXPR_P (decl))
1819 tree debugdecl = DECL_DEBUG_EXPR (decl);
1820 if (DECL_P (debugdecl))
1821 decl = debugdecl;
1824 return decl;
1827 /* Set the register LOC to contain DV, OFFSET. */
1829 static void
1830 var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1831 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1832 enum insert_option iopt)
1834 attrs *node;
1835 bool decl_p = dv_is_decl_p (dv);
1837 if (decl_p)
1838 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1840 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1841 if (dv_as_opaque (node->dv) == dv_as_opaque (dv)
1842 && node->offset == offset)
1843 break;
1844 if (!node)
1845 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
1846 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1849 /* Return true if we should track a location that is OFFSET bytes from
1850 a variable. Store the constant offset in *OFFSET_OUT if so. */
1852 static bool
1853 track_offset_p (poly_int64 offset, HOST_WIDE_INT *offset_out)
1855 HOST_WIDE_INT const_offset;
1856 if (!offset.is_constant (&const_offset)
1857 || !IN_RANGE (const_offset, 0, MAX_VAR_PARTS - 1))
1858 return false;
1859 *offset_out = const_offset;
1860 return true;
1863 /* Return the offset of a register that track_offset_p says we
1864 should track. */
1866 static HOST_WIDE_INT
1867 get_tracked_reg_offset (rtx loc)
1869 HOST_WIDE_INT offset;
1870 if (!track_offset_p (REG_OFFSET (loc), &offset))
1871 gcc_unreachable ();
1872 return offset;
1875 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1877 static void
1878 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1879 rtx set_src)
1881 tree decl = REG_EXPR (loc);
1882 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1884 var_reg_decl_set (set, loc, initialized,
1885 dv_from_decl (decl), offset, set_src, INSERT);
1888 static enum var_init_status
1889 get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1891 variable *var;
1892 int i;
1893 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1895 if (! flag_var_tracking_uninit)
1896 return VAR_INIT_STATUS_INITIALIZED;
1898 var = shared_hash_find (set->vars, dv);
1899 if (var)
1901 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1903 location_chain *nextp;
1904 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1905 if (rtx_equal_p (nextp->loc, loc))
1907 ret_val = nextp->init;
1908 break;
1913 return ret_val;
1916 /* Delete current content of register LOC in dataflow set SET and set
1917 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1918 MODIFY is true, any other live copies of the same variable part are
1919 also deleted from the dataflow set, otherwise the variable part is
1920 assumed to be copied from another location holding the same
1921 part. */
1923 static void
1924 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1925 enum var_init_status initialized, rtx set_src)
1927 tree decl = REG_EXPR (loc);
1928 HOST_WIDE_INT offset = get_tracked_reg_offset (loc);
1929 attrs *node, *next;
1930 attrs **nextp;
1932 decl = var_debug_decl (decl);
1934 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1935 initialized = get_init_value (set, loc, dv_from_decl (decl));
1937 nextp = &set->regs[REGNO (loc)];
1938 for (node = *nextp; node; node = next)
1940 next = node->next;
1941 if (dv_as_opaque (node->dv) != decl || node->offset != offset)
1943 delete_variable_part (set, node->loc, node->dv, node->offset);
1944 delete node;
1945 *nextp = next;
1947 else
1949 node->loc = loc;
1950 nextp = &node->next;
1953 if (modify)
1954 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1955 var_reg_set (set, loc, initialized, set_src);
1958 /* Delete the association of register LOC in dataflow set SET with any
1959 variables that aren't onepart. If CLOBBER is true, also delete any
1960 other live copies of the same variable part, and delete the
1961 association with onepart dvs too. */
1963 static void
1964 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1966 attrs **nextp = &set->regs[REGNO (loc)];
1967 attrs *node, *next;
1969 HOST_WIDE_INT offset;
1970 if (clobber && track_offset_p (REG_OFFSET (loc), &offset))
1972 tree decl = REG_EXPR (loc);
1974 decl = var_debug_decl (decl);
1976 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1979 for (node = *nextp; node; node = next)
1981 next = node->next;
1982 if (clobber || !dv_onepart_p (node->dv))
1984 delete_variable_part (set, node->loc, node->dv, node->offset);
1985 delete node;
1986 *nextp = next;
1988 else
1989 nextp = &node->next;
1993 /* Delete content of register with number REGNO in dataflow set SET. */
1995 static void
1996 var_regno_delete (dataflow_set *set, int regno)
1998 attrs **reg = &set->regs[regno];
1999 attrs *node, *next;
2001 for (node = *reg; node; node = next)
2003 next = node->next;
2004 delete_variable_part (set, node->loc, node->dv, node->offset);
2005 delete node;
2007 *reg = NULL;
2010 /* Return true if I is the negated value of a power of two. */
2011 static bool
2012 negative_power_of_two_p (HOST_WIDE_INT i)
2014 unsigned HOST_WIDE_INT x = -(unsigned HOST_WIDE_INT)i;
2015 return pow2_or_zerop (x);
2018 /* Strip constant offsets and alignments off of LOC. Return the base
2019 expression. */
2021 static rtx
2022 vt_get_canonicalize_base (rtx loc)
2024 while ((GET_CODE (loc) == PLUS
2025 || GET_CODE (loc) == AND)
2026 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2027 && (GET_CODE (loc) != AND
2028 || negative_power_of_two_p (INTVAL (XEXP (loc, 1)))))
2029 loc = XEXP (loc, 0);
2031 return loc;
2034 /* This caches canonicalized addresses for VALUEs, computed using
2035 information in the global cselib table. */
2036 static hash_map<rtx, rtx> *global_get_addr_cache;
2038 /* This caches canonicalized addresses for VALUEs, computed using
2039 information from the global cache and information pertaining to a
2040 basic block being analyzed. */
2041 static hash_map<rtx, rtx> *local_get_addr_cache;
2043 static rtx vt_canonicalize_addr (dataflow_set *, rtx);
2045 /* Return the canonical address for LOC, that must be a VALUE, using a
2046 cached global equivalence or computing it and storing it in the
2047 global cache. */
2049 static rtx
2050 get_addr_from_global_cache (rtx const loc)
2052 rtx x;
2054 gcc_checking_assert (GET_CODE (loc) == VALUE);
2056 bool existed;
2057 rtx *slot = &global_get_addr_cache->get_or_insert (loc, &existed);
2058 if (existed)
2059 return *slot;
2061 x = canon_rtx (get_addr (loc));
2063 /* Tentative, avoiding infinite recursion. */
2064 *slot = x;
2066 if (x != loc)
2068 rtx nx = vt_canonicalize_addr (NULL, x);
2069 if (nx != x)
2071 /* The table may have moved during recursion, recompute
2072 SLOT. */
2073 *global_get_addr_cache->get (loc) = x = nx;
2077 return x;
2080 /* Return the canonical address for LOC, that must be a VALUE, using a
2081 cached local equivalence or computing it and storing it in the
2082 local cache. */
2084 static rtx
2085 get_addr_from_local_cache (dataflow_set *set, rtx const loc)
2087 rtx x;
2088 decl_or_value dv;
2089 variable *var;
2090 location_chain *l;
2092 gcc_checking_assert (GET_CODE (loc) == VALUE);
2094 bool existed;
2095 rtx *slot = &local_get_addr_cache->get_or_insert (loc, &existed);
2096 if (existed)
2097 return *slot;
2099 x = get_addr_from_global_cache (loc);
2101 /* Tentative, avoiding infinite recursion. */
2102 *slot = x;
2104 /* Recurse to cache local expansion of X, or if we need to search
2105 for a VALUE in the expansion. */
2106 if (x != loc)
2108 rtx nx = vt_canonicalize_addr (set, x);
2109 if (nx != x)
2111 slot = local_get_addr_cache->get (loc);
2112 *slot = x = nx;
2114 return x;
2117 dv = dv_from_rtx (x);
2118 var = shared_hash_find (set->vars, dv);
2119 if (!var)
2120 return x;
2122 /* Look for an improved equivalent expression. */
2123 for (l = var->var_part[0].loc_chain; l; l = l->next)
2125 rtx base = vt_get_canonicalize_base (l->loc);
2126 if (GET_CODE (base) == VALUE
2127 && canon_value_cmp (base, loc))
2129 rtx nx = vt_canonicalize_addr (set, l->loc);
2130 if (x != nx)
2132 slot = local_get_addr_cache->get (loc);
2133 *slot = x = nx;
2135 break;
2139 return x;
2142 /* Canonicalize LOC using equivalences from SET in addition to those
2143 in the cselib static table. It expects a VALUE-based expression,
2144 and it will only substitute VALUEs with other VALUEs or
2145 function-global equivalences, so that, if two addresses have base
2146 VALUEs that are locally or globally related in ways that
2147 memrefs_conflict_p cares about, they will both canonicalize to
2148 expressions that have the same base VALUE.
2150 The use of VALUEs as canonical base addresses enables the canonical
2151 RTXs to remain unchanged globally, if they resolve to a constant,
2152 or throughout a basic block otherwise, so that they can be cached
2153 and the cache needs not be invalidated when REGs, MEMs or such
2154 change. */
2156 static rtx
2157 vt_canonicalize_addr (dataflow_set *set, rtx oloc)
2159 HOST_WIDE_INT ofst = 0;
2160 machine_mode mode = GET_MODE (oloc);
2161 rtx loc = oloc;
2162 rtx x;
2163 bool retry = true;
2165 while (retry)
2167 while (GET_CODE (loc) == PLUS
2168 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2170 ofst += INTVAL (XEXP (loc, 1));
2171 loc = XEXP (loc, 0);
2174 /* Alignment operations can't normally be combined, so just
2175 canonicalize the base and we're done. We'll normally have
2176 only one stack alignment anyway. */
2177 if (GET_CODE (loc) == AND
2178 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2179 && negative_power_of_two_p (INTVAL (XEXP (loc, 1))))
2181 x = vt_canonicalize_addr (set, XEXP (loc, 0));
2182 if (x != XEXP (loc, 0))
2183 loc = gen_rtx_AND (mode, x, XEXP (loc, 1));
2184 retry = false;
2187 if (GET_CODE (loc) == VALUE)
2189 if (set)
2190 loc = get_addr_from_local_cache (set, loc);
2191 else
2192 loc = get_addr_from_global_cache (loc);
2194 /* Consolidate plus_constants. */
2195 while (ofst && GET_CODE (loc) == PLUS
2196 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2198 ofst += INTVAL (XEXP (loc, 1));
2199 loc = XEXP (loc, 0);
2202 retry = false;
2204 else
2206 x = canon_rtx (loc);
2207 if (retry)
2208 retry = (x != loc);
2209 loc = x;
2213 /* Add OFST back in. */
2214 if (ofst)
2216 /* Don't build new RTL if we can help it. */
2217 if (GET_CODE (oloc) == PLUS
2218 && XEXP (oloc, 0) == loc
2219 && INTVAL (XEXP (oloc, 1)) == ofst)
2220 return oloc;
2222 loc = plus_constant (mode, loc, ofst);
2225 return loc;
2228 /* Return true iff there's a true dependence between MLOC and LOC.
2229 MADDR must be a canonicalized version of MLOC's address. */
2231 static inline bool
2232 vt_canon_true_dep (dataflow_set *set, rtx mloc, rtx maddr, rtx loc)
2234 if (GET_CODE (loc) != MEM)
2235 return false;
2237 rtx addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2238 if (!canon_true_dependence (mloc, GET_MODE (mloc), maddr, loc, addr))
2239 return false;
2241 return true;
2244 /* Hold parameters for the hashtab traversal function
2245 drop_overlapping_mem_locs, see below. */
2247 struct overlapping_mems
2249 dataflow_set *set;
2250 rtx loc, addr;
2253 /* Remove all MEMs that overlap with COMS->LOC from the location list
2254 of a hash table entry for a onepart variable. COMS->ADDR must be a
2255 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2256 canonicalized itself. */
2259 drop_overlapping_mem_locs (variable **slot, overlapping_mems *coms)
2261 dataflow_set *set = coms->set;
2262 rtx mloc = coms->loc, addr = coms->addr;
2263 variable *var = *slot;
2265 if (var->onepart != NOT_ONEPART)
2267 location_chain *loc, **locp;
2268 bool changed = false;
2269 rtx cur_loc;
2271 gcc_assert (var->n_var_parts == 1);
2273 if (shared_var_p (var, set->vars))
2275 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
2276 if (vt_canon_true_dep (set, mloc, addr, loc->loc))
2277 break;
2279 if (!loc)
2280 return 1;
2282 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
2283 var = *slot;
2284 gcc_assert (var->n_var_parts == 1);
2287 if (VAR_LOC_1PAUX (var))
2288 cur_loc = VAR_LOC_FROM (var);
2289 else
2290 cur_loc = var->var_part[0].cur_loc;
2292 for (locp = &var->var_part[0].loc_chain, loc = *locp;
2293 loc; loc = *locp)
2295 if (!vt_canon_true_dep (set, mloc, addr, loc->loc))
2297 locp = &loc->next;
2298 continue;
2301 *locp = loc->next;
2302 /* If we have deleted the location which was last emitted
2303 we have to emit new location so add the variable to set
2304 of changed variables. */
2305 if (cur_loc == loc->loc)
2307 changed = true;
2308 var->var_part[0].cur_loc = NULL;
2309 if (VAR_LOC_1PAUX (var))
2310 VAR_LOC_FROM (var) = NULL;
2312 delete loc;
2315 if (!var->var_part[0].loc_chain)
2317 var->n_var_parts--;
2318 changed = true;
2320 if (changed)
2321 variable_was_changed (var, set);
2324 return 1;
2327 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2329 static void
2330 clobber_overlapping_mems (dataflow_set *set, rtx loc)
2332 struct overlapping_mems coms;
2334 gcc_checking_assert (GET_CODE (loc) == MEM);
2336 coms.set = set;
2337 coms.loc = canon_rtx (loc);
2338 coms.addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2340 set->traversed_vars = set->vars;
2341 shared_hash_htab (set->vars)
2342 ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms);
2343 set->traversed_vars = NULL;
2346 /* Set the location of DV, OFFSET as the MEM LOC. */
2348 static void
2349 var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2350 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
2351 enum insert_option iopt)
2353 if (dv_is_decl_p (dv))
2354 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
2356 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
2359 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2360 SET to LOC.
2361 Adjust the address first if it is stack pointer based. */
2363 static void
2364 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2365 rtx set_src)
2367 tree decl = MEM_EXPR (loc);
2368 HOST_WIDE_INT offset = int_mem_offset (loc);
2370 var_mem_decl_set (set, loc, initialized,
2371 dv_from_decl (decl), offset, set_src, INSERT);
2374 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2375 dataflow set SET to LOC. If MODIFY is true, any other live copies
2376 of the same variable part are also deleted from the dataflow set,
2377 otherwise the variable part is assumed to be copied from another
2378 location holding the same part.
2379 Adjust the address first if it is stack pointer based. */
2381 static void
2382 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
2383 enum var_init_status initialized, rtx set_src)
2385 tree decl = MEM_EXPR (loc);
2386 HOST_WIDE_INT offset = int_mem_offset (loc);
2388 clobber_overlapping_mems (set, loc);
2389 decl = var_debug_decl (decl);
2391 if (initialized == VAR_INIT_STATUS_UNKNOWN)
2392 initialized = get_init_value (set, loc, dv_from_decl (decl));
2394 if (modify)
2395 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, set_src);
2396 var_mem_set (set, loc, initialized, set_src);
2399 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2400 true, also delete any other live copies of the same variable part.
2401 Adjust the address first if it is stack pointer based. */
2403 static void
2404 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
2406 tree decl = MEM_EXPR (loc);
2407 HOST_WIDE_INT offset = int_mem_offset (loc);
2409 clobber_overlapping_mems (set, loc);
2410 decl = var_debug_decl (decl);
2411 if (clobber)
2412 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
2413 delete_variable_part (set, loc, dv_from_decl (decl), offset);
2416 /* Return true if LOC should not be expanded for location expressions,
2417 or used in them. */
2419 static inline bool
2420 unsuitable_loc (rtx loc)
2422 switch (GET_CODE (loc))
2424 case PC:
2425 case SCRATCH:
2426 case CC0:
2427 case ASM_INPUT:
2428 case ASM_OPERANDS:
2429 return true;
2431 default:
2432 return false;
2436 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2437 bound to it. */
2439 static inline void
2440 val_bind (dataflow_set *set, rtx val, rtx loc, bool modified)
2442 if (REG_P (loc))
2444 if (modified)
2445 var_regno_delete (set, REGNO (loc));
2446 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2447 dv_from_value (val), 0, NULL_RTX, INSERT);
2449 else if (MEM_P (loc))
2451 struct elt_loc_list *l = CSELIB_VAL_PTR (val)->locs;
2453 if (modified)
2454 clobber_overlapping_mems (set, loc);
2456 if (l && GET_CODE (l->loc) == VALUE)
2457 l = canonical_cselib_val (CSELIB_VAL_PTR (l->loc))->locs;
2459 /* If this MEM is a global constant, we don't need it in the
2460 dynamic tables. ??? We should test this before emitting the
2461 micro-op in the first place. */
2462 while (l)
2463 if (GET_CODE (l->loc) == MEM && XEXP (l->loc, 0) == XEXP (loc, 0))
2464 break;
2465 else
2466 l = l->next;
2468 if (!l)
2469 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2470 dv_from_value (val), 0, NULL_RTX, INSERT);
2472 else
2474 /* Other kinds of equivalences are necessarily static, at least
2475 so long as we do not perform substitutions while merging
2476 expressions. */
2477 gcc_unreachable ();
2478 set_variable_part (set, loc, dv_from_value (val), 0,
2479 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2483 /* Bind a value to a location it was just stored in. If MODIFIED
2484 holds, assume the location was modified, detaching it from any
2485 values bound to it. */
2487 static void
2488 val_store (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn,
2489 bool modified)
2491 cselib_val *v = CSELIB_VAL_PTR (val);
2493 gcc_assert (cselib_preserved_value_p (v));
2495 if (dump_file)
2497 fprintf (dump_file, "%i: ", insn ? INSN_UID (insn) : 0);
2498 print_inline_rtx (dump_file, loc, 0);
2499 fprintf (dump_file, " evaluates to ");
2500 print_inline_rtx (dump_file, val, 0);
2501 if (v->locs)
2503 struct elt_loc_list *l;
2504 for (l = v->locs; l; l = l->next)
2506 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
2507 print_inline_rtx (dump_file, l->loc, 0);
2510 fprintf (dump_file, "\n");
2513 gcc_checking_assert (!unsuitable_loc (loc));
2515 val_bind (set, val, loc, modified);
2518 /* Clear (canonical address) slots that reference X. */
2520 bool
2521 local_get_addr_clear_given_value (rtx const &, rtx *slot, rtx x)
2523 if (vt_get_canonicalize_base (*slot) == x)
2524 *slot = NULL;
2525 return true;
2528 /* Reset this node, detaching all its equivalences. Return the slot
2529 in the variable hash table that holds dv, if there is one. */
2531 static void
2532 val_reset (dataflow_set *set, decl_or_value dv)
2534 variable *var = shared_hash_find (set->vars, dv) ;
2535 location_chain *node;
2536 rtx cval;
2538 if (!var || !var->n_var_parts)
2539 return;
2541 gcc_assert (var->n_var_parts == 1);
2543 if (var->onepart == ONEPART_VALUE)
2545 rtx x = dv_as_value (dv);
2547 /* Relationships in the global cache don't change, so reset the
2548 local cache entry only. */
2549 rtx *slot = local_get_addr_cache->get (x);
2550 if (slot)
2552 /* If the value resolved back to itself, odds are that other
2553 values may have cached it too. These entries now refer
2554 to the old X, so detach them too. Entries that used the
2555 old X but resolved to something else remain ok as long as
2556 that something else isn't also reset. */
2557 if (*slot == x)
2558 local_get_addr_cache
2559 ->traverse<rtx, local_get_addr_clear_given_value> (x);
2560 *slot = NULL;
2564 cval = NULL;
2565 for (node = var->var_part[0].loc_chain; node; node = node->next)
2566 if (GET_CODE (node->loc) == VALUE
2567 && canon_value_cmp (node->loc, cval))
2568 cval = node->loc;
2570 for (node = var->var_part[0].loc_chain; node; node = node->next)
2571 if (GET_CODE (node->loc) == VALUE && cval != node->loc)
2573 /* Redirect the equivalence link to the new canonical
2574 value, or simply remove it if it would point at
2575 itself. */
2576 if (cval)
2577 set_variable_part (set, cval, dv_from_value (node->loc),
2578 0, node->init, node->set_src, NO_INSERT);
2579 delete_variable_part (set, dv_as_value (dv),
2580 dv_from_value (node->loc), 0);
2583 if (cval)
2585 decl_or_value cdv = dv_from_value (cval);
2587 /* Keep the remaining values connected, accumulating links
2588 in the canonical value. */
2589 for (node = var->var_part[0].loc_chain; node; node = node->next)
2591 if (node->loc == cval)
2592 continue;
2593 else if (GET_CODE (node->loc) == REG)
2594 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
2595 node->set_src, NO_INSERT);
2596 else if (GET_CODE (node->loc) == MEM)
2597 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
2598 node->set_src, NO_INSERT);
2599 else
2600 set_variable_part (set, node->loc, cdv, 0,
2601 node->init, node->set_src, NO_INSERT);
2605 /* We remove this last, to make sure that the canonical value is not
2606 removed to the point of requiring reinsertion. */
2607 if (cval)
2608 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
2610 clobber_variable_part (set, NULL, dv, 0, NULL);
2613 /* Find the values in a given location and map the val to another
2614 value, if it is unique, or add the location as one holding the
2615 value. */
2617 static void
2618 val_resolve (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn)
2620 decl_or_value dv = dv_from_value (val);
2622 if (dump_file && (dump_flags & TDF_DETAILS))
2624 if (insn)
2625 fprintf (dump_file, "%i: ", INSN_UID (insn));
2626 else
2627 fprintf (dump_file, "head: ");
2628 print_inline_rtx (dump_file, val, 0);
2629 fputs (" is at ", dump_file);
2630 print_inline_rtx (dump_file, loc, 0);
2631 fputc ('\n', dump_file);
2634 val_reset (set, dv);
2636 gcc_checking_assert (!unsuitable_loc (loc));
2638 if (REG_P (loc))
2640 attrs *node, *found = NULL;
2642 for (node = set->regs[REGNO (loc)]; node; node = node->next)
2643 if (dv_is_value_p (node->dv)
2644 && GET_MODE (dv_as_value (node->dv)) == GET_MODE (loc))
2646 found = node;
2648 /* Map incoming equivalences. ??? Wouldn't it be nice if
2649 we just started sharing the location lists? Maybe a
2650 circular list ending at the value itself or some
2651 such. */
2652 set_variable_part (set, dv_as_value (node->dv),
2653 dv_from_value (val), node->offset,
2654 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2655 set_variable_part (set, val, node->dv, node->offset,
2656 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2659 /* If we didn't find any equivalence, we need to remember that
2660 this value is held in the named register. */
2661 if (found)
2662 return;
2664 /* ??? Attempt to find and merge equivalent MEMs or other
2665 expressions too. */
2667 val_bind (set, val, loc, false);
2670 /* Initialize dataflow set SET to be empty.
2671 VARS_SIZE is the initial size of hash table VARS. */
2673 static void
2674 dataflow_set_init (dataflow_set *set)
2676 init_attrs_list_set (set->regs);
2677 set->vars = shared_hash_copy (empty_shared_hash);
2678 set->stack_adjust = 0;
2679 set->traversed_vars = NULL;
2682 /* Delete the contents of dataflow set SET. */
2684 static void
2685 dataflow_set_clear (dataflow_set *set)
2687 int i;
2689 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2690 attrs_list_clear (&set->regs[i]);
2692 shared_hash_destroy (set->vars);
2693 set->vars = shared_hash_copy (empty_shared_hash);
2696 /* Copy the contents of dataflow set SRC to DST. */
2698 static void
2699 dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
2701 int i;
2703 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2704 attrs_list_copy (&dst->regs[i], src->regs[i]);
2706 shared_hash_destroy (dst->vars);
2707 dst->vars = shared_hash_copy (src->vars);
2708 dst->stack_adjust = src->stack_adjust;
2711 /* Information for merging lists of locations for a given offset of variable.
2713 struct variable_union_info
2715 /* Node of the location chain. */
2716 location_chain *lc;
2718 /* The sum of positions in the input chains. */
2719 int pos;
2721 /* The position in the chain of DST dataflow set. */
2722 int pos_dst;
2725 /* Buffer for location list sorting and its allocated size. */
2726 static struct variable_union_info *vui_vec;
2727 static int vui_allocated;
2729 /* Compare function for qsort, order the structures by POS element. */
2731 static int
2732 variable_union_info_cmp_pos (const void *n1, const void *n2)
2734 const struct variable_union_info *const i1 =
2735 (const struct variable_union_info *) n1;
2736 const struct variable_union_info *const i2 =
2737 ( const struct variable_union_info *) n2;
2739 if (i1->pos != i2->pos)
2740 return i1->pos - i2->pos;
2742 return (i1->pos_dst - i2->pos_dst);
2745 /* Compute union of location parts of variable *SLOT and the same variable
2746 from hash table DATA. Compute "sorted" union of the location chains
2747 for common offsets, i.e. the locations of a variable part are sorted by
2748 a priority where the priority is the sum of the positions in the 2 chains
2749 (if a location is only in one list the position in the second list is
2750 defined to be larger than the length of the chains).
2751 When we are updating the location parts the newest location is in the
2752 beginning of the chain, so when we do the described "sorted" union
2753 we keep the newest locations in the beginning. */
2755 static int
2756 variable_union (variable *src, dataflow_set *set)
2758 variable *dst;
2759 variable **dstp;
2760 int i, j, k;
2762 dstp = shared_hash_find_slot (set->vars, src->dv);
2763 if (!dstp || !*dstp)
2765 src->refcount++;
2767 dst_can_be_shared = false;
2768 if (!dstp)
2769 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2771 *dstp = src;
2773 /* Continue traversing the hash table. */
2774 return 1;
2776 else
2777 dst = *dstp;
2779 gcc_assert (src->n_var_parts);
2780 gcc_checking_assert (src->onepart == dst->onepart);
2782 /* We can combine one-part variables very efficiently, because their
2783 entries are in canonical order. */
2784 if (src->onepart)
2786 location_chain **nodep, *dnode, *snode;
2788 gcc_assert (src->n_var_parts == 1
2789 && dst->n_var_parts == 1);
2791 snode = src->var_part[0].loc_chain;
2792 gcc_assert (snode);
2794 restart_onepart_unshared:
2795 nodep = &dst->var_part[0].loc_chain;
2796 dnode = *nodep;
2797 gcc_assert (dnode);
2799 while (snode)
2801 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2803 if (r > 0)
2805 location_chain *nnode;
2807 if (shared_var_p (dst, set->vars))
2809 dstp = unshare_variable (set, dstp, dst,
2810 VAR_INIT_STATUS_INITIALIZED);
2811 dst = *dstp;
2812 goto restart_onepart_unshared;
2815 *nodep = nnode = new location_chain;
2816 nnode->loc = snode->loc;
2817 nnode->init = snode->init;
2818 if (!snode->set_src || MEM_P (snode->set_src))
2819 nnode->set_src = NULL;
2820 else
2821 nnode->set_src = snode->set_src;
2822 nnode->next = dnode;
2823 dnode = nnode;
2825 else if (r == 0)
2826 gcc_checking_assert (rtx_equal_p (dnode->loc, snode->loc));
2828 if (r >= 0)
2829 snode = snode->next;
2831 nodep = &dnode->next;
2832 dnode = *nodep;
2835 return 1;
2838 gcc_checking_assert (!src->onepart);
2840 /* Count the number of location parts, result is K. */
2841 for (i = 0, j = 0, k = 0;
2842 i < src->n_var_parts && j < dst->n_var_parts; k++)
2844 if (VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2846 i++;
2847 j++;
2849 else if (VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
2850 i++;
2851 else
2852 j++;
2854 k += src->n_var_parts - i;
2855 k += dst->n_var_parts - j;
2857 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2858 thus there are at most MAX_VAR_PARTS different offsets. */
2859 gcc_checking_assert (dst->onepart ? k == 1 : k <= MAX_VAR_PARTS);
2861 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2863 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2864 dst = *dstp;
2867 i = src->n_var_parts - 1;
2868 j = dst->n_var_parts - 1;
2869 dst->n_var_parts = k;
2871 for (k--; k >= 0; k--)
2873 location_chain *node, *node2;
2875 if (i >= 0 && j >= 0
2876 && VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2878 /* Compute the "sorted" union of the chains, i.e. the locations which
2879 are in both chains go first, they are sorted by the sum of
2880 positions in the chains. */
2881 int dst_l, src_l;
2882 int ii, jj, n;
2883 struct variable_union_info *vui;
2885 /* If DST is shared compare the location chains.
2886 If they are different we will modify the chain in DST with
2887 high probability so make a copy of DST. */
2888 if (shared_var_p (dst, set->vars))
2890 for (node = src->var_part[i].loc_chain,
2891 node2 = dst->var_part[j].loc_chain; node && node2;
2892 node = node->next, node2 = node2->next)
2894 if (!((REG_P (node2->loc)
2895 && REG_P (node->loc)
2896 && REGNO (node2->loc) == REGNO (node->loc))
2897 || rtx_equal_p (node2->loc, node->loc)))
2899 if (node2->init < node->init)
2900 node2->init = node->init;
2901 break;
2904 if (node || node2)
2906 dstp = unshare_variable (set, dstp, dst,
2907 VAR_INIT_STATUS_UNKNOWN);
2908 dst = (variable *)*dstp;
2912 src_l = 0;
2913 for (node = src->var_part[i].loc_chain; node; node = node->next)
2914 src_l++;
2915 dst_l = 0;
2916 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2917 dst_l++;
2919 if (dst_l == 1)
2921 /* The most common case, much simpler, no qsort is needed. */
2922 location_chain *dstnode = dst->var_part[j].loc_chain;
2923 dst->var_part[k].loc_chain = dstnode;
2924 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
2925 node2 = dstnode;
2926 for (node = src->var_part[i].loc_chain; node; node = node->next)
2927 if (!((REG_P (dstnode->loc)
2928 && REG_P (node->loc)
2929 && REGNO (dstnode->loc) == REGNO (node->loc))
2930 || rtx_equal_p (dstnode->loc, node->loc)))
2932 location_chain *new_node;
2934 /* Copy the location from SRC. */
2935 new_node = new location_chain;
2936 new_node->loc = node->loc;
2937 new_node->init = node->init;
2938 if (!node->set_src || MEM_P (node->set_src))
2939 new_node->set_src = NULL;
2940 else
2941 new_node->set_src = node->set_src;
2942 node2->next = new_node;
2943 node2 = new_node;
2945 node2->next = NULL;
2947 else
2949 if (src_l + dst_l > vui_allocated)
2951 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l);
2952 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,
2953 vui_allocated);
2955 vui = vui_vec;
2957 /* Fill in the locations from DST. */
2958 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2959 node = node->next, jj++)
2961 vui[jj].lc = node;
2962 vui[jj].pos_dst = jj;
2964 /* Pos plus value larger than a sum of 2 valid positions. */
2965 vui[jj].pos = jj + src_l + dst_l;
2968 /* Fill in the locations from SRC. */
2969 n = dst_l;
2970 for (node = src->var_part[i].loc_chain, ii = 0; node;
2971 node = node->next, ii++)
2973 /* Find location from NODE. */
2974 for (jj = 0; jj < dst_l; jj++)
2976 if ((REG_P (vui[jj].lc->loc)
2977 && REG_P (node->loc)
2978 && REGNO (vui[jj].lc->loc) == REGNO (node->loc))
2979 || rtx_equal_p (vui[jj].lc->loc, node->loc))
2981 vui[jj].pos = jj + ii;
2982 break;
2985 if (jj >= dst_l) /* The location has not been found. */
2987 location_chain *new_node;
2989 /* Copy the location from SRC. */
2990 new_node = new location_chain;
2991 new_node->loc = node->loc;
2992 new_node->init = node->init;
2993 if (!node->set_src || MEM_P (node->set_src))
2994 new_node->set_src = NULL;
2995 else
2996 new_node->set_src = node->set_src;
2997 vui[n].lc = new_node;
2998 vui[n].pos_dst = src_l + dst_l;
2999 vui[n].pos = ii + src_l + dst_l;
3000 n++;
3004 if (dst_l == 2)
3006 /* Special case still very common case. For dst_l == 2
3007 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3008 vui[i].pos == i + src_l + dst_l. */
3009 if (vui[0].pos > vui[1].pos)
3011 /* Order should be 1, 0, 2... */
3012 dst->var_part[k].loc_chain = vui[1].lc;
3013 vui[1].lc->next = vui[0].lc;
3014 if (n >= 3)
3016 vui[0].lc->next = vui[2].lc;
3017 vui[n - 1].lc->next = NULL;
3019 else
3020 vui[0].lc->next = NULL;
3021 ii = 3;
3023 else
3025 dst->var_part[k].loc_chain = vui[0].lc;
3026 if (n >= 3 && vui[2].pos < vui[1].pos)
3028 /* Order should be 0, 2, 1, 3... */
3029 vui[0].lc->next = vui[2].lc;
3030 vui[2].lc->next = vui[1].lc;
3031 if (n >= 4)
3033 vui[1].lc->next = vui[3].lc;
3034 vui[n - 1].lc->next = NULL;
3036 else
3037 vui[1].lc->next = NULL;
3038 ii = 4;
3040 else
3042 /* Order should be 0, 1, 2... */
3043 ii = 1;
3044 vui[n - 1].lc->next = NULL;
3047 for (; ii < n; ii++)
3048 vui[ii - 1].lc->next = vui[ii].lc;
3050 else
3052 qsort (vui, n, sizeof (struct variable_union_info),
3053 variable_union_info_cmp_pos);
3055 /* Reconnect the nodes in sorted order. */
3056 for (ii = 1; ii < n; ii++)
3057 vui[ii - 1].lc->next = vui[ii].lc;
3058 vui[n - 1].lc->next = NULL;
3059 dst->var_part[k].loc_chain = vui[0].lc;
3062 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
3064 i--;
3065 j--;
3067 else if ((i >= 0 && j >= 0
3068 && VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
3069 || i < 0)
3071 dst->var_part[k] = dst->var_part[j];
3072 j--;
3074 else if ((i >= 0 && j >= 0
3075 && VAR_PART_OFFSET (src, i) > VAR_PART_OFFSET (dst, j))
3076 || j < 0)
3078 location_chain **nextp;
3080 /* Copy the chain from SRC. */
3081 nextp = &dst->var_part[k].loc_chain;
3082 for (node = src->var_part[i].loc_chain; node; node = node->next)
3084 location_chain *new_lc;
3086 new_lc = new location_chain;
3087 new_lc->next = NULL;
3088 new_lc->init = node->init;
3089 if (!node->set_src || MEM_P (node->set_src))
3090 new_lc->set_src = NULL;
3091 else
3092 new_lc->set_src = node->set_src;
3093 new_lc->loc = node->loc;
3095 *nextp = new_lc;
3096 nextp = &new_lc->next;
3099 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (src, i);
3100 i--;
3102 dst->var_part[k].cur_loc = NULL;
3105 if (flag_var_tracking_uninit)
3106 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
3108 location_chain *node, *node2;
3109 for (node = src->var_part[i].loc_chain; node; node = node->next)
3110 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
3111 if (rtx_equal_p (node->loc, node2->loc))
3113 if (node->init > node2->init)
3114 node2->init = node->init;
3118 /* Continue traversing the hash table. */
3119 return 1;
3122 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3124 static void
3125 dataflow_set_union (dataflow_set *dst, dataflow_set *src)
3127 int i;
3129 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3130 attrs_list_union (&dst->regs[i], src->regs[i]);
3132 if (dst->vars == empty_shared_hash)
3134 shared_hash_destroy (dst->vars);
3135 dst->vars = shared_hash_copy (src->vars);
3137 else
3139 variable_iterator_type hi;
3140 variable *var;
3142 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars),
3143 var, variable, hi)
3144 variable_union (var, dst);
3148 /* Whether the value is currently being expanded. */
3149 #define VALUE_RECURSED_INTO(x) \
3150 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3152 /* Whether no expansion was found, saving useless lookups.
3153 It must only be set when VALUE_CHANGED is clear. */
3154 #define NO_LOC_P(x) \
3155 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3157 /* Whether cur_loc in the value needs to be (re)computed. */
3158 #define VALUE_CHANGED(x) \
3159 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3160 /* Whether cur_loc in the decl needs to be (re)computed. */
3161 #define DECL_CHANGED(x) TREE_VISITED (x)
3163 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3164 user DECLs, this means they're in changed_variables. Values and
3165 debug exprs may be left with this flag set if no user variable
3166 requires them to be evaluated. */
3168 static inline void
3169 set_dv_changed (decl_or_value dv, bool newv)
3171 switch (dv_onepart_p (dv))
3173 case ONEPART_VALUE:
3174 if (newv)
3175 NO_LOC_P (dv_as_value (dv)) = false;
3176 VALUE_CHANGED (dv_as_value (dv)) = newv;
3177 break;
3179 case ONEPART_DEXPR:
3180 if (newv)
3181 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv))) = false;
3182 /* Fall through. */
3184 default:
3185 DECL_CHANGED (dv_as_decl (dv)) = newv;
3186 break;
3190 /* Return true if DV needs to have its cur_loc recomputed. */
3192 static inline bool
3193 dv_changed_p (decl_or_value dv)
3195 return (dv_is_value_p (dv)
3196 ? VALUE_CHANGED (dv_as_value (dv))
3197 : DECL_CHANGED (dv_as_decl (dv)));
3200 /* Return a location list node whose loc is rtx_equal to LOC, in the
3201 location list of a one-part variable or value VAR, or in that of
3202 any values recursively mentioned in the location lists. VARS must
3203 be in star-canonical form. */
3205 static location_chain *
3206 find_loc_in_1pdv (rtx loc, variable *var, variable_table_type *vars)
3208 location_chain *node;
3209 enum rtx_code loc_code;
3211 if (!var)
3212 return NULL;
3214 gcc_checking_assert (var->onepart);
3216 if (!var->n_var_parts)
3217 return NULL;
3219 gcc_checking_assert (loc != dv_as_opaque (var->dv));
3221 loc_code = GET_CODE (loc);
3222 for (node = var->var_part[0].loc_chain; node; node = node->next)
3224 decl_or_value dv;
3225 variable *rvar;
3227 if (GET_CODE (node->loc) != loc_code)
3229 if (GET_CODE (node->loc) != VALUE)
3230 continue;
3232 else if (loc == node->loc)
3233 return node;
3234 else if (loc_code != VALUE)
3236 if (rtx_equal_p (loc, node->loc))
3237 return node;
3238 continue;
3241 /* Since we're in star-canonical form, we don't need to visit
3242 non-canonical nodes: one-part variables and non-canonical
3243 values would only point back to the canonical node. */
3244 if (dv_is_value_p (var->dv)
3245 && !canon_value_cmp (node->loc, dv_as_value (var->dv)))
3247 /* Skip all subsequent VALUEs. */
3248 while (node->next && GET_CODE (node->next->loc) == VALUE)
3250 node = node->next;
3251 gcc_checking_assert (!canon_value_cmp (node->loc,
3252 dv_as_value (var->dv)));
3253 if (loc == node->loc)
3254 return node;
3256 continue;
3259 gcc_checking_assert (node == var->var_part[0].loc_chain);
3260 gcc_checking_assert (!node->next);
3262 dv = dv_from_value (node->loc);
3263 rvar = vars->find_with_hash (dv, dv_htab_hash (dv));
3264 return find_loc_in_1pdv (loc, rvar, vars);
3267 /* ??? Gotta look in cselib_val locations too. */
3269 return NULL;
3272 /* Hash table iteration argument passed to variable_merge. */
3273 struct dfset_merge
3275 /* The set in which the merge is to be inserted. */
3276 dataflow_set *dst;
3277 /* The set that we're iterating in. */
3278 dataflow_set *cur;
3279 /* The set that may contain the other dv we are to merge with. */
3280 dataflow_set *src;
3281 /* Number of onepart dvs in src. */
3282 int src_onepart_cnt;
3285 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3286 loc_cmp order, and it is maintained as such. */
3288 static void
3289 insert_into_intersection (location_chain **nodep, rtx loc,
3290 enum var_init_status status)
3292 location_chain *node;
3293 int r;
3295 for (node = *nodep; node; nodep = &node->next, node = *nodep)
3296 if ((r = loc_cmp (node->loc, loc)) == 0)
3298 node->init = MIN (node->init, status);
3299 return;
3301 else if (r > 0)
3302 break;
3304 node = new location_chain;
3306 node->loc = loc;
3307 node->set_src = NULL;
3308 node->init = status;
3309 node->next = *nodep;
3310 *nodep = node;
3313 /* Insert in DEST the intersection of the locations present in both
3314 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3315 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3316 DSM->dst. */
3318 static void
3319 intersect_loc_chains (rtx val, location_chain **dest, struct dfset_merge *dsm,
3320 location_chain *s1node, variable *s2var)
3322 dataflow_set *s1set = dsm->cur;
3323 dataflow_set *s2set = dsm->src;
3324 location_chain *found;
3326 if (s2var)
3328 location_chain *s2node;
3330 gcc_checking_assert (s2var->onepart);
3332 if (s2var->n_var_parts)
3334 s2node = s2var->var_part[0].loc_chain;
3336 for (; s1node && s2node;
3337 s1node = s1node->next, s2node = s2node->next)
3338 if (s1node->loc != s2node->loc)
3339 break;
3340 else if (s1node->loc == val)
3341 continue;
3342 else
3343 insert_into_intersection (dest, s1node->loc,
3344 MIN (s1node->init, s2node->init));
3348 for (; s1node; s1node = s1node->next)
3350 if (s1node->loc == val)
3351 continue;
3353 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
3354 shared_hash_htab (s2set->vars))))
3356 insert_into_intersection (dest, s1node->loc,
3357 MIN (s1node->init, found->init));
3358 continue;
3361 if (GET_CODE (s1node->loc) == VALUE
3362 && !VALUE_RECURSED_INTO (s1node->loc))
3364 decl_or_value dv = dv_from_value (s1node->loc);
3365 variable *svar = shared_hash_find (s1set->vars, dv);
3366 if (svar)
3368 if (svar->n_var_parts == 1)
3370 VALUE_RECURSED_INTO (s1node->loc) = true;
3371 intersect_loc_chains (val, dest, dsm,
3372 svar->var_part[0].loc_chain,
3373 s2var);
3374 VALUE_RECURSED_INTO (s1node->loc) = false;
3379 /* ??? gotta look in cselib_val locations too. */
3381 /* ??? if the location is equivalent to any location in src,
3382 searched recursively
3384 add to dst the values needed to represent the equivalence
3386 telling whether locations S is equivalent to another dv's
3387 location list:
3389 for each location D in the list
3391 if S and D satisfy rtx_equal_p, then it is present
3393 else if D is a value, recurse without cycles
3395 else if S and D have the same CODE and MODE
3397 for each operand oS and the corresponding oD
3399 if oS and oD are not equivalent, then S an D are not equivalent
3401 else if they are RTX vectors
3403 if any vector oS element is not equivalent to its respective oD,
3404 then S and D are not equivalent
3412 /* Return -1 if X should be before Y in a location list for a 1-part
3413 variable, 1 if Y should be before X, and 0 if they're equivalent
3414 and should not appear in the list. */
3416 static int
3417 loc_cmp (rtx x, rtx y)
3419 int i, j, r;
3420 RTX_CODE code = GET_CODE (x);
3421 const char *fmt;
3423 if (x == y)
3424 return 0;
3426 if (REG_P (x))
3428 if (!REG_P (y))
3429 return -1;
3430 gcc_assert (GET_MODE (x) == GET_MODE (y));
3431 if (REGNO (x) == REGNO (y))
3432 return 0;
3433 else if (REGNO (x) < REGNO (y))
3434 return -1;
3435 else
3436 return 1;
3439 if (REG_P (y))
3440 return 1;
3442 if (MEM_P (x))
3444 if (!MEM_P (y))
3445 return -1;
3446 gcc_assert (GET_MODE (x) == GET_MODE (y));
3447 return loc_cmp (XEXP (x, 0), XEXP (y, 0));
3450 if (MEM_P (y))
3451 return 1;
3453 if (GET_CODE (x) == VALUE)
3455 if (GET_CODE (y) != VALUE)
3456 return -1;
3457 /* Don't assert the modes are the same, that is true only
3458 when not recursing. (subreg:QI (value:SI 1:1) 0)
3459 and (subreg:QI (value:DI 2:2) 0) can be compared,
3460 even when the modes are different. */
3461 if (canon_value_cmp (x, y))
3462 return -1;
3463 else
3464 return 1;
3467 if (GET_CODE (y) == VALUE)
3468 return 1;
3470 /* Entry value is the least preferable kind of expression. */
3471 if (GET_CODE (x) == ENTRY_VALUE)
3473 if (GET_CODE (y) != ENTRY_VALUE)
3474 return 1;
3475 gcc_assert (GET_MODE (x) == GET_MODE (y));
3476 return loc_cmp (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
3479 if (GET_CODE (y) == ENTRY_VALUE)
3480 return -1;
3482 if (GET_CODE (x) == GET_CODE (y))
3483 /* Compare operands below. */;
3484 else if (GET_CODE (x) < GET_CODE (y))
3485 return -1;
3486 else
3487 return 1;
3489 gcc_assert (GET_MODE (x) == GET_MODE (y));
3491 if (GET_CODE (x) == DEBUG_EXPR)
3493 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3494 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))
3495 return -1;
3496 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3497 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)));
3498 return 1;
3501 fmt = GET_RTX_FORMAT (code);
3502 for (i = 0; i < GET_RTX_LENGTH (code); i++)
3503 switch (fmt[i])
3505 case 'w':
3506 if (XWINT (x, i) == XWINT (y, i))
3507 break;
3508 else if (XWINT (x, i) < XWINT (y, i))
3509 return -1;
3510 else
3511 return 1;
3513 case 'n':
3514 case 'i':
3515 if (XINT (x, i) == XINT (y, i))
3516 break;
3517 else if (XINT (x, i) < XINT (y, i))
3518 return -1;
3519 else
3520 return 1;
3522 case 'p':
3523 r = compare_sizes_for_sort (SUBREG_BYTE (x), SUBREG_BYTE (y));
3524 if (r != 0)
3525 return r;
3526 break;
3528 case 'V':
3529 case 'E':
3530 /* Compare the vector length first. */
3531 if (XVECLEN (x, i) == XVECLEN (y, i))
3532 /* Compare the vectors elements. */;
3533 else if (XVECLEN (x, i) < XVECLEN (y, i))
3534 return -1;
3535 else
3536 return 1;
3538 for (j = 0; j < XVECLEN (x, i); j++)
3539 if ((r = loc_cmp (XVECEXP (x, i, j),
3540 XVECEXP (y, i, j))))
3541 return r;
3542 break;
3544 case 'e':
3545 if ((r = loc_cmp (XEXP (x, i), XEXP (y, i))))
3546 return r;
3547 break;
3549 case 'S':
3550 case 's':
3551 if (XSTR (x, i) == XSTR (y, i))
3552 break;
3553 if (!XSTR (x, i))
3554 return -1;
3555 if (!XSTR (y, i))
3556 return 1;
3557 if ((r = strcmp (XSTR (x, i), XSTR (y, i))) == 0)
3558 break;
3559 else if (r < 0)
3560 return -1;
3561 else
3562 return 1;
3564 case 'u':
3565 /* These are just backpointers, so they don't matter. */
3566 break;
3568 case '0':
3569 case 't':
3570 break;
3572 /* It is believed that rtx's at this level will never
3573 contain anything but integers and other rtx's,
3574 except for within LABEL_REFs and SYMBOL_REFs. */
3575 default:
3576 gcc_unreachable ();
3578 if (CONST_WIDE_INT_P (x))
3580 /* Compare the vector length first. */
3581 if (CONST_WIDE_INT_NUNITS (x) >= CONST_WIDE_INT_NUNITS (y))
3582 return 1;
3583 else if (CONST_WIDE_INT_NUNITS (x) < CONST_WIDE_INT_NUNITS (y))
3584 return -1;
3586 /* Compare the vectors elements. */;
3587 for (j = CONST_WIDE_INT_NUNITS (x) - 1; j >= 0 ; j--)
3589 if (CONST_WIDE_INT_ELT (x, j) < CONST_WIDE_INT_ELT (y, j))
3590 return -1;
3591 if (CONST_WIDE_INT_ELT (x, j) > CONST_WIDE_INT_ELT (y, j))
3592 return 1;
3596 return 0;
3599 /* Check the order of entries in one-part variables. */
3602 canonicalize_loc_order_check (variable **slot,
3603 dataflow_set *data ATTRIBUTE_UNUSED)
3605 variable *var = *slot;
3606 location_chain *node, *next;
3608 #ifdef ENABLE_RTL_CHECKING
3609 int i;
3610 for (i = 0; i < var->n_var_parts; i++)
3611 gcc_assert (var->var_part[0].cur_loc == NULL);
3612 gcc_assert (!var->in_changed_variables);
3613 #endif
3615 if (!var->onepart)
3616 return 1;
3618 gcc_assert (var->n_var_parts == 1);
3619 node = var->var_part[0].loc_chain;
3620 gcc_assert (node);
3622 while ((next = node->next))
3624 gcc_assert (loc_cmp (node->loc, next->loc) < 0);
3625 node = next;
3628 return 1;
3631 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3632 more likely to be chosen as canonical for an equivalence set.
3633 Ensure less likely values can reach more likely neighbors, making
3634 the connections bidirectional. */
3637 canonicalize_values_mark (variable **slot, dataflow_set *set)
3639 variable *var = *slot;
3640 decl_or_value dv = var->dv;
3641 rtx val;
3642 location_chain *node;
3644 if (!dv_is_value_p (dv))
3645 return 1;
3647 gcc_checking_assert (var->n_var_parts == 1);
3649 val = dv_as_value (dv);
3651 for (node = var->var_part[0].loc_chain; node; node = node->next)
3652 if (GET_CODE (node->loc) == VALUE)
3654 if (canon_value_cmp (node->loc, val))
3655 VALUE_RECURSED_INTO (val) = true;
3656 else
3658 decl_or_value odv = dv_from_value (node->loc);
3659 variable **oslot;
3660 oslot = shared_hash_find_slot_noinsert (set->vars, odv);
3662 set_slot_part (set, val, oslot, odv, 0,
3663 node->init, NULL_RTX);
3665 VALUE_RECURSED_INTO (node->loc) = true;
3669 return 1;
3672 /* Remove redundant entries from equivalence lists in onepart
3673 variables, canonicalizing equivalence sets into star shapes. */
3676 canonicalize_values_star (variable **slot, dataflow_set *set)
3678 variable *var = *slot;
3679 decl_or_value dv = var->dv;
3680 location_chain *node;
3681 decl_or_value cdv;
3682 rtx val, cval;
3683 variable **cslot;
3684 bool has_value;
3685 bool has_marks;
3687 if (!var->onepart)
3688 return 1;
3690 gcc_checking_assert (var->n_var_parts == 1);
3692 if (dv_is_value_p (dv))
3694 cval = dv_as_value (dv);
3695 if (!VALUE_RECURSED_INTO (cval))
3696 return 1;
3697 VALUE_RECURSED_INTO (cval) = false;
3699 else
3700 cval = NULL_RTX;
3702 restart:
3703 val = cval;
3704 has_value = false;
3705 has_marks = false;
3707 gcc_assert (var->n_var_parts == 1);
3709 for (node = var->var_part[0].loc_chain; node; node = node->next)
3710 if (GET_CODE (node->loc) == VALUE)
3712 has_value = true;
3713 if (VALUE_RECURSED_INTO (node->loc))
3714 has_marks = true;
3715 if (canon_value_cmp (node->loc, cval))
3716 cval = node->loc;
3719 if (!has_value)
3720 return 1;
3722 if (cval == val)
3724 if (!has_marks || dv_is_decl_p (dv))
3725 return 1;
3727 /* Keep it marked so that we revisit it, either after visiting a
3728 child node, or after visiting a new parent that might be
3729 found out. */
3730 VALUE_RECURSED_INTO (val) = true;
3732 for (node = var->var_part[0].loc_chain; node; node = node->next)
3733 if (GET_CODE (node->loc) == VALUE
3734 && VALUE_RECURSED_INTO (node->loc))
3736 cval = node->loc;
3737 restart_with_cval:
3738 VALUE_RECURSED_INTO (cval) = false;
3739 dv = dv_from_value (cval);
3740 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3741 if (!slot)
3743 gcc_assert (dv_is_decl_p (var->dv));
3744 /* The canonical value was reset and dropped.
3745 Remove it. */
3746 clobber_variable_part (set, NULL, var->dv, 0, NULL);
3747 return 1;
3749 var = *slot;
3750 gcc_assert (dv_is_value_p (var->dv));
3751 if (var->n_var_parts == 0)
3752 return 1;
3753 gcc_assert (var->n_var_parts == 1);
3754 goto restart;
3757 VALUE_RECURSED_INTO (val) = false;
3759 return 1;
3762 /* Push values to the canonical one. */
3763 cdv = dv_from_value (cval);
3764 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3766 for (node = var->var_part[0].loc_chain; node; node = node->next)
3767 if (node->loc != cval)
3769 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3770 node->init, NULL_RTX);
3771 if (GET_CODE (node->loc) == VALUE)
3773 decl_or_value ndv = dv_from_value (node->loc);
3775 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX,
3776 NO_INSERT);
3778 if (canon_value_cmp (node->loc, val))
3780 /* If it could have been a local minimum, it's not any more,
3781 since it's now neighbor to cval, so it may have to push
3782 to it. Conversely, if it wouldn't have prevailed over
3783 val, then whatever mark it has is fine: if it was to
3784 push, it will now push to a more canonical node, but if
3785 it wasn't, then it has already pushed any values it might
3786 have to. */
3787 VALUE_RECURSED_INTO (node->loc) = true;
3788 /* Make sure we visit node->loc by ensuring we cval is
3789 visited too. */
3790 VALUE_RECURSED_INTO (cval) = true;
3792 else if (!VALUE_RECURSED_INTO (node->loc))
3793 /* If we have no need to "recurse" into this node, it's
3794 already "canonicalized", so drop the link to the old
3795 parent. */
3796 clobber_variable_part (set, cval, ndv, 0, NULL);
3798 else if (GET_CODE (node->loc) == REG)
3800 attrs *list = set->regs[REGNO (node->loc)], **listp;
3802 /* Change an existing attribute referring to dv so that it
3803 refers to cdv, removing any duplicate this might
3804 introduce, and checking that no previous duplicates
3805 existed, all in a single pass. */
3807 while (list)
3809 if (list->offset == 0
3810 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3811 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3812 break;
3814 list = list->next;
3817 gcc_assert (list);
3818 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3820 list->dv = cdv;
3821 for (listp = &list->next; (list = *listp); listp = &list->next)
3823 if (list->offset)
3824 continue;
3826 if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3828 *listp = list->next;
3829 delete list;
3830 list = *listp;
3831 break;
3834 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (dv));
3837 else if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3839 for (listp = &list->next; (list = *listp); listp = &list->next)
3841 if (list->offset)
3842 continue;
3844 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3846 *listp = list->next;
3847 delete list;
3848 list = *listp;
3849 break;
3852 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (cdv));
3855 else
3856 gcc_unreachable ();
3858 if (flag_checking)
3859 while (list)
3861 if (list->offset == 0
3862 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3863 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3864 gcc_unreachable ();
3866 list = list->next;
3871 if (val)
3872 set_slot_part (set, val, cslot, cdv, 0,
3873 VAR_INIT_STATUS_INITIALIZED, NULL_RTX);
3875 slot = clobber_slot_part (set, cval, slot, 0, NULL);
3877 /* Variable may have been unshared. */
3878 var = *slot;
3879 gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
3880 && var->var_part[0].loc_chain->next == NULL);
3882 if (VALUE_RECURSED_INTO (cval))
3883 goto restart_with_cval;
3885 return 1;
3888 /* Bind one-part variables to the canonical value in an equivalence
3889 set. Not doing this causes dataflow convergence failure in rare
3890 circumstances, see PR42873. Unfortunately we can't do this
3891 efficiently as part of canonicalize_values_star, since we may not
3892 have determined or even seen the canonical value of a set when we
3893 get to a variable that references another member of the set. */
3896 canonicalize_vars_star (variable **slot, dataflow_set *set)
3898 variable *var = *slot;
3899 decl_or_value dv = var->dv;
3900 location_chain *node;
3901 rtx cval;
3902 decl_or_value cdv;
3903 variable **cslot;
3904 variable *cvar;
3905 location_chain *cnode;
3907 if (!var->onepart || var->onepart == ONEPART_VALUE)
3908 return 1;
3910 gcc_assert (var->n_var_parts == 1);
3912 node = var->var_part[0].loc_chain;
3914 if (GET_CODE (node->loc) != VALUE)
3915 return 1;
3917 gcc_assert (!node->next);
3918 cval = node->loc;
3920 /* Push values to the canonical one. */
3921 cdv = dv_from_value (cval);
3922 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3923 if (!cslot)
3924 return 1;
3925 cvar = *cslot;
3926 gcc_assert (cvar->n_var_parts == 1);
3928 cnode = cvar->var_part[0].loc_chain;
3930 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3931 that are not “more canonical” than it. */
3932 if (GET_CODE (cnode->loc) != VALUE
3933 || !canon_value_cmp (cnode->loc, cval))
3934 return 1;
3936 /* CVAL was found to be non-canonical. Change the variable to point
3937 to the canonical VALUE. */
3938 gcc_assert (!cnode->next);
3939 cval = cnode->loc;
3941 slot = set_slot_part (set, cval, slot, dv, 0,
3942 node->init, node->set_src);
3943 clobber_slot_part (set, cval, slot, 0, node->set_src);
3945 return 1;
3948 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3949 corresponding entry in DSM->src. Multi-part variables are combined
3950 with variable_union, whereas onepart dvs are combined with
3951 intersection. */
3953 static int
3954 variable_merge_over_cur (variable *s1var, struct dfset_merge *dsm)
3956 dataflow_set *dst = dsm->dst;
3957 variable **dstslot;
3958 variable *s2var, *dvar = NULL;
3959 decl_or_value dv = s1var->dv;
3960 onepart_enum onepart = s1var->onepart;
3961 rtx val;
3962 hashval_t dvhash;
3963 location_chain *node, **nodep;
3965 /* If the incoming onepart variable has an empty location list, then
3966 the intersection will be just as empty. For other variables,
3967 it's always union. */
3968 gcc_checking_assert (s1var->n_var_parts
3969 && s1var->var_part[0].loc_chain);
3971 if (!onepart)
3972 return variable_union (s1var, dst);
3974 gcc_checking_assert (s1var->n_var_parts == 1);
3976 dvhash = dv_htab_hash (dv);
3977 if (dv_is_value_p (dv))
3978 val = dv_as_value (dv);
3979 else
3980 val = NULL;
3982 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
3983 if (!s2var)
3985 dst_can_be_shared = false;
3986 return 1;
3989 dsm->src_onepart_cnt--;
3990 gcc_assert (s2var->var_part[0].loc_chain
3991 && s2var->onepart == onepart
3992 && s2var->n_var_parts == 1);
3994 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3995 if (dstslot)
3997 dvar = *dstslot;
3998 gcc_assert (dvar->refcount == 1
3999 && dvar->onepart == onepart
4000 && dvar->n_var_parts == 1);
4001 nodep = &dvar->var_part[0].loc_chain;
4003 else
4005 nodep = &node;
4006 node = NULL;
4009 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
4011 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
4012 dvhash, INSERT);
4013 *dstslot = dvar = s2var;
4014 dvar->refcount++;
4016 else
4018 dst_can_be_shared = false;
4020 intersect_loc_chains (val, nodep, dsm,
4021 s1var->var_part[0].loc_chain, s2var);
4023 if (!dstslot)
4025 if (node)
4027 dvar = onepart_pool_allocate (onepart);
4028 dvar->dv = dv;
4029 dvar->refcount = 1;
4030 dvar->n_var_parts = 1;
4031 dvar->onepart = onepart;
4032 dvar->in_changed_variables = false;
4033 dvar->var_part[0].loc_chain = node;
4034 dvar->var_part[0].cur_loc = NULL;
4035 if (onepart)
4036 VAR_LOC_1PAUX (dvar) = NULL;
4037 else
4038 VAR_PART_OFFSET (dvar, 0) = 0;
4040 dstslot
4041 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
4042 INSERT);
4043 gcc_assert (!*dstslot);
4044 *dstslot = dvar;
4046 else
4047 return 1;
4051 nodep = &dvar->var_part[0].loc_chain;
4052 while ((node = *nodep))
4054 location_chain **nextp = &node->next;
4056 if (GET_CODE (node->loc) == REG)
4058 attrs *list;
4060 for (list = dst->regs[REGNO (node->loc)]; list; list = list->next)
4061 if (GET_MODE (node->loc) == GET_MODE (list->loc)
4062 && dv_is_value_p (list->dv))
4063 break;
4065 if (!list)
4066 attrs_list_insert (&dst->regs[REGNO (node->loc)],
4067 dv, 0, node->loc);
4068 /* If this value became canonical for another value that had
4069 this register, we want to leave it alone. */
4070 else if (dv_as_value (list->dv) != val)
4072 dstslot = set_slot_part (dst, dv_as_value (list->dv),
4073 dstslot, dv, 0,
4074 node->init, NULL_RTX);
4075 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
4077 /* Since nextp points into the removed node, we can't
4078 use it. The pointer to the next node moved to nodep.
4079 However, if the variable we're walking is unshared
4080 during our walk, we'll keep walking the location list
4081 of the previously-shared variable, in which case the
4082 node won't have been removed, and we'll want to skip
4083 it. That's why we test *nodep here. */
4084 if (*nodep != node)
4085 nextp = nodep;
4088 else
4089 /* Canonicalization puts registers first, so we don't have to
4090 walk it all. */
4091 break;
4092 nodep = nextp;
4095 if (dvar != *dstslot)
4096 dvar = *dstslot;
4097 nodep = &dvar->var_part[0].loc_chain;
4099 if (val)
4101 /* Mark all referenced nodes for canonicalization, and make sure
4102 we have mutual equivalence links. */
4103 VALUE_RECURSED_INTO (val) = true;
4104 for (node = *nodep; node; node = node->next)
4105 if (GET_CODE (node->loc) == VALUE)
4107 VALUE_RECURSED_INTO (node->loc) = true;
4108 set_variable_part (dst, val, dv_from_value (node->loc), 0,
4109 node->init, NULL, INSERT);
4112 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4113 gcc_assert (*dstslot == dvar);
4114 canonicalize_values_star (dstslot, dst);
4115 gcc_checking_assert (dstslot
4116 == shared_hash_find_slot_noinsert_1 (dst->vars,
4117 dv, dvhash));
4118 dvar = *dstslot;
4120 else
4122 bool has_value = false, has_other = false;
4124 /* If we have one value and anything else, we're going to
4125 canonicalize this, so make sure all values have an entry in
4126 the table and are marked for canonicalization. */
4127 for (node = *nodep; node; node = node->next)
4129 if (GET_CODE (node->loc) == VALUE)
4131 /* If this was marked during register canonicalization,
4132 we know we have to canonicalize values. */
4133 if (has_value)
4134 has_other = true;
4135 has_value = true;
4136 if (has_other)
4137 break;
4139 else
4141 has_other = true;
4142 if (has_value)
4143 break;
4147 if (has_value && has_other)
4149 for (node = *nodep; node; node = node->next)
4151 if (GET_CODE (node->loc) == VALUE)
4153 decl_or_value dv = dv_from_value (node->loc);
4154 variable **slot = NULL;
4156 if (shared_hash_shared (dst->vars))
4157 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
4158 if (!slot)
4159 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
4160 INSERT);
4161 if (!*slot)
4163 variable *var = onepart_pool_allocate (ONEPART_VALUE);
4164 var->dv = dv;
4165 var->refcount = 1;
4166 var->n_var_parts = 1;
4167 var->onepart = ONEPART_VALUE;
4168 var->in_changed_variables = false;
4169 var->var_part[0].loc_chain = NULL;
4170 var->var_part[0].cur_loc = NULL;
4171 VAR_LOC_1PAUX (var) = NULL;
4172 *slot = var;
4175 VALUE_RECURSED_INTO (node->loc) = true;
4179 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4180 gcc_assert (*dstslot == dvar);
4181 canonicalize_values_star (dstslot, dst);
4182 gcc_checking_assert (dstslot
4183 == shared_hash_find_slot_noinsert_1 (dst->vars,
4184 dv, dvhash));
4185 dvar = *dstslot;
4189 if (!onepart_variable_different_p (dvar, s2var))
4191 variable_htab_free (dvar);
4192 *dstslot = dvar = s2var;
4193 dvar->refcount++;
4195 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
4197 variable_htab_free (dvar);
4198 *dstslot = dvar = s1var;
4199 dvar->refcount++;
4200 dst_can_be_shared = false;
4202 else
4203 dst_can_be_shared = false;
4205 return 1;
4208 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4209 multi-part variable. Unions of multi-part variables and
4210 intersections of one-part ones will be handled in
4211 variable_merge_over_cur(). */
4213 static int
4214 variable_merge_over_src (variable *s2var, struct dfset_merge *dsm)
4216 dataflow_set *dst = dsm->dst;
4217 decl_or_value dv = s2var->dv;
4219 if (!s2var->onepart)
4221 variable **dstp = shared_hash_find_slot (dst->vars, dv);
4222 *dstp = s2var;
4223 s2var->refcount++;
4224 return 1;
4227 dsm->src_onepart_cnt++;
4228 return 1;
4231 /* Combine dataflow set information from SRC2 into DST, using PDST
4232 to carry over information across passes. */
4234 static void
4235 dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
4237 dataflow_set cur = *dst;
4238 dataflow_set *src1 = &cur;
4239 struct dfset_merge dsm;
4240 int i;
4241 size_t src1_elems, src2_elems;
4242 variable_iterator_type hi;
4243 variable *var;
4245 src1_elems = shared_hash_htab (src1->vars)->elements ();
4246 src2_elems = shared_hash_htab (src2->vars)->elements ();
4247 dataflow_set_init (dst);
4248 dst->stack_adjust = cur.stack_adjust;
4249 shared_hash_destroy (dst->vars);
4250 dst->vars = new shared_hash;
4251 dst->vars->refcount = 1;
4252 dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems));
4254 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4255 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
4257 dsm.dst = dst;
4258 dsm.src = src2;
4259 dsm.cur = src1;
4260 dsm.src_onepart_cnt = 0;
4262 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars),
4263 var, variable, hi)
4264 variable_merge_over_src (var, &dsm);
4265 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars),
4266 var, variable, hi)
4267 variable_merge_over_cur (var, &dsm);
4269 if (dsm.src_onepart_cnt)
4270 dst_can_be_shared = false;
4272 dataflow_set_destroy (src1);
4275 /* Mark register equivalences. */
4277 static void
4278 dataflow_set_equiv_regs (dataflow_set *set)
4280 int i;
4281 attrs *list, **listp;
4283 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4285 rtx canon[NUM_MACHINE_MODES];
4287 /* If the list is empty or one entry, no need to canonicalize
4288 anything. */
4289 if (set->regs[i] == NULL || set->regs[i]->next == NULL)
4290 continue;
4292 memset (canon, 0, sizeof (canon));
4294 for (list = set->regs[i]; list; list = list->next)
4295 if (list->offset == 0 && dv_is_value_p (list->dv))
4297 rtx val = dv_as_value (list->dv);
4298 rtx *cvalp = &canon[(int)GET_MODE (val)];
4299 rtx cval = *cvalp;
4301 if (canon_value_cmp (val, cval))
4302 *cvalp = val;
4305 for (list = set->regs[i]; list; list = list->next)
4306 if (list->offset == 0 && dv_onepart_p (list->dv))
4308 rtx cval = canon[(int)GET_MODE (list->loc)];
4310 if (!cval)
4311 continue;
4313 if (dv_is_value_p (list->dv))
4315 rtx val = dv_as_value (list->dv);
4317 if (val == cval)
4318 continue;
4320 VALUE_RECURSED_INTO (val) = true;
4321 set_variable_part (set, val, dv_from_value (cval), 0,
4322 VAR_INIT_STATUS_INITIALIZED,
4323 NULL, NO_INSERT);
4326 VALUE_RECURSED_INTO (cval) = true;
4327 set_variable_part (set, cval, list->dv, 0,
4328 VAR_INIT_STATUS_INITIALIZED, NULL, NO_INSERT);
4331 for (listp = &set->regs[i]; (list = *listp);
4332 listp = list ? &list->next : listp)
4333 if (list->offset == 0 && dv_onepart_p (list->dv))
4335 rtx cval = canon[(int)GET_MODE (list->loc)];
4336 variable **slot;
4338 if (!cval)
4339 continue;
4341 if (dv_is_value_p (list->dv))
4343 rtx val = dv_as_value (list->dv);
4344 if (!VALUE_RECURSED_INTO (val))
4345 continue;
4348 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
4349 canonicalize_values_star (slot, set);
4350 if (*listp != list)
4351 list = NULL;
4356 /* Remove any redundant values in the location list of VAR, which must
4357 be unshared and 1-part. */
4359 static void
4360 remove_duplicate_values (variable *var)
4362 location_chain *node, **nodep;
4364 gcc_assert (var->onepart);
4365 gcc_assert (var->n_var_parts == 1);
4366 gcc_assert (var->refcount == 1);
4368 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
4370 if (GET_CODE (node->loc) == VALUE)
4372 if (VALUE_RECURSED_INTO (node->loc))
4374 /* Remove duplicate value node. */
4375 *nodep = node->next;
4376 delete node;
4377 continue;
4379 else
4380 VALUE_RECURSED_INTO (node->loc) = true;
4382 nodep = &node->next;
4385 for (node = var->var_part[0].loc_chain; node; node = node->next)
4386 if (GET_CODE (node->loc) == VALUE)
4388 gcc_assert (VALUE_RECURSED_INTO (node->loc));
4389 VALUE_RECURSED_INTO (node->loc) = false;
4394 /* Hash table iteration argument passed to variable_post_merge. */
4395 struct dfset_post_merge
4397 /* The new input set for the current block. */
4398 dataflow_set *set;
4399 /* Pointer to the permanent input set for the current block, or
4400 NULL. */
4401 dataflow_set **permp;
4404 /* Create values for incoming expressions associated with one-part
4405 variables that don't have value numbers for them. */
4408 variable_post_merge_new_vals (variable **slot, dfset_post_merge *dfpm)
4410 dataflow_set *set = dfpm->set;
4411 variable *var = *slot;
4412 location_chain *node;
4414 if (!var->onepart || !var->n_var_parts)
4415 return 1;
4417 gcc_assert (var->n_var_parts == 1);
4419 if (dv_is_decl_p (var->dv))
4421 bool check_dupes = false;
4423 restart:
4424 for (node = var->var_part[0].loc_chain; node; node = node->next)
4426 if (GET_CODE (node->loc) == VALUE)
4427 gcc_assert (!VALUE_RECURSED_INTO (node->loc));
4428 else if (GET_CODE (node->loc) == REG)
4430 attrs *att, **attp, **curp = NULL;
4432 if (var->refcount != 1)
4434 slot = unshare_variable (set, slot, var,
4435 VAR_INIT_STATUS_INITIALIZED);
4436 var = *slot;
4437 goto restart;
4440 for (attp = &set->regs[REGNO (node->loc)]; (att = *attp);
4441 attp = &att->next)
4442 if (att->offset == 0
4443 && GET_MODE (att->loc) == GET_MODE (node->loc))
4445 if (dv_is_value_p (att->dv))
4447 rtx cval = dv_as_value (att->dv);
4448 node->loc = cval;
4449 check_dupes = true;
4450 break;
4452 else if (dv_as_opaque (att->dv) == dv_as_opaque (var->dv))
4453 curp = attp;
4456 if (!curp)
4458 curp = attp;
4459 while (*curp)
4460 if ((*curp)->offset == 0
4461 && GET_MODE ((*curp)->loc) == GET_MODE (node->loc)
4462 && dv_as_opaque ((*curp)->dv) == dv_as_opaque (var->dv))
4463 break;
4464 else
4465 curp = &(*curp)->next;
4466 gcc_assert (*curp);
4469 if (!att)
4471 decl_or_value cdv;
4472 rtx cval;
4474 if (!*dfpm->permp)
4476 *dfpm->permp = XNEW (dataflow_set);
4477 dataflow_set_init (*dfpm->permp);
4480 for (att = (*dfpm->permp)->regs[REGNO (node->loc)];
4481 att; att = att->next)
4482 if (GET_MODE (att->loc) == GET_MODE (node->loc))
4484 gcc_assert (att->offset == 0
4485 && dv_is_value_p (att->dv));
4486 val_reset (set, att->dv);
4487 break;
4490 if (att)
4492 cdv = att->dv;
4493 cval = dv_as_value (cdv);
4495 else
4497 /* Create a unique value to hold this register,
4498 that ought to be found and reused in
4499 subsequent rounds. */
4500 cselib_val *v;
4501 gcc_assert (!cselib_lookup (node->loc,
4502 GET_MODE (node->loc), 0,
4503 VOIDmode));
4504 v = cselib_lookup (node->loc, GET_MODE (node->loc), 1,
4505 VOIDmode);
4506 cselib_preserve_value (v);
4507 cselib_invalidate_rtx (node->loc);
4508 cval = v->val_rtx;
4509 cdv = dv_from_value (cval);
4510 if (dump_file)
4511 fprintf (dump_file,
4512 "Created new value %u:%u for reg %i\n",
4513 v->uid, v->hash, REGNO (node->loc));
4516 var_reg_decl_set (*dfpm->permp, node->loc,
4517 VAR_INIT_STATUS_INITIALIZED,
4518 cdv, 0, NULL, INSERT);
4520 node->loc = cval;
4521 check_dupes = true;
4524 /* Remove attribute referring to the decl, which now
4525 uses the value for the register, already existing or
4526 to be added when we bring perm in. */
4527 att = *curp;
4528 *curp = att->next;
4529 delete att;
4533 if (check_dupes)
4534 remove_duplicate_values (var);
4537 return 1;
4540 /* Reset values in the permanent set that are not associated with the
4541 chosen expression. */
4544 variable_post_merge_perm_vals (variable **pslot, dfset_post_merge *dfpm)
4546 dataflow_set *set = dfpm->set;
4547 variable *pvar = *pslot, *var;
4548 location_chain *pnode;
4549 decl_or_value dv;
4550 attrs *att;
4552 gcc_assert (dv_is_value_p (pvar->dv)
4553 && pvar->n_var_parts == 1);
4554 pnode = pvar->var_part[0].loc_chain;
4555 gcc_assert (pnode
4556 && !pnode->next
4557 && REG_P (pnode->loc));
4559 dv = pvar->dv;
4561 var = shared_hash_find (set->vars, dv);
4562 if (var)
4564 /* Although variable_post_merge_new_vals may have made decls
4565 non-star-canonical, values that pre-existed in canonical form
4566 remain canonical, and newly-created values reference a single
4567 REG, so they are canonical as well. Since VAR has the
4568 location list for a VALUE, using find_loc_in_1pdv for it is
4569 fine, since VALUEs don't map back to DECLs. */
4570 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
4571 return 1;
4572 val_reset (set, dv);
4575 for (att = set->regs[REGNO (pnode->loc)]; att; att = att->next)
4576 if (att->offset == 0
4577 && GET_MODE (att->loc) == GET_MODE (pnode->loc)
4578 && dv_is_value_p (att->dv))
4579 break;
4581 /* If there is a value associated with this register already, create
4582 an equivalence. */
4583 if (att && dv_as_value (att->dv) != dv_as_value (dv))
4585 rtx cval = dv_as_value (att->dv);
4586 set_variable_part (set, cval, dv, 0, pnode->init, NULL, INSERT);
4587 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
4588 NULL, INSERT);
4590 else if (!att)
4592 attrs_list_insert (&set->regs[REGNO (pnode->loc)],
4593 dv, 0, pnode->loc);
4594 variable_union (pvar, set);
4597 return 1;
4600 /* Just checking stuff and registering register attributes for
4601 now. */
4603 static void
4604 dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
4606 struct dfset_post_merge dfpm;
4608 dfpm.set = set;
4609 dfpm.permp = permp;
4611 shared_hash_htab (set->vars)
4612 ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm);
4613 if (*permp)
4614 shared_hash_htab ((*permp)->vars)
4615 ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm);
4616 shared_hash_htab (set->vars)
4617 ->traverse <dataflow_set *, canonicalize_values_star> (set);
4618 shared_hash_htab (set->vars)
4619 ->traverse <dataflow_set *, canonicalize_vars_star> (set);
4622 /* Return a node whose loc is a MEM that refers to EXPR in the
4623 location list of a one-part variable or value VAR, or in that of
4624 any values recursively mentioned in the location lists. */
4626 static location_chain *
4627 find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars)
4629 location_chain *node;
4630 decl_or_value dv;
4631 variable *var;
4632 location_chain *where = NULL;
4634 if (!val)
4635 return NULL;
4637 gcc_assert (GET_CODE (val) == VALUE
4638 && !VALUE_RECURSED_INTO (val));
4640 dv = dv_from_value (val);
4641 var = vars->find_with_hash (dv, dv_htab_hash (dv));
4643 if (!var)
4644 return NULL;
4646 gcc_assert (var->onepart);
4648 if (!var->n_var_parts)
4649 return NULL;
4651 VALUE_RECURSED_INTO (val) = true;
4653 for (node = var->var_part[0].loc_chain; node; node = node->next)
4654 if (MEM_P (node->loc)
4655 && MEM_EXPR (node->loc) == expr
4656 && int_mem_offset (node->loc) == 0)
4658 where = node;
4659 break;
4661 else if (GET_CODE (node->loc) == VALUE
4662 && !VALUE_RECURSED_INTO (node->loc)
4663 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
4664 break;
4666 VALUE_RECURSED_INTO (val) = false;
4668 return where;
4671 /* Return TRUE if the value of MEM may vary across a call. */
4673 static bool
4674 mem_dies_at_call (rtx mem)
4676 tree expr = MEM_EXPR (mem);
4677 tree decl;
4679 if (!expr)
4680 return true;
4682 decl = get_base_address (expr);
4684 if (!decl)
4685 return true;
4687 if (!DECL_P (decl))
4688 return true;
4690 return (may_be_aliased (decl)
4691 || (!TREE_READONLY (decl) && is_global_var (decl)));
4694 /* Remove all MEMs from the location list of a hash table entry for a
4695 one-part variable, except those whose MEM attributes map back to
4696 the variable itself, directly or within a VALUE. */
4699 dataflow_set_preserve_mem_locs (variable **slot, dataflow_set *set)
4701 variable *var = *slot;
4703 if (var->onepart == ONEPART_VDECL || var->onepart == ONEPART_DEXPR)
4705 tree decl = dv_as_decl (var->dv);
4706 location_chain *loc, **locp;
4707 bool changed = false;
4709 if (!var->n_var_parts)
4710 return 1;
4712 gcc_assert (var->n_var_parts == 1);
4714 if (shared_var_p (var, set->vars))
4716 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4718 /* We want to remove dying MEMs that don't refer to DECL. */
4719 if (GET_CODE (loc->loc) == MEM
4720 && (MEM_EXPR (loc->loc) != decl
4721 || int_mem_offset (loc->loc) != 0)
4722 && mem_dies_at_call (loc->loc))
4723 break;
4724 /* We want to move here MEMs that do refer to DECL. */
4725 else if (GET_CODE (loc->loc) == VALUE
4726 && find_mem_expr_in_1pdv (decl, loc->loc,
4727 shared_hash_htab (set->vars)))
4728 break;
4731 if (!loc)
4732 return 1;
4734 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4735 var = *slot;
4736 gcc_assert (var->n_var_parts == 1);
4739 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4740 loc; loc = *locp)
4742 rtx old_loc = loc->loc;
4743 if (GET_CODE (old_loc) == VALUE)
4745 location_chain *mem_node
4746 = find_mem_expr_in_1pdv (decl, loc->loc,
4747 shared_hash_htab (set->vars));
4749 /* ??? This picks up only one out of multiple MEMs that
4750 refer to the same variable. Do we ever need to be
4751 concerned about dealing with more than one, or, given
4752 that they should all map to the same variable
4753 location, their addresses will have been merged and
4754 they will be regarded as equivalent? */
4755 if (mem_node)
4757 loc->loc = mem_node->loc;
4758 loc->set_src = mem_node->set_src;
4759 loc->init = MIN (loc->init, mem_node->init);
4763 if (GET_CODE (loc->loc) != MEM
4764 || (MEM_EXPR (loc->loc) == decl
4765 && int_mem_offset (loc->loc) == 0)
4766 || !mem_dies_at_call (loc->loc))
4768 if (old_loc != loc->loc && emit_notes)
4770 if (old_loc == var->var_part[0].cur_loc)
4772 changed = true;
4773 var->var_part[0].cur_loc = NULL;
4776 locp = &loc->next;
4777 continue;
4780 if (emit_notes)
4782 if (old_loc == var->var_part[0].cur_loc)
4784 changed = true;
4785 var->var_part[0].cur_loc = NULL;
4788 *locp = loc->next;
4789 delete loc;
4792 if (!var->var_part[0].loc_chain)
4794 var->n_var_parts--;
4795 changed = true;
4797 if (changed)
4798 variable_was_changed (var, set);
4801 return 1;
4804 /* Remove all MEMs from the location list of a hash table entry for a
4805 onepart variable. */
4808 dataflow_set_remove_mem_locs (variable **slot, dataflow_set *set)
4810 variable *var = *slot;
4812 if (var->onepart != NOT_ONEPART)
4814 location_chain *loc, **locp;
4815 bool changed = false;
4816 rtx cur_loc;
4818 gcc_assert (var->n_var_parts == 1);
4820 if (shared_var_p (var, set->vars))
4822 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4823 if (GET_CODE (loc->loc) == MEM
4824 && mem_dies_at_call (loc->loc))
4825 break;
4827 if (!loc)
4828 return 1;
4830 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4831 var = *slot;
4832 gcc_assert (var->n_var_parts == 1);
4835 if (VAR_LOC_1PAUX (var))
4836 cur_loc = VAR_LOC_FROM (var);
4837 else
4838 cur_loc = var->var_part[0].cur_loc;
4840 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4841 loc; loc = *locp)
4843 if (GET_CODE (loc->loc) != MEM
4844 || !mem_dies_at_call (loc->loc))
4846 locp = &loc->next;
4847 continue;
4850 *locp = loc->next;
4851 /* If we have deleted the location which was last emitted
4852 we have to emit new location so add the variable to set
4853 of changed variables. */
4854 if (cur_loc == loc->loc)
4856 changed = true;
4857 var->var_part[0].cur_loc = NULL;
4858 if (VAR_LOC_1PAUX (var))
4859 VAR_LOC_FROM (var) = NULL;
4861 delete loc;
4864 if (!var->var_part[0].loc_chain)
4866 var->n_var_parts--;
4867 changed = true;
4869 if (changed)
4870 variable_was_changed (var, set);
4873 return 1;
4876 /* Remove all variable-location information about call-clobbered
4877 registers, as well as associations between MEMs and VALUEs. */
4879 static void
4880 dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
4882 unsigned int r;
4883 hard_reg_set_iterator hrsi;
4884 HARD_REG_SET invalidated_regs;
4886 get_call_reg_set_usage (call_insn, &invalidated_regs,
4887 regs_invalidated_by_call);
4889 EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
4890 var_regno_delete (set, r);
4892 if (MAY_HAVE_DEBUG_BIND_INSNS)
4894 set->traversed_vars = set->vars;
4895 shared_hash_htab (set->vars)
4896 ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
4897 set->traversed_vars = set->vars;
4898 shared_hash_htab (set->vars)
4899 ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set);
4900 set->traversed_vars = NULL;
4904 static bool
4905 variable_part_different_p (variable_part *vp1, variable_part *vp2)
4907 location_chain *lc1, *lc2;
4909 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4911 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4913 if (REG_P (lc1->loc) && REG_P (lc2->loc))
4915 if (REGNO (lc1->loc) == REGNO (lc2->loc))
4916 break;
4918 if (rtx_equal_p (lc1->loc, lc2->loc))
4919 break;
4921 if (!lc2)
4922 return true;
4924 return false;
4927 /* Return true if one-part variables VAR1 and VAR2 are different.
4928 They must be in canonical order. */
4930 static bool
4931 onepart_variable_different_p (variable *var1, variable *var2)
4933 location_chain *lc1, *lc2;
4935 if (var1 == var2)
4936 return false;
4938 gcc_assert (var1->n_var_parts == 1
4939 && var2->n_var_parts == 1);
4941 lc1 = var1->var_part[0].loc_chain;
4942 lc2 = var2->var_part[0].loc_chain;
4944 gcc_assert (lc1 && lc2);
4946 while (lc1 && lc2)
4948 if (loc_cmp (lc1->loc, lc2->loc))
4949 return true;
4950 lc1 = lc1->next;
4951 lc2 = lc2->next;
4954 return lc1 != lc2;
4957 /* Return true if one-part variables VAR1 and VAR2 are different.
4958 They must be in canonical order. */
4960 static void
4961 dump_onepart_variable_differences (variable *var1, variable *var2)
4963 location_chain *lc1, *lc2;
4965 gcc_assert (var1 != var2);
4966 gcc_assert (dump_file);
4967 gcc_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv));
4968 gcc_assert (var1->n_var_parts == 1
4969 && var2->n_var_parts == 1);
4971 lc1 = var1->var_part[0].loc_chain;
4972 lc2 = var2->var_part[0].loc_chain;
4974 gcc_assert (lc1 && lc2);
4976 while (lc1 && lc2)
4978 switch (loc_cmp (lc1->loc, lc2->loc))
4980 case -1:
4981 fprintf (dump_file, "removed: ");
4982 print_rtl_single (dump_file, lc1->loc);
4983 lc1 = lc1->next;
4984 continue;
4985 case 0:
4986 break;
4987 case 1:
4988 fprintf (dump_file, "added: ");
4989 print_rtl_single (dump_file, lc2->loc);
4990 lc2 = lc2->next;
4991 continue;
4992 default:
4993 gcc_unreachable ();
4995 lc1 = lc1->next;
4996 lc2 = lc2->next;
4999 while (lc1)
5001 fprintf (dump_file, "removed: ");
5002 print_rtl_single (dump_file, lc1->loc);
5003 lc1 = lc1->next;
5006 while (lc2)
5008 fprintf (dump_file, "added: ");
5009 print_rtl_single (dump_file, lc2->loc);
5010 lc2 = lc2->next;
5014 /* Return true if variables VAR1 and VAR2 are different. */
5016 static bool
5017 variable_different_p (variable *var1, variable *var2)
5019 int i;
5021 if (var1 == var2)
5022 return false;
5024 if (var1->onepart != var2->onepart)
5025 return true;
5027 if (var1->n_var_parts != var2->n_var_parts)
5028 return true;
5030 if (var1->onepart && var1->n_var_parts)
5032 gcc_checking_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv)
5033 && var1->n_var_parts == 1);
5034 /* One-part values have locations in a canonical order. */
5035 return onepart_variable_different_p (var1, var2);
5038 for (i = 0; i < var1->n_var_parts; i++)
5040 if (VAR_PART_OFFSET (var1, i) != VAR_PART_OFFSET (var2, i))
5041 return true;
5042 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
5043 return true;
5044 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
5045 return true;
5047 return false;
5050 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5052 static bool
5053 dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
5055 variable_iterator_type hi;
5056 variable *var1;
5057 bool diffound = false;
5058 bool details = (dump_file && (dump_flags & TDF_DETAILS));
5060 #define RETRUE \
5061 do \
5063 if (!details) \
5064 return true; \
5065 else \
5066 diffound = true; \
5068 while (0)
5070 if (old_set->vars == new_set->vars)
5071 return false;
5073 if (shared_hash_htab (old_set->vars)->elements ()
5074 != shared_hash_htab (new_set->vars)->elements ())
5075 RETRUE;
5077 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars),
5078 var1, variable, hi)
5080 variable_table_type *htab = shared_hash_htab (new_set->vars);
5081 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5083 if (!var2)
5085 if (dump_file && (dump_flags & TDF_DETAILS))
5087 fprintf (dump_file, "dataflow difference found: removal of:\n");
5088 dump_var (var1);
5090 RETRUE;
5092 else if (variable_different_p (var1, var2))
5094 if (details)
5096 fprintf (dump_file, "dataflow difference found: "
5097 "old and new follow:\n");
5098 dump_var (var1);
5099 if (dv_onepart_p (var1->dv))
5100 dump_onepart_variable_differences (var1, var2);
5101 dump_var (var2);
5103 RETRUE;
5107 /* There's no need to traverse the second hashtab unless we want to
5108 print the details. If both have the same number of elements and
5109 the second one had all entries found in the first one, then the
5110 second can't have any extra entries. */
5111 if (!details)
5112 return diffound;
5114 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set->vars),
5115 var1, variable, hi)
5117 variable_table_type *htab = shared_hash_htab (old_set->vars);
5118 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5119 if (!var2)
5121 if (details)
5123 fprintf (dump_file, "dataflow difference found: addition of:\n");
5124 dump_var (var1);
5126 RETRUE;
5130 #undef RETRUE
5132 return diffound;
5135 /* Free the contents of dataflow set SET. */
5137 static void
5138 dataflow_set_destroy (dataflow_set *set)
5140 int i;
5142 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5143 attrs_list_clear (&set->regs[i]);
5145 shared_hash_destroy (set->vars);
5146 set->vars = NULL;
5149 /* Return true if T is a tracked parameter with non-degenerate record type. */
5151 static bool
5152 tracked_record_parameter_p (tree t)
5154 if (TREE_CODE (t) != PARM_DECL)
5155 return false;
5157 if (DECL_MODE (t) == BLKmode)
5158 return false;
5160 tree type = TREE_TYPE (t);
5161 if (TREE_CODE (type) != RECORD_TYPE)
5162 return false;
5164 if (TYPE_FIELDS (type) == NULL_TREE
5165 || DECL_CHAIN (TYPE_FIELDS (type)) == NULL_TREE)
5166 return false;
5168 return true;
5171 /* Shall EXPR be tracked? */
5173 static bool
5174 track_expr_p (tree expr, bool need_rtl)
5176 rtx decl_rtl;
5177 tree realdecl;
5179 if (TREE_CODE (expr) == DEBUG_EXPR_DECL)
5180 return DECL_RTL_SET_P (expr);
5182 /* If EXPR is not a parameter or a variable do not track it. */
5183 if (!VAR_P (expr) && TREE_CODE (expr) != PARM_DECL)
5184 return 0;
5186 /* It also must have a name... */
5187 if (!DECL_NAME (expr) && need_rtl)
5188 return 0;
5190 /* ... and a RTL assigned to it. */
5191 decl_rtl = DECL_RTL_IF_SET (expr);
5192 if (!decl_rtl && need_rtl)
5193 return 0;
5195 /* If this expression is really a debug alias of some other declaration, we
5196 don't need to track this expression if the ultimate declaration is
5197 ignored. */
5198 realdecl = expr;
5199 if (VAR_P (realdecl) && DECL_HAS_DEBUG_EXPR_P (realdecl))
5201 realdecl = DECL_DEBUG_EXPR (realdecl);
5202 if (!DECL_P (realdecl))
5204 if (handled_component_p (realdecl)
5205 || (TREE_CODE (realdecl) == MEM_REF
5206 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5208 HOST_WIDE_INT bitsize, bitpos;
5209 bool reverse;
5210 tree innerdecl
5211 = get_ref_base_and_extent_hwi (realdecl, &bitpos,
5212 &bitsize, &reverse);
5213 if (!innerdecl
5214 || !DECL_P (innerdecl)
5215 || DECL_IGNORED_P (innerdecl)
5216 /* Do not track declarations for parts of tracked record
5217 parameters since we want to track them as a whole. */
5218 || tracked_record_parameter_p (innerdecl)
5219 || TREE_STATIC (innerdecl)
5220 || bitsize == 0
5221 || bitpos + bitsize > 256)
5222 return 0;
5223 else
5224 realdecl = expr;
5226 else
5227 return 0;
5231 /* Do not track EXPR if REALDECL it should be ignored for debugging
5232 purposes. */
5233 if (DECL_IGNORED_P (realdecl))
5234 return 0;
5236 /* Do not track global variables until we are able to emit correct location
5237 list for them. */
5238 if (TREE_STATIC (realdecl))
5239 return 0;
5241 /* When the EXPR is a DECL for alias of some variable (see example)
5242 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5243 DECL_RTL contains SYMBOL_REF.
5245 Example:
5246 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5247 char **_dl_argv;
5249 if (decl_rtl && MEM_P (decl_rtl)
5250 && contains_symbol_ref_p (XEXP (decl_rtl, 0)))
5251 return 0;
5253 /* If RTX is a memory it should not be very large (because it would be
5254 an array or struct). */
5255 if (decl_rtl && MEM_P (decl_rtl))
5257 /* Do not track structures and arrays. */
5258 if ((GET_MODE (decl_rtl) == BLKmode
5259 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
5260 && !tracked_record_parameter_p (realdecl))
5261 return 0;
5262 if (MEM_SIZE_KNOWN_P (decl_rtl)
5263 && maybe_gt (MEM_SIZE (decl_rtl), MAX_VAR_PARTS))
5264 return 0;
5267 DECL_CHANGED (expr) = 0;
5268 DECL_CHANGED (realdecl) = 0;
5269 return 1;
5272 /* Determine whether a given LOC refers to the same variable part as
5273 EXPR+OFFSET. */
5275 static bool
5276 same_variable_part_p (rtx loc, tree expr, poly_int64 offset)
5278 tree expr2;
5279 poly_int64 offset2;
5281 if (! DECL_P (expr))
5282 return false;
5284 if (REG_P (loc))
5286 expr2 = REG_EXPR (loc);
5287 offset2 = REG_OFFSET (loc);
5289 else if (MEM_P (loc))
5291 expr2 = MEM_EXPR (loc);
5292 offset2 = int_mem_offset (loc);
5294 else
5295 return false;
5297 if (! expr2 || ! DECL_P (expr2))
5298 return false;
5300 expr = var_debug_decl (expr);
5301 expr2 = var_debug_decl (expr2);
5303 return (expr == expr2 && known_eq (offset, offset2));
5306 /* LOC is a REG or MEM that we would like to track if possible.
5307 If EXPR is null, we don't know what expression LOC refers to,
5308 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5309 LOC is an lvalue register.
5311 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5312 is something we can track. When returning true, store the mode of
5313 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5314 from EXPR in *OFFSET_OUT (if nonnull). */
5316 static bool
5317 track_loc_p (rtx loc, tree expr, poly_int64 offset, bool store_reg_p,
5318 machine_mode *mode_out, HOST_WIDE_INT *offset_out)
5320 machine_mode mode;
5322 if (expr == NULL || !track_expr_p (expr, true))
5323 return false;
5325 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5326 whole subreg, but only the old inner part is really relevant. */
5327 mode = GET_MODE (loc);
5328 if (REG_P (loc) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc)))
5330 machine_mode pseudo_mode;
5332 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc));
5333 if (paradoxical_subreg_p (mode, pseudo_mode))
5335 offset += byte_lowpart_offset (pseudo_mode, mode);
5336 mode = pseudo_mode;
5340 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5341 Do the same if we are storing to a register and EXPR occupies
5342 the whole of register LOC; in that case, the whole of EXPR is
5343 being changed. We exclude complex modes from the second case
5344 because the real and imaginary parts are represented as separate
5345 pseudo registers, even if the whole complex value fits into one
5346 hard register. */
5347 if ((paradoxical_subreg_p (mode, DECL_MODE (expr))
5348 || (store_reg_p
5349 && !COMPLEX_MODE_P (DECL_MODE (expr))
5350 && hard_regno_nregs (REGNO (loc), DECL_MODE (expr)) == 1))
5351 && known_eq (offset + byte_lowpart_offset (DECL_MODE (expr), mode), 0))
5353 mode = DECL_MODE (expr);
5354 offset = 0;
5357 HOST_WIDE_INT const_offset;
5358 if (!track_offset_p (offset, &const_offset))
5359 return false;
5361 if (mode_out)
5362 *mode_out = mode;
5363 if (offset_out)
5364 *offset_out = const_offset;
5365 return true;
5368 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5369 want to track. When returning nonnull, make sure that the attributes
5370 on the returned value are updated. */
5372 static rtx
5373 var_lowpart (machine_mode mode, rtx loc)
5375 unsigned int regno;
5377 if (GET_MODE (loc) == mode)
5378 return loc;
5380 if (!REG_P (loc) && !MEM_P (loc))
5381 return NULL;
5383 poly_uint64 offset = byte_lowpart_offset (mode, GET_MODE (loc));
5385 if (MEM_P (loc))
5386 return adjust_address_nv (loc, mode, offset);
5388 poly_uint64 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
5389 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
5390 reg_offset, mode);
5391 return gen_rtx_REG_offset (loc, mode, regno, offset);
5394 /* Carry information about uses and stores while walking rtx. */
5396 struct count_use_info
5398 /* The insn where the RTX is. */
5399 rtx_insn *insn;
5401 /* The basic block where insn is. */
5402 basic_block bb;
5404 /* The array of n_sets sets in the insn, as determined by cselib. */
5405 struct cselib_set *sets;
5406 int n_sets;
5408 /* True if we're counting stores, false otherwise. */
5409 bool store_p;
5412 /* Find a VALUE corresponding to X. */
5414 static inline cselib_val *
5415 find_use_val (rtx x, machine_mode mode, struct count_use_info *cui)
5417 int i;
5419 if (cui->sets)
5421 /* This is called after uses are set up and before stores are
5422 processed by cselib, so it's safe to look up srcs, but not
5423 dsts. So we look up expressions that appear in srcs or in
5424 dest expressions, but we search the sets array for dests of
5425 stores. */
5426 if (cui->store_p)
5428 /* Some targets represent memset and memcpy patterns
5429 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5430 (set (mem:BLK ...) (const_int ...)) or
5431 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5432 in that case, otherwise we end up with mode mismatches. */
5433 if (mode == BLKmode && MEM_P (x))
5434 return NULL;
5435 for (i = 0; i < cui->n_sets; i++)
5436 if (cui->sets[i].dest == x)
5437 return cui->sets[i].src_elt;
5439 else
5440 return cselib_lookup (x, mode, 0, VOIDmode);
5443 return NULL;
5446 /* Replace all registers and addresses in an expression with VALUE
5447 expressions that map back to them, unless the expression is a
5448 register. If no mapping is or can be performed, returns NULL. */
5450 static rtx
5451 replace_expr_with_values (rtx loc)
5453 if (REG_P (loc) || GET_CODE (loc) == ENTRY_VALUE)
5454 return NULL;
5455 else if (MEM_P (loc))
5457 cselib_val *addr = cselib_lookup (XEXP (loc, 0),
5458 get_address_mode (loc), 0,
5459 GET_MODE (loc));
5460 if (addr)
5461 return replace_equiv_address_nv (loc, addr->val_rtx);
5462 else
5463 return NULL;
5465 else
5466 return cselib_subst_to_values (loc, VOIDmode);
5469 /* Return true if X contains a DEBUG_EXPR. */
5471 static bool
5472 rtx_debug_expr_p (const_rtx x)
5474 subrtx_iterator::array_type array;
5475 FOR_EACH_SUBRTX (iter, array, x, ALL)
5476 if (GET_CODE (*iter) == DEBUG_EXPR)
5477 return true;
5478 return false;
5481 /* Determine what kind of micro operation to choose for a USE. Return
5482 MO_CLOBBER if no micro operation is to be generated. */
5484 static enum micro_operation_type
5485 use_type (rtx loc, struct count_use_info *cui, machine_mode *modep)
5487 tree expr;
5489 if (cui && cui->sets)
5491 if (GET_CODE (loc) == VAR_LOCATION)
5493 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc), false))
5495 rtx ploc = PAT_VAR_LOCATION_LOC (loc);
5496 if (! VAR_LOC_UNKNOWN_P (ploc))
5498 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc), 1,
5499 VOIDmode);
5501 /* ??? flag_float_store and volatile mems are never
5502 given values, but we could in theory use them for
5503 locations. */
5504 gcc_assert (val || 1);
5506 return MO_VAL_LOC;
5508 else
5509 return MO_CLOBBER;
5512 if (REG_P (loc) || MEM_P (loc))
5514 if (modep)
5515 *modep = GET_MODE (loc);
5516 if (cui->store_p)
5518 if (REG_P (loc)
5519 || (find_use_val (loc, GET_MODE (loc), cui)
5520 && cselib_lookup (XEXP (loc, 0),
5521 get_address_mode (loc), 0,
5522 GET_MODE (loc))))
5523 return MO_VAL_SET;
5525 else
5527 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5529 if (val && !cselib_preserved_value_p (val))
5530 return MO_VAL_USE;
5535 if (REG_P (loc))
5537 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER);
5539 if (loc == cfa_base_rtx)
5540 return MO_CLOBBER;
5541 expr = REG_EXPR (loc);
5543 if (!expr)
5544 return MO_USE_NO_VAR;
5545 else if (target_for_debug_bind (var_debug_decl (expr)))
5546 return MO_CLOBBER;
5547 else if (track_loc_p (loc, expr, REG_OFFSET (loc),
5548 false, modep, NULL))
5549 return MO_USE;
5550 else
5551 return MO_USE_NO_VAR;
5553 else if (MEM_P (loc))
5555 expr = MEM_EXPR (loc);
5557 if (!expr)
5558 return MO_CLOBBER;
5559 else if (target_for_debug_bind (var_debug_decl (expr)))
5560 return MO_CLOBBER;
5561 else if (track_loc_p (loc, expr, int_mem_offset (loc),
5562 false, modep, NULL)
5563 /* Multi-part variables shouldn't refer to one-part
5564 variable names such as VALUEs (never happens) or
5565 DEBUG_EXPRs (only happens in the presence of debug
5566 insns). */
5567 && (!MAY_HAVE_DEBUG_BIND_INSNS
5568 || !rtx_debug_expr_p (XEXP (loc, 0))))
5569 return MO_USE;
5570 else
5571 return MO_CLOBBER;
5574 return MO_CLOBBER;
5577 /* Log to OUT information about micro-operation MOPT involving X in
5578 INSN of BB. */
5580 static inline void
5581 log_op_type (rtx x, basic_block bb, rtx_insn *insn,
5582 enum micro_operation_type mopt, FILE *out)
5584 fprintf (out, "bb %i op %i insn %i %s ",
5585 bb->index, VTI (bb)->mos.length (),
5586 INSN_UID (insn), micro_operation_type_name[mopt]);
5587 print_inline_rtx (out, x, 2);
5588 fputc ('\n', out);
5591 /* Tell whether the CONCAT used to holds a VALUE and its location
5592 needs value resolution, i.e., an attempt of mapping the location
5593 back to other incoming values. */
5594 #define VAL_NEEDS_RESOLUTION(x) \
5595 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5596 /* Whether the location in the CONCAT is a tracked expression, that
5597 should also be handled like a MO_USE. */
5598 #define VAL_HOLDS_TRACK_EXPR(x) \
5599 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5600 /* Whether the location in the CONCAT should be handled like a MO_COPY
5601 as well. */
5602 #define VAL_EXPR_IS_COPIED(x) \
5603 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5604 /* Whether the location in the CONCAT should be handled like a
5605 MO_CLOBBER as well. */
5606 #define VAL_EXPR_IS_CLOBBERED(x) \
5607 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5609 /* All preserved VALUEs. */
5610 static vec<rtx> preserved_values;
5612 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5614 static void
5615 preserve_value (cselib_val *val)
5617 cselib_preserve_value (val);
5618 preserved_values.safe_push (val->val_rtx);
5621 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5622 any rtxes not suitable for CONST use not replaced by VALUEs
5623 are discovered. */
5625 static bool
5626 non_suitable_const (const_rtx x)
5628 subrtx_iterator::array_type array;
5629 FOR_EACH_SUBRTX (iter, array, x, ALL)
5631 const_rtx x = *iter;
5632 switch (GET_CODE (x))
5634 case REG:
5635 case DEBUG_EXPR:
5636 case PC:
5637 case SCRATCH:
5638 case CC0:
5639 case ASM_INPUT:
5640 case ASM_OPERANDS:
5641 return true;
5642 case MEM:
5643 if (!MEM_READONLY_P (x))
5644 return true;
5645 break;
5646 default:
5647 break;
5650 return false;
5653 /* Add uses (register and memory references) LOC which will be tracked
5654 to VTI (bb)->mos. */
5656 static void
5657 add_uses (rtx loc, struct count_use_info *cui)
5659 machine_mode mode = VOIDmode;
5660 enum micro_operation_type type = use_type (loc, cui, &mode);
5662 if (type != MO_CLOBBER)
5664 basic_block bb = cui->bb;
5665 micro_operation mo;
5667 mo.type = type;
5668 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
5669 mo.insn = cui->insn;
5671 if (type == MO_VAL_LOC)
5673 rtx oloc = loc;
5674 rtx vloc = PAT_VAR_LOCATION_LOC (oloc);
5675 cselib_val *val;
5677 gcc_assert (cui->sets);
5679 if (MEM_P (vloc)
5680 && !REG_P (XEXP (vloc, 0))
5681 && !MEM_P (XEXP (vloc, 0)))
5683 rtx mloc = vloc;
5684 machine_mode address_mode = get_address_mode (mloc);
5685 cselib_val *val
5686 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5687 GET_MODE (mloc));
5689 if (val && !cselib_preserved_value_p (val))
5690 preserve_value (val);
5693 if (CONSTANT_P (vloc)
5694 && (GET_CODE (vloc) != CONST || non_suitable_const (vloc)))
5695 /* For constants don't look up any value. */;
5696 else if (!VAR_LOC_UNKNOWN_P (vloc) && !unsuitable_loc (vloc)
5697 && (val = find_use_val (vloc, GET_MODE (oloc), cui)))
5699 machine_mode mode2;
5700 enum micro_operation_type type2;
5701 rtx nloc = NULL;
5702 bool resolvable = REG_P (vloc) || MEM_P (vloc);
5704 if (resolvable)
5705 nloc = replace_expr_with_values (vloc);
5707 if (nloc)
5709 oloc = shallow_copy_rtx (oloc);
5710 PAT_VAR_LOCATION_LOC (oloc) = nloc;
5713 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc);
5715 type2 = use_type (vloc, 0, &mode2);
5717 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5718 || type2 == MO_CLOBBER);
5720 if (type2 == MO_CLOBBER
5721 && !cselib_preserved_value_p (val))
5723 VAL_NEEDS_RESOLUTION (oloc) = resolvable;
5724 preserve_value (val);
5727 else if (!VAR_LOC_UNKNOWN_P (vloc))
5729 oloc = shallow_copy_rtx (oloc);
5730 PAT_VAR_LOCATION_LOC (oloc) = gen_rtx_UNKNOWN_VAR_LOC ();
5733 mo.u.loc = oloc;
5735 else if (type == MO_VAL_USE)
5737 machine_mode mode2 = VOIDmode;
5738 enum micro_operation_type type2;
5739 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5740 rtx vloc, oloc = loc, nloc;
5742 gcc_assert (cui->sets);
5744 if (MEM_P (oloc)
5745 && !REG_P (XEXP (oloc, 0))
5746 && !MEM_P (XEXP (oloc, 0)))
5748 rtx mloc = oloc;
5749 machine_mode address_mode = get_address_mode (mloc);
5750 cselib_val *val
5751 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5752 GET_MODE (mloc));
5754 if (val && !cselib_preserved_value_p (val))
5755 preserve_value (val);
5758 type2 = use_type (loc, 0, &mode2);
5760 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5761 || type2 == MO_CLOBBER);
5763 if (type2 == MO_USE)
5764 vloc = var_lowpart (mode2, loc);
5765 else
5766 vloc = oloc;
5768 /* The loc of a MO_VAL_USE may have two forms:
5770 (concat val src): val is at src, a value-based
5771 representation.
5773 (concat (concat val use) src): same as above, with use as
5774 the MO_USE tracked value, if it differs from src.
5778 gcc_checking_assert (REG_P (loc) || MEM_P (loc));
5779 nloc = replace_expr_with_values (loc);
5780 if (!nloc)
5781 nloc = oloc;
5783 if (vloc != nloc)
5784 oloc = gen_rtx_CONCAT (mode2, val->val_rtx, vloc);
5785 else
5786 oloc = val->val_rtx;
5788 mo.u.loc = gen_rtx_CONCAT (mode, oloc, nloc);
5790 if (type2 == MO_USE)
5791 VAL_HOLDS_TRACK_EXPR (mo.u.loc) = 1;
5792 if (!cselib_preserved_value_p (val))
5794 VAL_NEEDS_RESOLUTION (mo.u.loc) = 1;
5795 preserve_value (val);
5798 else
5799 gcc_assert (type == MO_USE || type == MO_USE_NO_VAR);
5801 if (dump_file && (dump_flags & TDF_DETAILS))
5802 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
5803 VTI (bb)->mos.safe_push (mo);
5807 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5809 static void
5810 add_uses_1 (rtx *x, void *cui)
5812 subrtx_var_iterator::array_type array;
5813 FOR_EACH_SUBRTX_VAR (iter, array, *x, NONCONST)
5814 add_uses (*iter, (struct count_use_info *) cui);
5817 /* This is the value used during expansion of locations. We want it
5818 to be unbounded, so that variables expanded deep in a recursion
5819 nest are fully evaluated, so that their values are cached
5820 correctly. We avoid recursion cycles through other means, and we
5821 don't unshare RTL, so excess complexity is not a problem. */
5822 #define EXPR_DEPTH (INT_MAX)
5823 /* We use this to keep too-complex expressions from being emitted as
5824 location notes, and then to debug information. Users can trade
5825 compile time for ridiculously complex expressions, although they're
5826 seldom useful, and they may often have to be discarded as not
5827 representable anyway. */
5828 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5830 /* Attempt to reverse the EXPR operation in the debug info and record
5831 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5832 no longer live we can express its value as VAL - 6. */
5834 static void
5835 reverse_op (rtx val, const_rtx expr, rtx_insn *insn)
5837 rtx src, arg, ret;
5838 cselib_val *v;
5839 struct elt_loc_list *l;
5840 enum rtx_code code;
5841 int count;
5843 if (GET_CODE (expr) != SET)
5844 return;
5846 if (!REG_P (SET_DEST (expr)) || GET_MODE (val) != GET_MODE (SET_DEST (expr)))
5847 return;
5849 src = SET_SRC (expr);
5850 switch (GET_CODE (src))
5852 case PLUS:
5853 case MINUS:
5854 case XOR:
5855 case NOT:
5856 case NEG:
5857 if (!REG_P (XEXP (src, 0)))
5858 return;
5859 break;
5860 case SIGN_EXTEND:
5861 case ZERO_EXTEND:
5862 if (!REG_P (XEXP (src, 0)) && !MEM_P (XEXP (src, 0)))
5863 return;
5864 break;
5865 default:
5866 return;
5869 if (!SCALAR_INT_MODE_P (GET_MODE (src)) || XEXP (src, 0) == cfa_base_rtx)
5870 return;
5872 v = cselib_lookup (XEXP (src, 0), GET_MODE (XEXP (src, 0)), 0, VOIDmode);
5873 if (!v || !cselib_preserved_value_p (v))
5874 return;
5876 /* Use canonical V to avoid creating multiple redundant expressions
5877 for different VALUES equivalent to V. */
5878 v = canonical_cselib_val (v);
5880 /* Adding a reverse op isn't useful if V already has an always valid
5881 location. Ignore ENTRY_VALUE, while it is always constant, we should
5882 prefer non-ENTRY_VALUE locations whenever possible. */
5883 for (l = v->locs, count = 0; l; l = l->next, count++)
5884 if (CONSTANT_P (l->loc)
5885 && (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
5886 return;
5887 /* Avoid creating too large locs lists. */
5888 else if (count == PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE))
5889 return;
5891 switch (GET_CODE (src))
5893 case NOT:
5894 case NEG:
5895 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5896 return;
5897 ret = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (val), val);
5898 break;
5899 case SIGN_EXTEND:
5900 case ZERO_EXTEND:
5901 ret = gen_lowpart_SUBREG (GET_MODE (v->val_rtx), val);
5902 break;
5903 case XOR:
5904 code = XOR;
5905 goto binary;
5906 case PLUS:
5907 code = MINUS;
5908 goto binary;
5909 case MINUS:
5910 code = PLUS;
5911 goto binary;
5912 binary:
5913 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5914 return;
5915 arg = XEXP (src, 1);
5916 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5918 arg = cselib_expand_value_rtx (arg, scratch_regs, 5);
5919 if (arg == NULL_RTX)
5920 return;
5921 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5922 return;
5924 ret = simplify_gen_binary (code, GET_MODE (val), val, arg);
5925 break;
5926 default:
5927 gcc_unreachable ();
5930 cselib_add_permanent_equiv (v, ret, insn);
5933 /* Add stores (register and memory references) LOC which will be tracked
5934 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5935 CUIP->insn is instruction which the LOC is part of. */
5937 static void
5938 add_stores (rtx loc, const_rtx expr, void *cuip)
5940 machine_mode mode = VOIDmode, mode2;
5941 struct count_use_info *cui = (struct count_use_info *)cuip;
5942 basic_block bb = cui->bb;
5943 micro_operation mo;
5944 rtx oloc = loc, nloc, src = NULL;
5945 enum micro_operation_type type = use_type (loc, cui, &mode);
5946 bool track_p = false;
5947 cselib_val *v;
5948 bool resolve, preserve;
5950 if (type == MO_CLOBBER)
5951 return;
5953 mode2 = mode;
5955 if (REG_P (loc))
5957 gcc_assert (loc != cfa_base_rtx);
5958 if ((GET_CODE (expr) == CLOBBER && type != MO_VAL_SET)
5959 || !(track_p = use_type (loc, NULL, &mode2) == MO_USE)
5960 || GET_CODE (expr) == CLOBBER)
5962 mo.type = MO_CLOBBER;
5963 mo.u.loc = loc;
5964 if (GET_CODE (expr) == SET
5965 && SET_DEST (expr) == loc
5966 && !unsuitable_loc (SET_SRC (expr))
5967 && find_use_val (loc, mode, cui))
5969 gcc_checking_assert (type == MO_VAL_SET);
5970 mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
5973 else
5975 if (GET_CODE (expr) == SET
5976 && SET_DEST (expr) == loc
5977 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
5978 src = var_lowpart (mode2, SET_SRC (expr));
5979 loc = var_lowpart (mode2, loc);
5981 if (src == NULL)
5983 mo.type = MO_SET;
5984 mo.u.loc = loc;
5986 else
5988 rtx xexpr = gen_rtx_SET (loc, src);
5989 if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
5991 /* If this is an instruction copying (part of) a parameter
5992 passed by invisible reference to its register location,
5993 pretend it's a SET so that the initial memory location
5994 is discarded, as the parameter register can be reused
5995 for other purposes and we do not track locations based
5996 on generic registers. */
5997 if (MEM_P (src)
5998 && REG_EXPR (loc)
5999 && TREE_CODE (REG_EXPR (loc)) == PARM_DECL
6000 && DECL_MODE (REG_EXPR (loc)) != BLKmode
6001 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc)))
6002 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc)), 0)
6003 != arg_pointer_rtx)
6004 mo.type = MO_SET;
6005 else
6006 mo.type = MO_COPY;
6008 else
6009 mo.type = MO_SET;
6010 mo.u.loc = xexpr;
6013 mo.insn = cui->insn;
6015 else if (MEM_P (loc)
6016 && ((track_p = use_type (loc, NULL, &mode2) == MO_USE)
6017 || cui->sets))
6019 if (MEM_P (loc) && type == MO_VAL_SET
6020 && !REG_P (XEXP (loc, 0))
6021 && !MEM_P (XEXP (loc, 0)))
6023 rtx mloc = loc;
6024 machine_mode address_mode = get_address_mode (mloc);
6025 cselib_val *val = cselib_lookup (XEXP (mloc, 0),
6026 address_mode, 0,
6027 GET_MODE (mloc));
6029 if (val && !cselib_preserved_value_p (val))
6030 preserve_value (val);
6033 if (GET_CODE (expr) == CLOBBER || !track_p)
6035 mo.type = MO_CLOBBER;
6036 mo.u.loc = track_p ? var_lowpart (mode2, loc) : loc;
6038 else
6040 if (GET_CODE (expr) == SET
6041 && SET_DEST (expr) == loc
6042 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
6043 src = var_lowpart (mode2, SET_SRC (expr));
6044 loc = var_lowpart (mode2, loc);
6046 if (src == NULL)
6048 mo.type = MO_SET;
6049 mo.u.loc = loc;
6051 else
6053 rtx xexpr = gen_rtx_SET (loc, src);
6054 if (same_variable_part_p (SET_SRC (xexpr),
6055 MEM_EXPR (loc),
6056 int_mem_offset (loc)))
6057 mo.type = MO_COPY;
6058 else
6059 mo.type = MO_SET;
6060 mo.u.loc = xexpr;
6063 mo.insn = cui->insn;
6065 else
6066 return;
6068 if (type != MO_VAL_SET)
6069 goto log_and_return;
6071 v = find_use_val (oloc, mode, cui);
6073 if (!v)
6074 goto log_and_return;
6076 resolve = preserve = !cselib_preserved_value_p (v);
6078 /* We cannot track values for multiple-part variables, so we track only
6079 locations for tracked record parameters. */
6080 if (track_p
6081 && REG_P (loc)
6082 && REG_EXPR (loc)
6083 && tracked_record_parameter_p (REG_EXPR (loc)))
6085 /* Although we don't use the value here, it could be used later by the
6086 mere virtue of its existence as the operand of the reverse operation
6087 that gave rise to it (typically extension/truncation). Make sure it
6088 is preserved as required by vt_expand_var_loc_chain. */
6089 if (preserve)
6090 preserve_value (v);
6091 goto log_and_return;
6094 if (loc == stack_pointer_rtx
6095 && hard_frame_pointer_adjustment != -1
6096 && preserve)
6097 cselib_set_value_sp_based (v);
6099 nloc = replace_expr_with_values (oloc);
6100 if (nloc)
6101 oloc = nloc;
6103 if (GET_CODE (PATTERN (cui->insn)) == COND_EXEC)
6105 cselib_val *oval = cselib_lookup (oloc, GET_MODE (oloc), 0, VOIDmode);
6107 if (oval == v)
6108 return;
6109 gcc_assert (REG_P (oloc) || MEM_P (oloc));
6111 if (oval && !cselib_preserved_value_p (oval))
6113 micro_operation moa;
6115 preserve_value (oval);
6117 moa.type = MO_VAL_USE;
6118 moa.u.loc = gen_rtx_CONCAT (mode, oval->val_rtx, oloc);
6119 VAL_NEEDS_RESOLUTION (moa.u.loc) = 1;
6120 moa.insn = cui->insn;
6122 if (dump_file && (dump_flags & TDF_DETAILS))
6123 log_op_type (moa.u.loc, cui->bb, cui->insn,
6124 moa.type, dump_file);
6125 VTI (bb)->mos.safe_push (moa);
6128 resolve = false;
6130 else if (resolve && GET_CODE (mo.u.loc) == SET)
6132 if (REG_P (SET_SRC (expr)) || MEM_P (SET_SRC (expr)))
6133 nloc = replace_expr_with_values (SET_SRC (expr));
6134 else
6135 nloc = NULL_RTX;
6137 /* Avoid the mode mismatch between oexpr and expr. */
6138 if (!nloc && mode != mode2)
6140 nloc = SET_SRC (expr);
6141 gcc_assert (oloc == SET_DEST (expr));
6144 if (nloc && nloc != SET_SRC (mo.u.loc))
6145 oloc = gen_rtx_SET (oloc, nloc);
6146 else
6148 if (oloc == SET_DEST (mo.u.loc))
6149 /* No point in duplicating. */
6150 oloc = mo.u.loc;
6151 if (!REG_P (SET_SRC (mo.u.loc)))
6152 resolve = false;
6155 else if (!resolve)
6157 if (GET_CODE (mo.u.loc) == SET
6158 && oloc == SET_DEST (mo.u.loc))
6159 /* No point in duplicating. */
6160 oloc = mo.u.loc;
6162 else
6163 resolve = false;
6165 loc = gen_rtx_CONCAT (mode, v->val_rtx, oloc);
6167 if (mo.u.loc != oloc)
6168 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, mo.u.loc);
6170 /* The loc of a MO_VAL_SET may have various forms:
6172 (concat val dst): dst now holds val
6174 (concat val (set dst src)): dst now holds val, copied from src
6176 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6177 after replacing mems and non-top-level regs with values.
6179 (concat (concat val dstv) (set dst src)): dst now holds val,
6180 copied from src. dstv is a value-based representation of dst, if
6181 it differs from dst. If resolution is needed, src is a REG, and
6182 its mode is the same as that of val.
6184 (concat (concat val (set dstv srcv)) (set dst src)): src
6185 copied to dst, holding val. dstv and srcv are value-based
6186 representations of dst and src, respectively.
6190 if (GET_CODE (PATTERN (cui->insn)) != COND_EXEC)
6191 reverse_op (v->val_rtx, expr, cui->insn);
6193 mo.u.loc = loc;
6195 if (track_p)
6196 VAL_HOLDS_TRACK_EXPR (loc) = 1;
6197 if (preserve)
6199 VAL_NEEDS_RESOLUTION (loc) = resolve;
6200 preserve_value (v);
6202 if (mo.type == MO_CLOBBER)
6203 VAL_EXPR_IS_CLOBBERED (loc) = 1;
6204 if (mo.type == MO_COPY)
6205 VAL_EXPR_IS_COPIED (loc) = 1;
6207 mo.type = MO_VAL_SET;
6209 log_and_return:
6210 if (dump_file && (dump_flags & TDF_DETAILS))
6211 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
6212 VTI (bb)->mos.safe_push (mo);
6215 /* Arguments to the call. */
6216 static rtx call_arguments;
6218 /* Compute call_arguments. */
6220 static void
6221 prepare_call_arguments (basic_block bb, rtx_insn *insn)
6223 rtx link, x, call;
6224 rtx prev, cur, next;
6225 rtx this_arg = NULL_RTX;
6226 tree type = NULL_TREE, t, fndecl = NULL_TREE;
6227 tree obj_type_ref = NULL_TREE;
6228 CUMULATIVE_ARGS args_so_far_v;
6229 cumulative_args_t args_so_far;
6231 memset (&args_so_far_v, 0, sizeof (args_so_far_v));
6232 args_so_far = pack_cumulative_args (&args_so_far_v);
6233 call = get_call_rtx_from (insn);
6234 if (call)
6236 if (GET_CODE (XEXP (XEXP (call, 0), 0)) == SYMBOL_REF)
6238 rtx symbol = XEXP (XEXP (call, 0), 0);
6239 if (SYMBOL_REF_DECL (symbol))
6240 fndecl = SYMBOL_REF_DECL (symbol);
6242 if (fndecl == NULL_TREE)
6243 fndecl = MEM_EXPR (XEXP (call, 0));
6244 if (fndecl
6245 && TREE_CODE (TREE_TYPE (fndecl)) != FUNCTION_TYPE
6246 && TREE_CODE (TREE_TYPE (fndecl)) != METHOD_TYPE)
6247 fndecl = NULL_TREE;
6248 if (fndecl && TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6249 type = TREE_TYPE (fndecl);
6250 if (fndecl && TREE_CODE (fndecl) != FUNCTION_DECL)
6252 if (TREE_CODE (fndecl) == INDIRECT_REF
6253 && TREE_CODE (TREE_OPERAND (fndecl, 0)) == OBJ_TYPE_REF)
6254 obj_type_ref = TREE_OPERAND (fndecl, 0);
6255 fndecl = NULL_TREE;
6257 if (type)
6259 for (t = TYPE_ARG_TYPES (type); t && t != void_list_node;
6260 t = TREE_CHAIN (t))
6261 if (TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
6262 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t))))
6263 break;
6264 if ((t == NULL || t == void_list_node) && obj_type_ref == NULL_TREE)
6265 type = NULL;
6266 else
6268 int nargs ATTRIBUTE_UNUSED = list_length (TYPE_ARG_TYPES (type));
6269 link = CALL_INSN_FUNCTION_USAGE (insn);
6270 #ifndef PCC_STATIC_STRUCT_RETURN
6271 if (aggregate_value_p (TREE_TYPE (type), type)
6272 && targetm.calls.struct_value_rtx (type, 0) == 0)
6274 tree struct_addr = build_pointer_type (TREE_TYPE (type));
6275 machine_mode mode = TYPE_MODE (struct_addr);
6276 rtx reg;
6277 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6278 nargs + 1);
6279 reg = targetm.calls.function_arg (args_so_far, mode,
6280 struct_addr, true);
6281 targetm.calls.function_arg_advance (args_so_far, mode,
6282 struct_addr, true);
6283 if (reg == NULL_RTX)
6285 for (; link; link = XEXP (link, 1))
6286 if (GET_CODE (XEXP (link, 0)) == USE
6287 && MEM_P (XEXP (XEXP (link, 0), 0)))
6289 link = XEXP (link, 1);
6290 break;
6294 else
6295 #endif
6296 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6297 nargs);
6298 if (obj_type_ref && TYPE_ARG_TYPES (type) != void_list_node)
6300 machine_mode mode;
6301 t = TYPE_ARG_TYPES (type);
6302 mode = TYPE_MODE (TREE_VALUE (t));
6303 this_arg = targetm.calls.function_arg (args_so_far, mode,
6304 TREE_VALUE (t), true);
6305 if (this_arg && !REG_P (this_arg))
6306 this_arg = NULL_RTX;
6307 else if (this_arg == NULL_RTX)
6309 for (; link; link = XEXP (link, 1))
6310 if (GET_CODE (XEXP (link, 0)) == USE
6311 && MEM_P (XEXP (XEXP (link, 0), 0)))
6313 this_arg = XEXP (XEXP (link, 0), 0);
6314 break;
6321 t = type ? TYPE_ARG_TYPES (type) : NULL_TREE;
6323 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6324 if (GET_CODE (XEXP (link, 0)) == USE)
6326 rtx item = NULL_RTX;
6327 x = XEXP (XEXP (link, 0), 0);
6328 if (GET_MODE (link) == VOIDmode
6329 || GET_MODE (link) == BLKmode
6330 || (GET_MODE (link) != GET_MODE (x)
6331 && ((GET_MODE_CLASS (GET_MODE (link)) != MODE_INT
6332 && GET_MODE_CLASS (GET_MODE (link)) != MODE_PARTIAL_INT)
6333 || (GET_MODE_CLASS (GET_MODE (x)) != MODE_INT
6334 && GET_MODE_CLASS (GET_MODE (x)) != MODE_PARTIAL_INT))))
6335 /* Can't do anything for these, if the original type mode
6336 isn't known or can't be converted. */;
6337 else if (REG_P (x))
6339 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6340 scalar_int_mode mode;
6341 if (val && cselib_preserved_value_p (val))
6342 item = val->val_rtx;
6343 else if (is_a <scalar_int_mode> (GET_MODE (x), &mode))
6345 opt_scalar_int_mode mode_iter;
6346 FOR_EACH_WIDER_MODE (mode_iter, mode)
6348 mode = mode_iter.require ();
6349 if (GET_MODE_BITSIZE (mode) > BITS_PER_WORD)
6350 break;
6352 rtx reg = simplify_subreg (mode, x, GET_MODE (x), 0);
6353 if (reg == NULL_RTX || !REG_P (reg))
6354 continue;
6355 val = cselib_lookup (reg, mode, 0, VOIDmode);
6356 if (val && cselib_preserved_value_p (val))
6358 item = val->val_rtx;
6359 break;
6364 else if (MEM_P (x))
6366 rtx mem = x;
6367 cselib_val *val;
6369 if (!frame_pointer_needed)
6371 struct adjust_mem_data amd;
6372 amd.mem_mode = VOIDmode;
6373 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
6374 amd.store = true;
6375 mem = simplify_replace_fn_rtx (mem, NULL_RTX, adjust_mems,
6376 &amd);
6377 gcc_assert (amd.side_effects.is_empty ());
6379 val = cselib_lookup (mem, GET_MODE (mem), 0, VOIDmode);
6380 if (val && cselib_preserved_value_p (val))
6381 item = val->val_rtx;
6382 else if (GET_MODE_CLASS (GET_MODE (mem)) != MODE_INT
6383 && GET_MODE_CLASS (GET_MODE (mem)) != MODE_PARTIAL_INT)
6385 /* For non-integer stack argument see also if they weren't
6386 initialized by integers. */
6387 scalar_int_mode imode;
6388 if (int_mode_for_mode (GET_MODE (mem)).exists (&imode)
6389 && imode != GET_MODE (mem))
6391 val = cselib_lookup (adjust_address_nv (mem, imode, 0),
6392 imode, 0, VOIDmode);
6393 if (val && cselib_preserved_value_p (val))
6394 item = lowpart_subreg (GET_MODE (x), val->val_rtx,
6395 imode);
6399 if (item)
6401 rtx x2 = x;
6402 if (GET_MODE (item) != GET_MODE (link))
6403 item = lowpart_subreg (GET_MODE (link), item, GET_MODE (item));
6404 if (GET_MODE (x2) != GET_MODE (link))
6405 x2 = lowpart_subreg (GET_MODE (link), x2, GET_MODE (x2));
6406 item = gen_rtx_CONCAT (GET_MODE (link), x2, item);
6407 call_arguments
6408 = gen_rtx_EXPR_LIST (VOIDmode, item, call_arguments);
6410 if (t && t != void_list_node)
6412 tree argtype = TREE_VALUE (t);
6413 machine_mode mode = TYPE_MODE (argtype);
6414 rtx reg;
6415 if (pass_by_reference (&args_so_far_v, mode, argtype, true))
6417 argtype = build_pointer_type (argtype);
6418 mode = TYPE_MODE (argtype);
6420 reg = targetm.calls.function_arg (args_so_far, mode,
6421 argtype, true);
6422 if (TREE_CODE (argtype) == REFERENCE_TYPE
6423 && INTEGRAL_TYPE_P (TREE_TYPE (argtype))
6424 && reg
6425 && REG_P (reg)
6426 && GET_MODE (reg) == mode
6427 && (GET_MODE_CLASS (mode) == MODE_INT
6428 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
6429 && REG_P (x)
6430 && REGNO (x) == REGNO (reg)
6431 && GET_MODE (x) == mode
6432 && item)
6434 machine_mode indmode
6435 = TYPE_MODE (TREE_TYPE (argtype));
6436 rtx mem = gen_rtx_MEM (indmode, x);
6437 cselib_val *val = cselib_lookup (mem, indmode, 0, VOIDmode);
6438 if (val && cselib_preserved_value_p (val))
6440 item = gen_rtx_CONCAT (indmode, mem, val->val_rtx);
6441 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6442 call_arguments);
6444 else
6446 struct elt_loc_list *l;
6447 tree initial;
6449 /* Try harder, when passing address of a constant
6450 pool integer it can be easily read back. */
6451 item = XEXP (item, 1);
6452 if (GET_CODE (item) == SUBREG)
6453 item = SUBREG_REG (item);
6454 gcc_assert (GET_CODE (item) == VALUE);
6455 val = CSELIB_VAL_PTR (item);
6456 for (l = val->locs; l; l = l->next)
6457 if (GET_CODE (l->loc) == SYMBOL_REF
6458 && TREE_CONSTANT_POOL_ADDRESS_P (l->loc)
6459 && SYMBOL_REF_DECL (l->loc)
6460 && DECL_INITIAL (SYMBOL_REF_DECL (l->loc)))
6462 initial = DECL_INITIAL (SYMBOL_REF_DECL (l->loc));
6463 if (tree_fits_shwi_p (initial))
6465 item = GEN_INT (tree_to_shwi (initial));
6466 item = gen_rtx_CONCAT (indmode, mem, item);
6467 call_arguments
6468 = gen_rtx_EXPR_LIST (VOIDmode, item,
6469 call_arguments);
6471 break;
6475 targetm.calls.function_arg_advance (args_so_far, mode,
6476 argtype, true);
6477 t = TREE_CHAIN (t);
6481 /* Add debug arguments. */
6482 if (fndecl
6483 && TREE_CODE (fndecl) == FUNCTION_DECL
6484 && DECL_HAS_DEBUG_ARGS_P (fndecl))
6486 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (fndecl);
6487 if (debug_args)
6489 unsigned int ix;
6490 tree param;
6491 for (ix = 0; vec_safe_iterate (*debug_args, ix, &param); ix += 2)
6493 rtx item;
6494 tree dtemp = (**debug_args)[ix + 1];
6495 machine_mode mode = DECL_MODE (dtemp);
6496 item = gen_rtx_DEBUG_PARAMETER_REF (mode, param);
6497 item = gen_rtx_CONCAT (mode, item, DECL_RTL_KNOWN_SET (dtemp));
6498 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6499 call_arguments);
6504 /* Reverse call_arguments chain. */
6505 prev = NULL_RTX;
6506 for (cur = call_arguments; cur; cur = next)
6508 next = XEXP (cur, 1);
6509 XEXP (cur, 1) = prev;
6510 prev = cur;
6512 call_arguments = prev;
6514 x = get_call_rtx_from (insn);
6515 if (x)
6517 x = XEXP (XEXP (x, 0), 0);
6518 if (GET_CODE (x) == SYMBOL_REF)
6519 /* Don't record anything. */;
6520 else if (CONSTANT_P (x))
6522 x = gen_rtx_CONCAT (GET_MODE (x) == VOIDmode ? Pmode : GET_MODE (x),
6523 pc_rtx, x);
6524 call_arguments
6525 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6527 else
6529 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6530 if (val && cselib_preserved_value_p (val))
6532 x = gen_rtx_CONCAT (GET_MODE (x), pc_rtx, val->val_rtx);
6533 call_arguments
6534 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6538 if (this_arg)
6540 machine_mode mode
6541 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref)));
6542 rtx clobbered = gen_rtx_MEM (mode, this_arg);
6543 HOST_WIDE_INT token
6544 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref));
6545 if (token)
6546 clobbered = plus_constant (mode, clobbered,
6547 token * GET_MODE_SIZE (mode));
6548 clobbered = gen_rtx_MEM (mode, clobbered);
6549 x = gen_rtx_CONCAT (mode, gen_rtx_CLOBBER (VOIDmode, pc_rtx), clobbered);
6550 call_arguments
6551 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6555 /* Callback for cselib_record_sets_hook, that records as micro
6556 operations uses and stores in an insn after cselib_record_sets has
6557 analyzed the sets in an insn, but before it modifies the stored
6558 values in the internal tables, unless cselib_record_sets doesn't
6559 call it directly (perhaps because we're not doing cselib in the
6560 first place, in which case sets and n_sets will be 0). */
6562 static void
6563 add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
6565 basic_block bb = BLOCK_FOR_INSN (insn);
6566 int n1, n2;
6567 struct count_use_info cui;
6568 micro_operation *mos;
6570 cselib_hook_called = true;
6572 cui.insn = insn;
6573 cui.bb = bb;
6574 cui.sets = sets;
6575 cui.n_sets = n_sets;
6577 n1 = VTI (bb)->mos.length ();
6578 cui.store_p = false;
6579 note_uses (&PATTERN (insn), add_uses_1, &cui);
6580 n2 = VTI (bb)->mos.length () - 1;
6581 mos = VTI (bb)->mos.address ();
6583 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6584 MO_VAL_LOC last. */
6585 while (n1 < n2)
6587 while (n1 < n2 && mos[n1].type == MO_USE)
6588 n1++;
6589 while (n1 < n2 && mos[n2].type != MO_USE)
6590 n2--;
6591 if (n1 < n2)
6592 std::swap (mos[n1], mos[n2]);
6595 n2 = VTI (bb)->mos.length () - 1;
6596 while (n1 < n2)
6598 while (n1 < n2 && mos[n1].type != MO_VAL_LOC)
6599 n1++;
6600 while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
6601 n2--;
6602 if (n1 < n2)
6603 std::swap (mos[n1], mos[n2]);
6606 if (CALL_P (insn))
6608 micro_operation mo;
6610 mo.type = MO_CALL;
6611 mo.insn = insn;
6612 mo.u.loc = call_arguments;
6613 call_arguments = NULL_RTX;
6615 if (dump_file && (dump_flags & TDF_DETAILS))
6616 log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
6617 VTI (bb)->mos.safe_push (mo);
6620 n1 = VTI (bb)->mos.length ();
6621 /* This will record NEXT_INSN (insn), such that we can
6622 insert notes before it without worrying about any
6623 notes that MO_USEs might emit after the insn. */
6624 cui.store_p = true;
6625 note_stores (PATTERN (insn), add_stores, &cui);
6626 n2 = VTI (bb)->mos.length () - 1;
6627 mos = VTI (bb)->mos.address ();
6629 /* Order the MO_VAL_USEs first (note_stores does nothing
6630 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6631 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6632 while (n1 < n2)
6634 while (n1 < n2 && mos[n1].type == MO_VAL_USE)
6635 n1++;
6636 while (n1 < n2 && mos[n2].type != MO_VAL_USE)
6637 n2--;
6638 if (n1 < n2)
6639 std::swap (mos[n1], mos[n2]);
6642 n2 = VTI (bb)->mos.length () - 1;
6643 while (n1 < n2)
6645 while (n1 < n2 && mos[n1].type == MO_CLOBBER)
6646 n1++;
6647 while (n1 < n2 && mos[n2].type != MO_CLOBBER)
6648 n2--;
6649 if (n1 < n2)
6650 std::swap (mos[n1], mos[n2]);
6654 static enum var_init_status
6655 find_src_status (dataflow_set *in, rtx src)
6657 tree decl = NULL_TREE;
6658 enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED;
6660 if (! flag_var_tracking_uninit)
6661 status = VAR_INIT_STATUS_INITIALIZED;
6663 if (src && REG_P (src))
6664 decl = var_debug_decl (REG_EXPR (src));
6665 else if (src && MEM_P (src))
6666 decl = var_debug_decl (MEM_EXPR (src));
6668 if (src && decl)
6669 status = get_init_value (in, src, dv_from_decl (decl));
6671 return status;
6674 /* SRC is the source of an assignment. Use SET to try to find what
6675 was ultimately assigned to SRC. Return that value if known,
6676 otherwise return SRC itself. */
6678 static rtx
6679 find_src_set_src (dataflow_set *set, rtx src)
6681 tree decl = NULL_TREE; /* The variable being copied around. */
6682 rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */
6683 variable *var;
6684 location_chain *nextp;
6685 int i;
6686 bool found;
6688 if (src && REG_P (src))
6689 decl = var_debug_decl (REG_EXPR (src));
6690 else if (src && MEM_P (src))
6691 decl = var_debug_decl (MEM_EXPR (src));
6693 if (src && decl)
6695 decl_or_value dv = dv_from_decl (decl);
6697 var = shared_hash_find (set->vars, dv);
6698 if (var)
6700 found = false;
6701 for (i = 0; i < var->n_var_parts && !found; i++)
6702 for (nextp = var->var_part[i].loc_chain; nextp && !found;
6703 nextp = nextp->next)
6704 if (rtx_equal_p (nextp->loc, src))
6706 set_src = nextp->set_src;
6707 found = true;
6713 return set_src;
6716 /* Compute the changes of variable locations in the basic block BB. */
6718 static bool
6719 compute_bb_dataflow (basic_block bb)
6721 unsigned int i;
6722 micro_operation *mo;
6723 bool changed;
6724 dataflow_set old_out;
6725 dataflow_set *in = &VTI (bb)->in;
6726 dataflow_set *out = &VTI (bb)->out;
6728 dataflow_set_init (&old_out);
6729 dataflow_set_copy (&old_out, out);
6730 dataflow_set_copy (out, in);
6732 if (MAY_HAVE_DEBUG_BIND_INSNS)
6733 local_get_addr_cache = new hash_map<rtx, rtx>;
6735 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
6737 rtx_insn *insn = mo->insn;
6739 switch (mo->type)
6741 case MO_CALL:
6742 dataflow_set_clear_at_call (out, insn);
6743 break;
6745 case MO_USE:
6747 rtx loc = mo->u.loc;
6749 if (REG_P (loc))
6750 var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6751 else if (MEM_P (loc))
6752 var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6754 break;
6756 case MO_VAL_LOC:
6758 rtx loc = mo->u.loc;
6759 rtx val, vloc;
6760 tree var;
6762 if (GET_CODE (loc) == CONCAT)
6764 val = XEXP (loc, 0);
6765 vloc = XEXP (loc, 1);
6767 else
6769 val = NULL_RTX;
6770 vloc = loc;
6773 var = PAT_VAR_LOCATION_DECL (vloc);
6775 clobber_variable_part (out, NULL_RTX,
6776 dv_from_decl (var), 0, NULL_RTX);
6777 if (val)
6779 if (VAL_NEEDS_RESOLUTION (loc))
6780 val_resolve (out, val, PAT_VAR_LOCATION_LOC (vloc), insn);
6781 set_variable_part (out, val, dv_from_decl (var), 0,
6782 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6783 INSERT);
6785 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
6786 set_variable_part (out, PAT_VAR_LOCATION_LOC (vloc),
6787 dv_from_decl (var), 0,
6788 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6789 INSERT);
6791 break;
6793 case MO_VAL_USE:
6795 rtx loc = mo->u.loc;
6796 rtx val, vloc, uloc;
6798 vloc = uloc = XEXP (loc, 1);
6799 val = XEXP (loc, 0);
6801 if (GET_CODE (val) == CONCAT)
6803 uloc = XEXP (val, 1);
6804 val = XEXP (val, 0);
6807 if (VAL_NEEDS_RESOLUTION (loc))
6808 val_resolve (out, val, vloc, insn);
6809 else
6810 val_store (out, val, uloc, insn, false);
6812 if (VAL_HOLDS_TRACK_EXPR (loc))
6814 if (GET_CODE (uloc) == REG)
6815 var_reg_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6816 NULL);
6817 else if (GET_CODE (uloc) == MEM)
6818 var_mem_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6819 NULL);
6822 break;
6824 case MO_VAL_SET:
6826 rtx loc = mo->u.loc;
6827 rtx val, vloc, uloc;
6828 rtx dstv, srcv;
6830 vloc = loc;
6831 uloc = XEXP (vloc, 1);
6832 val = XEXP (vloc, 0);
6833 vloc = uloc;
6835 if (GET_CODE (uloc) == SET)
6837 dstv = SET_DEST (uloc);
6838 srcv = SET_SRC (uloc);
6840 else
6842 dstv = uloc;
6843 srcv = NULL;
6846 if (GET_CODE (val) == CONCAT)
6848 dstv = vloc = XEXP (val, 1);
6849 val = XEXP (val, 0);
6852 if (GET_CODE (vloc) == SET)
6854 srcv = SET_SRC (vloc);
6856 gcc_assert (val != srcv);
6857 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
6859 dstv = vloc = SET_DEST (vloc);
6861 if (VAL_NEEDS_RESOLUTION (loc))
6862 val_resolve (out, val, srcv, insn);
6864 else if (VAL_NEEDS_RESOLUTION (loc))
6866 gcc_assert (GET_CODE (uloc) == SET
6867 && GET_CODE (SET_SRC (uloc)) == REG);
6868 val_resolve (out, val, SET_SRC (uloc), insn);
6871 if (VAL_HOLDS_TRACK_EXPR (loc))
6873 if (VAL_EXPR_IS_CLOBBERED (loc))
6875 if (REG_P (uloc))
6876 var_reg_delete (out, uloc, true);
6877 else if (MEM_P (uloc))
6879 gcc_assert (MEM_P (dstv));
6880 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
6881 var_mem_delete (out, dstv, true);
6884 else
6886 bool copied_p = VAL_EXPR_IS_COPIED (loc);
6887 rtx src = NULL, dst = uloc;
6888 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
6890 if (GET_CODE (uloc) == SET)
6892 src = SET_SRC (uloc);
6893 dst = SET_DEST (uloc);
6896 if (copied_p)
6898 if (flag_var_tracking_uninit)
6900 status = find_src_status (in, src);
6902 if (status == VAR_INIT_STATUS_UNKNOWN)
6903 status = find_src_status (out, src);
6906 src = find_src_set_src (in, src);
6909 if (REG_P (dst))
6910 var_reg_delete_and_set (out, dst, !copied_p,
6911 status, srcv);
6912 else if (MEM_P (dst))
6914 gcc_assert (MEM_P (dstv));
6915 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
6916 var_mem_delete_and_set (out, dstv, !copied_p,
6917 status, srcv);
6921 else if (REG_P (uloc))
6922 var_regno_delete (out, REGNO (uloc));
6923 else if (MEM_P (uloc))
6925 gcc_checking_assert (GET_CODE (vloc) == MEM);
6926 gcc_checking_assert (dstv == vloc);
6927 if (dstv != vloc)
6928 clobber_overlapping_mems (out, vloc);
6931 val_store (out, val, dstv, insn, true);
6933 break;
6935 case MO_SET:
6937 rtx loc = mo->u.loc;
6938 rtx set_src = NULL;
6940 if (GET_CODE (loc) == SET)
6942 set_src = SET_SRC (loc);
6943 loc = SET_DEST (loc);
6946 if (REG_P (loc))
6947 var_reg_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6948 set_src);
6949 else if (MEM_P (loc))
6950 var_mem_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6951 set_src);
6953 break;
6955 case MO_COPY:
6957 rtx loc = mo->u.loc;
6958 enum var_init_status src_status;
6959 rtx set_src = NULL;
6961 if (GET_CODE (loc) == SET)
6963 set_src = SET_SRC (loc);
6964 loc = SET_DEST (loc);
6967 if (! flag_var_tracking_uninit)
6968 src_status = VAR_INIT_STATUS_INITIALIZED;
6969 else
6971 src_status = find_src_status (in, set_src);
6973 if (src_status == VAR_INIT_STATUS_UNKNOWN)
6974 src_status = find_src_status (out, set_src);
6977 set_src = find_src_set_src (in, set_src);
6979 if (REG_P (loc))
6980 var_reg_delete_and_set (out, loc, false, src_status, set_src);
6981 else if (MEM_P (loc))
6982 var_mem_delete_and_set (out, loc, false, src_status, set_src);
6984 break;
6986 case MO_USE_NO_VAR:
6988 rtx loc = mo->u.loc;
6990 if (REG_P (loc))
6991 var_reg_delete (out, loc, false);
6992 else if (MEM_P (loc))
6993 var_mem_delete (out, loc, false);
6995 break;
6997 case MO_CLOBBER:
6999 rtx loc = mo->u.loc;
7001 if (REG_P (loc))
7002 var_reg_delete (out, loc, true);
7003 else if (MEM_P (loc))
7004 var_mem_delete (out, loc, true);
7006 break;
7008 case MO_ADJUST:
7009 out->stack_adjust += mo->u.adjust;
7010 break;
7014 if (MAY_HAVE_DEBUG_BIND_INSNS)
7016 delete local_get_addr_cache;
7017 local_get_addr_cache = NULL;
7019 dataflow_set_equiv_regs (out);
7020 shared_hash_htab (out->vars)
7021 ->traverse <dataflow_set *, canonicalize_values_mark> (out);
7022 shared_hash_htab (out->vars)
7023 ->traverse <dataflow_set *, canonicalize_values_star> (out);
7024 if (flag_checking)
7025 shared_hash_htab (out->vars)
7026 ->traverse <dataflow_set *, canonicalize_loc_order_check> (out);
7028 changed = dataflow_set_different (&old_out, out);
7029 dataflow_set_destroy (&old_out);
7030 return changed;
7033 /* Find the locations of variables in the whole function. */
7035 static bool
7036 vt_find_locations (void)
7038 bb_heap_t *worklist = new bb_heap_t (LONG_MIN);
7039 bb_heap_t *pending = new bb_heap_t (LONG_MIN);
7040 sbitmap in_worklist, in_pending;
7041 basic_block bb;
7042 edge e;
7043 int *bb_order;
7044 int *rc_order;
7045 int i;
7046 int htabsz = 0;
7047 int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
7048 bool success = true;
7050 timevar_push (TV_VAR_TRACKING_DATAFLOW);
7051 /* Compute reverse completion order of depth first search of the CFG
7052 so that the data-flow runs faster. */
7053 rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS);
7054 bb_order = XNEWVEC (int, last_basic_block_for_fn (cfun));
7055 pre_and_rev_post_order_compute (NULL, rc_order, false);
7056 for (i = 0; i < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; i++)
7057 bb_order[rc_order[i]] = i;
7058 free (rc_order);
7060 auto_sbitmap visited (last_basic_block_for_fn (cfun));
7061 in_worklist = sbitmap_alloc (last_basic_block_for_fn (cfun));
7062 in_pending = sbitmap_alloc (last_basic_block_for_fn (cfun));
7063 bitmap_clear (in_worklist);
7065 FOR_EACH_BB_FN (bb, cfun)
7066 pending->insert (bb_order[bb->index], bb);
7067 bitmap_ones (in_pending);
7069 while (success && !pending->empty ())
7071 std::swap (worklist, pending);
7072 std::swap (in_worklist, in_pending);
7074 bitmap_clear (visited);
7076 while (!worklist->empty ())
7078 bb = worklist->extract_min ();
7079 bitmap_clear_bit (in_worklist, bb->index);
7080 gcc_assert (!bitmap_bit_p (visited, bb->index));
7081 if (!bitmap_bit_p (visited, bb->index))
7083 bool changed;
7084 edge_iterator ei;
7085 int oldinsz, oldoutsz;
7087 bitmap_set_bit (visited, bb->index);
7089 if (VTI (bb)->in.vars)
7091 htabsz
7092 -= shared_hash_htab (VTI (bb)->in.vars)->size ()
7093 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7094 oldinsz = shared_hash_htab (VTI (bb)->in.vars)->elements ();
7095 oldoutsz
7096 = shared_hash_htab (VTI (bb)->out.vars)->elements ();
7098 else
7099 oldinsz = oldoutsz = 0;
7101 if (MAY_HAVE_DEBUG_BIND_INSNS)
7103 dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
7104 bool first = true, adjust = false;
7106 /* Calculate the IN set as the intersection of
7107 predecessor OUT sets. */
7109 dataflow_set_clear (in);
7110 dst_can_be_shared = true;
7112 FOR_EACH_EDGE (e, ei, bb->preds)
7113 if (!VTI (e->src)->flooded)
7114 gcc_assert (bb_order[bb->index]
7115 <= bb_order[e->src->index]);
7116 else if (first)
7118 dataflow_set_copy (in, &VTI (e->src)->out);
7119 first_out = &VTI (e->src)->out;
7120 first = false;
7122 else
7124 dataflow_set_merge (in, &VTI (e->src)->out);
7125 adjust = true;
7128 if (adjust)
7130 dataflow_post_merge_adjust (in, &VTI (bb)->permp);
7132 if (flag_checking)
7133 /* Merge and merge_adjust should keep entries in
7134 canonical order. */
7135 shared_hash_htab (in->vars)
7136 ->traverse <dataflow_set *,
7137 canonicalize_loc_order_check> (in);
7139 if (dst_can_be_shared)
7141 shared_hash_destroy (in->vars);
7142 in->vars = shared_hash_copy (first_out->vars);
7146 VTI (bb)->flooded = true;
7148 else
7150 /* Calculate the IN set as union of predecessor OUT sets. */
7151 dataflow_set_clear (&VTI (bb)->in);
7152 FOR_EACH_EDGE (e, ei, bb->preds)
7153 dataflow_set_union (&VTI (bb)->in, &VTI (e->src)->out);
7156 changed = compute_bb_dataflow (bb);
7157 htabsz += shared_hash_htab (VTI (bb)->in.vars)->size ()
7158 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7160 if (htabmax && htabsz > htabmax)
7162 if (MAY_HAVE_DEBUG_BIND_INSNS)
7163 inform (DECL_SOURCE_LOCATION (cfun->decl),
7164 "variable tracking size limit exceeded with "
7165 "-fvar-tracking-assignments, retrying without");
7166 else
7167 inform (DECL_SOURCE_LOCATION (cfun->decl),
7168 "variable tracking size limit exceeded");
7169 success = false;
7170 break;
7173 if (changed)
7175 FOR_EACH_EDGE (e, ei, bb->succs)
7177 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
7178 continue;
7180 if (bitmap_bit_p (visited, e->dest->index))
7182 if (!bitmap_bit_p (in_pending, e->dest->index))
7184 /* Send E->DEST to next round. */
7185 bitmap_set_bit (in_pending, e->dest->index);
7186 pending->insert (bb_order[e->dest->index],
7187 e->dest);
7190 else if (!bitmap_bit_p (in_worklist, e->dest->index))
7192 /* Add E->DEST to current round. */
7193 bitmap_set_bit (in_worklist, e->dest->index);
7194 worklist->insert (bb_order[e->dest->index],
7195 e->dest);
7200 if (dump_file)
7201 fprintf (dump_file,
7202 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7203 bb->index,
7204 (int)shared_hash_htab (VTI (bb)->in.vars)->size (),
7205 oldinsz,
7206 (int)shared_hash_htab (VTI (bb)->out.vars)->size (),
7207 oldoutsz,
7208 (int)worklist->nodes (), (int)pending->nodes (),
7209 htabsz);
7211 if (dump_file && (dump_flags & TDF_DETAILS))
7213 fprintf (dump_file, "BB %i IN:\n", bb->index);
7214 dump_dataflow_set (&VTI (bb)->in);
7215 fprintf (dump_file, "BB %i OUT:\n", bb->index);
7216 dump_dataflow_set (&VTI (bb)->out);
7222 if (success && MAY_HAVE_DEBUG_BIND_INSNS)
7223 FOR_EACH_BB_FN (bb, cfun)
7224 gcc_assert (VTI (bb)->flooded);
7226 free (bb_order);
7227 delete worklist;
7228 delete pending;
7229 sbitmap_free (in_worklist);
7230 sbitmap_free (in_pending);
7232 timevar_pop (TV_VAR_TRACKING_DATAFLOW);
7233 return success;
7236 /* Print the content of the LIST to dump file. */
7238 static void
7239 dump_attrs_list (attrs *list)
7241 for (; list; list = list->next)
7243 if (dv_is_decl_p (list->dv))
7244 print_mem_expr (dump_file, dv_as_decl (list->dv));
7245 else
7246 print_rtl_single (dump_file, dv_as_value (list->dv));
7247 fprintf (dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset);
7249 fprintf (dump_file, "\n");
7252 /* Print the information about variable *SLOT to dump file. */
7255 dump_var_tracking_slot (variable **slot, void *data ATTRIBUTE_UNUSED)
7257 variable *var = *slot;
7259 dump_var (var);
7261 /* Continue traversing the hash table. */
7262 return 1;
7265 /* Print the information about variable VAR to dump file. */
7267 static void
7268 dump_var (variable *var)
7270 int i;
7271 location_chain *node;
7273 if (dv_is_decl_p (var->dv))
7275 const_tree decl = dv_as_decl (var->dv);
7277 if (DECL_NAME (decl))
7279 fprintf (dump_file, " name: %s",
7280 IDENTIFIER_POINTER (DECL_NAME (decl)));
7281 if (dump_flags & TDF_UID)
7282 fprintf (dump_file, "D.%u", DECL_UID (decl));
7284 else if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
7285 fprintf (dump_file, " name: D#%u", DEBUG_TEMP_UID (decl));
7286 else
7287 fprintf (dump_file, " name: D.%u", DECL_UID (decl));
7288 fprintf (dump_file, "\n");
7290 else
7292 fputc (' ', dump_file);
7293 print_rtl_single (dump_file, dv_as_value (var->dv));
7296 for (i = 0; i < var->n_var_parts; i++)
7298 fprintf (dump_file, " offset %ld\n",
7299 (long)(var->onepart ? 0 : VAR_PART_OFFSET (var, i)));
7300 for (node = var->var_part[i].loc_chain; node; node = node->next)
7302 fprintf (dump_file, " ");
7303 if (node->init == VAR_INIT_STATUS_UNINITIALIZED)
7304 fprintf (dump_file, "[uninit]");
7305 print_rtl_single (dump_file, node->loc);
7310 /* Print the information about variables from hash table VARS to dump file. */
7312 static void
7313 dump_vars (variable_table_type *vars)
7315 if (vars->elements () > 0)
7317 fprintf (dump_file, "Variables:\n");
7318 vars->traverse <void *, dump_var_tracking_slot> (NULL);
7322 /* Print the dataflow set SET to dump file. */
7324 static void
7325 dump_dataflow_set (dataflow_set *set)
7327 int i;
7329 fprintf (dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n",
7330 set->stack_adjust);
7331 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
7333 if (set->regs[i])
7335 fprintf (dump_file, "Reg %d:", i);
7336 dump_attrs_list (set->regs[i]);
7339 dump_vars (shared_hash_htab (set->vars));
7340 fprintf (dump_file, "\n");
7343 /* Print the IN and OUT sets for each basic block to dump file. */
7345 static void
7346 dump_dataflow_sets (void)
7348 basic_block bb;
7350 FOR_EACH_BB_FN (bb, cfun)
7352 fprintf (dump_file, "\nBasic block %d:\n", bb->index);
7353 fprintf (dump_file, "IN:\n");
7354 dump_dataflow_set (&VTI (bb)->in);
7355 fprintf (dump_file, "OUT:\n");
7356 dump_dataflow_set (&VTI (bb)->out);
7360 /* Return the variable for DV in dropped_values, inserting one if
7361 requested with INSERT. */
7363 static inline variable *
7364 variable_from_dropped (decl_or_value dv, enum insert_option insert)
7366 variable **slot;
7367 variable *empty_var;
7368 onepart_enum onepart;
7370 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), insert);
7372 if (!slot)
7373 return NULL;
7375 if (*slot)
7376 return *slot;
7378 gcc_checking_assert (insert == INSERT);
7380 onepart = dv_onepart_p (dv);
7382 gcc_checking_assert (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR);
7384 empty_var = onepart_pool_allocate (onepart);
7385 empty_var->dv = dv;
7386 empty_var->refcount = 1;
7387 empty_var->n_var_parts = 0;
7388 empty_var->onepart = onepart;
7389 empty_var->in_changed_variables = false;
7390 empty_var->var_part[0].loc_chain = NULL;
7391 empty_var->var_part[0].cur_loc = NULL;
7392 VAR_LOC_1PAUX (empty_var) = NULL;
7393 set_dv_changed (dv, true);
7395 *slot = empty_var;
7397 return empty_var;
7400 /* Recover the one-part aux from dropped_values. */
7402 static struct onepart_aux *
7403 recover_dropped_1paux (variable *var)
7405 variable *dvar;
7407 gcc_checking_assert (var->onepart);
7409 if (VAR_LOC_1PAUX (var))
7410 return VAR_LOC_1PAUX (var);
7412 if (var->onepart == ONEPART_VDECL)
7413 return NULL;
7415 dvar = variable_from_dropped (var->dv, NO_INSERT);
7417 if (!dvar)
7418 return NULL;
7420 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (dvar);
7421 VAR_LOC_1PAUX (dvar) = NULL;
7423 return VAR_LOC_1PAUX (var);
7426 /* Add variable VAR to the hash table of changed variables and
7427 if it has no locations delete it from SET's hash table. */
7429 static void
7430 variable_was_changed (variable *var, dataflow_set *set)
7432 hashval_t hash = dv_htab_hash (var->dv);
7434 if (emit_notes)
7436 variable **slot;
7438 /* Remember this decl or VALUE has been added to changed_variables. */
7439 set_dv_changed (var->dv, true);
7441 slot = changed_variables->find_slot_with_hash (var->dv, hash, INSERT);
7443 if (*slot)
7445 variable *old_var = *slot;
7446 gcc_assert (old_var->in_changed_variables);
7447 old_var->in_changed_variables = false;
7448 if (var != old_var && var->onepart)
7450 /* Restore the auxiliary info from an empty variable
7451 previously created for changed_variables, so it is
7452 not lost. */
7453 gcc_checking_assert (!VAR_LOC_1PAUX (var));
7454 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (old_var);
7455 VAR_LOC_1PAUX (old_var) = NULL;
7457 variable_htab_free (*slot);
7460 if (set && var->n_var_parts == 0)
7462 onepart_enum onepart = var->onepart;
7463 variable *empty_var = NULL;
7464 variable **dslot = NULL;
7466 if (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR)
7468 dslot = dropped_values->find_slot_with_hash (var->dv,
7469 dv_htab_hash (var->dv),
7470 INSERT);
7471 empty_var = *dslot;
7473 if (empty_var)
7475 gcc_checking_assert (!empty_var->in_changed_variables);
7476 if (!VAR_LOC_1PAUX (var))
7478 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (empty_var);
7479 VAR_LOC_1PAUX (empty_var) = NULL;
7481 else
7482 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
7486 if (!empty_var)
7488 empty_var = onepart_pool_allocate (onepart);
7489 empty_var->dv = var->dv;
7490 empty_var->refcount = 1;
7491 empty_var->n_var_parts = 0;
7492 empty_var->onepart = onepart;
7493 if (dslot)
7495 empty_var->refcount++;
7496 *dslot = empty_var;
7499 else
7500 empty_var->refcount++;
7501 empty_var->in_changed_variables = true;
7502 *slot = empty_var;
7503 if (onepart)
7505 empty_var->var_part[0].loc_chain = NULL;
7506 empty_var->var_part[0].cur_loc = NULL;
7507 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (var);
7508 VAR_LOC_1PAUX (var) = NULL;
7510 goto drop_var;
7512 else
7514 if (var->onepart && !VAR_LOC_1PAUX (var))
7515 recover_dropped_1paux (var);
7516 var->refcount++;
7517 var->in_changed_variables = true;
7518 *slot = var;
7521 else
7523 gcc_assert (set);
7524 if (var->n_var_parts == 0)
7526 variable **slot;
7528 drop_var:
7529 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
7530 if (slot)
7532 if (shared_hash_shared (set->vars))
7533 slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
7534 NO_INSERT);
7535 shared_hash_htab (set->vars)->clear_slot (slot);
7541 /* Look for the index in VAR->var_part corresponding to OFFSET.
7542 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7543 referenced int will be set to the index that the part has or should
7544 have, if it should be inserted. */
7546 static inline int
7547 find_variable_location_part (variable *var, HOST_WIDE_INT offset,
7548 int *insertion_point)
7550 int pos, low, high;
7552 if (var->onepart)
7554 if (offset != 0)
7555 return -1;
7557 if (insertion_point)
7558 *insertion_point = 0;
7560 return var->n_var_parts - 1;
7563 /* Find the location part. */
7564 low = 0;
7565 high = var->n_var_parts;
7566 while (low != high)
7568 pos = (low + high) / 2;
7569 if (VAR_PART_OFFSET (var, pos) < offset)
7570 low = pos + 1;
7571 else
7572 high = pos;
7574 pos = low;
7576 if (insertion_point)
7577 *insertion_point = pos;
7579 if (pos < var->n_var_parts && VAR_PART_OFFSET (var, pos) == offset)
7580 return pos;
7582 return -1;
7585 static variable **
7586 set_slot_part (dataflow_set *set, rtx loc, variable **slot,
7587 decl_or_value dv, HOST_WIDE_INT offset,
7588 enum var_init_status initialized, rtx set_src)
7590 int pos;
7591 location_chain *node, *next;
7592 location_chain **nextp;
7593 variable *var;
7594 onepart_enum onepart;
7596 var = *slot;
7598 if (var)
7599 onepart = var->onepart;
7600 else
7601 onepart = dv_onepart_p (dv);
7603 gcc_checking_assert (offset == 0 || !onepart);
7604 gcc_checking_assert (loc != dv_as_opaque (dv));
7606 if (! flag_var_tracking_uninit)
7607 initialized = VAR_INIT_STATUS_INITIALIZED;
7609 if (!var)
7611 /* Create new variable information. */
7612 var = onepart_pool_allocate (onepart);
7613 var->dv = dv;
7614 var->refcount = 1;
7615 var->n_var_parts = 1;
7616 var->onepart = onepart;
7617 var->in_changed_variables = false;
7618 if (var->onepart)
7619 VAR_LOC_1PAUX (var) = NULL;
7620 else
7621 VAR_PART_OFFSET (var, 0) = offset;
7622 var->var_part[0].loc_chain = NULL;
7623 var->var_part[0].cur_loc = NULL;
7624 *slot = var;
7625 pos = 0;
7626 nextp = &var->var_part[0].loc_chain;
7628 else if (onepart)
7630 int r = -1, c = 0;
7632 gcc_assert (dv_as_opaque (var->dv) == dv_as_opaque (dv));
7634 pos = 0;
7636 if (GET_CODE (loc) == VALUE)
7638 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7639 nextp = &node->next)
7640 if (GET_CODE (node->loc) == VALUE)
7642 if (node->loc == loc)
7644 r = 0;
7645 break;
7647 if (canon_value_cmp (node->loc, loc))
7648 c++;
7649 else
7651 r = 1;
7652 break;
7655 else if (REG_P (node->loc) || MEM_P (node->loc))
7656 c++;
7657 else
7659 r = 1;
7660 break;
7663 else if (REG_P (loc))
7665 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7666 nextp = &node->next)
7667 if (REG_P (node->loc))
7669 if (REGNO (node->loc) < REGNO (loc))
7670 c++;
7671 else
7673 if (REGNO (node->loc) == REGNO (loc))
7674 r = 0;
7675 else
7676 r = 1;
7677 break;
7680 else
7682 r = 1;
7683 break;
7686 else if (MEM_P (loc))
7688 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7689 nextp = &node->next)
7690 if (REG_P (node->loc))
7691 c++;
7692 else if (MEM_P (node->loc))
7694 if ((r = loc_cmp (XEXP (node->loc, 0), XEXP (loc, 0))) >= 0)
7695 break;
7696 else
7697 c++;
7699 else
7701 r = 1;
7702 break;
7705 else
7706 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7707 nextp = &node->next)
7708 if ((r = loc_cmp (node->loc, loc)) >= 0)
7709 break;
7710 else
7711 c++;
7713 if (r == 0)
7714 return slot;
7716 if (shared_var_p (var, set->vars))
7718 slot = unshare_variable (set, slot, var, initialized);
7719 var = *slot;
7720 for (nextp = &var->var_part[0].loc_chain; c;
7721 nextp = &(*nextp)->next)
7722 c--;
7723 gcc_assert ((!node && !*nextp) || node->loc == (*nextp)->loc);
7726 else
7728 int inspos = 0;
7730 gcc_assert (dv_as_decl (var->dv) == dv_as_decl (dv));
7732 pos = find_variable_location_part (var, offset, &inspos);
7734 if (pos >= 0)
7736 node = var->var_part[pos].loc_chain;
7738 if (node
7739 && ((REG_P (node->loc) && REG_P (loc)
7740 && REGNO (node->loc) == REGNO (loc))
7741 || rtx_equal_p (node->loc, loc)))
7743 /* LOC is in the beginning of the chain so we have nothing
7744 to do. */
7745 if (node->init < initialized)
7746 node->init = initialized;
7747 if (set_src != NULL)
7748 node->set_src = set_src;
7750 return slot;
7752 else
7754 /* We have to make a copy of a shared variable. */
7755 if (shared_var_p (var, set->vars))
7757 slot = unshare_variable (set, slot, var, initialized);
7758 var = *slot;
7762 else
7764 /* We have not found the location part, new one will be created. */
7766 /* We have to make a copy of the shared variable. */
7767 if (shared_var_p (var, set->vars))
7769 slot = unshare_variable (set, slot, var, initialized);
7770 var = *slot;
7773 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7774 thus there are at most MAX_VAR_PARTS different offsets. */
7775 gcc_assert (var->n_var_parts < MAX_VAR_PARTS
7776 && (!var->n_var_parts || !onepart));
7778 /* We have to move the elements of array starting at index
7779 inspos to the next position. */
7780 for (pos = var->n_var_parts; pos > inspos; pos--)
7781 var->var_part[pos] = var->var_part[pos - 1];
7783 var->n_var_parts++;
7784 gcc_checking_assert (!onepart);
7785 VAR_PART_OFFSET (var, pos) = offset;
7786 var->var_part[pos].loc_chain = NULL;
7787 var->var_part[pos].cur_loc = NULL;
7790 /* Delete the location from the list. */
7791 nextp = &var->var_part[pos].loc_chain;
7792 for (node = var->var_part[pos].loc_chain; node; node = next)
7794 next = node->next;
7795 if ((REG_P (node->loc) && REG_P (loc)
7796 && REGNO (node->loc) == REGNO (loc))
7797 || rtx_equal_p (node->loc, loc))
7799 /* Save these values, to assign to the new node, before
7800 deleting this one. */
7801 if (node->init > initialized)
7802 initialized = node->init;
7803 if (node->set_src != NULL && set_src == NULL)
7804 set_src = node->set_src;
7805 if (var->var_part[pos].cur_loc == node->loc)
7806 var->var_part[pos].cur_loc = NULL;
7807 delete node;
7808 *nextp = next;
7809 break;
7811 else
7812 nextp = &node->next;
7815 nextp = &var->var_part[pos].loc_chain;
7818 /* Add the location to the beginning. */
7819 node = new location_chain;
7820 node->loc = loc;
7821 node->init = initialized;
7822 node->set_src = set_src;
7823 node->next = *nextp;
7824 *nextp = node;
7826 /* If no location was emitted do so. */
7827 if (var->var_part[pos].cur_loc == NULL)
7828 variable_was_changed (var, set);
7830 return slot;
7833 /* Set the part of variable's location in the dataflow set SET. The
7834 variable part is specified by variable's declaration in DV and
7835 offset OFFSET and the part's location by LOC. IOPT should be
7836 NO_INSERT if the variable is known to be in SET already and the
7837 variable hash table must not be resized, and INSERT otherwise. */
7839 static void
7840 set_variable_part (dataflow_set *set, rtx loc,
7841 decl_or_value dv, HOST_WIDE_INT offset,
7842 enum var_init_status initialized, rtx set_src,
7843 enum insert_option iopt)
7845 variable **slot;
7847 if (iopt == NO_INSERT)
7848 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7849 else
7851 slot = shared_hash_find_slot (set->vars, dv);
7852 if (!slot)
7853 slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
7855 set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
7858 /* Remove all recorded register locations for the given variable part
7859 from dataflow set SET, except for those that are identical to loc.
7860 The variable part is specified by variable's declaration or value
7861 DV and offset OFFSET. */
7863 static variable **
7864 clobber_slot_part (dataflow_set *set, rtx loc, variable **slot,
7865 HOST_WIDE_INT offset, rtx set_src)
7867 variable *var = *slot;
7868 int pos = find_variable_location_part (var, offset, NULL);
7870 if (pos >= 0)
7872 location_chain *node, *next;
7874 /* Remove the register locations from the dataflow set. */
7875 next = var->var_part[pos].loc_chain;
7876 for (node = next; node; node = next)
7878 next = node->next;
7879 if (node->loc != loc
7880 && (!flag_var_tracking_uninit
7881 || !set_src
7882 || MEM_P (set_src)
7883 || !rtx_equal_p (set_src, node->set_src)))
7885 if (REG_P (node->loc))
7887 attrs *anode, *anext;
7888 attrs **anextp;
7890 /* Remove the variable part from the register's
7891 list, but preserve any other variable parts
7892 that might be regarded as live in that same
7893 register. */
7894 anextp = &set->regs[REGNO (node->loc)];
7895 for (anode = *anextp; anode; anode = anext)
7897 anext = anode->next;
7898 if (dv_as_opaque (anode->dv) == dv_as_opaque (var->dv)
7899 && anode->offset == offset)
7901 delete anode;
7902 *anextp = anext;
7904 else
7905 anextp = &anode->next;
7909 slot = delete_slot_part (set, node->loc, slot, offset);
7914 return slot;
7917 /* Remove all recorded register locations for the given variable part
7918 from dataflow set SET, except for those that are identical to loc.
7919 The variable part is specified by variable's declaration or value
7920 DV and offset OFFSET. */
7922 static void
7923 clobber_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
7924 HOST_WIDE_INT offset, rtx set_src)
7926 variable **slot;
7928 if (!dv_as_opaque (dv)
7929 || (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
7930 return;
7932 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7933 if (!slot)
7934 return;
7936 clobber_slot_part (set, loc, slot, offset, set_src);
7939 /* Delete the part of variable's location from dataflow set SET. The
7940 variable part is specified by its SET->vars slot SLOT and offset
7941 OFFSET and the part's location by LOC. */
7943 static variable **
7944 delete_slot_part (dataflow_set *set, rtx loc, variable **slot,
7945 HOST_WIDE_INT offset)
7947 variable *var = *slot;
7948 int pos = find_variable_location_part (var, offset, NULL);
7950 if (pos >= 0)
7952 location_chain *node, *next;
7953 location_chain **nextp;
7954 bool changed;
7955 rtx cur_loc;
7957 if (shared_var_p (var, set->vars))
7959 /* If the variable contains the location part we have to
7960 make a copy of the variable. */
7961 for (node = var->var_part[pos].loc_chain; node;
7962 node = node->next)
7964 if ((REG_P (node->loc) && REG_P (loc)
7965 && REGNO (node->loc) == REGNO (loc))
7966 || rtx_equal_p (node->loc, loc))
7968 slot = unshare_variable (set, slot, var,
7969 VAR_INIT_STATUS_UNKNOWN);
7970 var = *slot;
7971 break;
7976 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
7977 cur_loc = VAR_LOC_FROM (var);
7978 else
7979 cur_loc = var->var_part[pos].cur_loc;
7981 /* Delete the location part. */
7982 changed = false;
7983 nextp = &var->var_part[pos].loc_chain;
7984 for (node = *nextp; node; node = next)
7986 next = node->next;
7987 if ((REG_P (node->loc) && REG_P (loc)
7988 && REGNO (node->loc) == REGNO (loc))
7989 || rtx_equal_p (node->loc, loc))
7991 /* If we have deleted the location which was last emitted
7992 we have to emit new location so add the variable to set
7993 of changed variables. */
7994 if (cur_loc == node->loc)
7996 changed = true;
7997 var->var_part[pos].cur_loc = NULL;
7998 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
7999 VAR_LOC_FROM (var) = NULL;
8001 delete node;
8002 *nextp = next;
8003 break;
8005 else
8006 nextp = &node->next;
8009 if (var->var_part[pos].loc_chain == NULL)
8011 changed = true;
8012 var->n_var_parts--;
8013 while (pos < var->n_var_parts)
8015 var->var_part[pos] = var->var_part[pos + 1];
8016 pos++;
8019 if (changed)
8020 variable_was_changed (var, set);
8023 return slot;
8026 /* Delete the part of variable's location from dataflow set SET. The
8027 variable part is specified by variable's declaration or value DV
8028 and offset OFFSET and the part's location by LOC. */
8030 static void
8031 delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
8032 HOST_WIDE_INT offset)
8034 variable **slot = shared_hash_find_slot_noinsert (set->vars, dv);
8035 if (!slot)
8036 return;
8038 delete_slot_part (set, loc, slot, offset);
8042 /* Structure for passing some other parameters to function
8043 vt_expand_loc_callback. */
8044 struct expand_loc_callback_data
8046 /* The variables and values active at this point. */
8047 variable_table_type *vars;
8049 /* Stack of values and debug_exprs under expansion, and their
8050 children. */
8051 auto_vec<rtx, 4> expanding;
8053 /* Stack of values and debug_exprs whose expansion hit recursion
8054 cycles. They will have VALUE_RECURSED_INTO marked when added to
8055 this list. This flag will be cleared if any of its dependencies
8056 resolves to a valid location. So, if the flag remains set at the
8057 end of the search, we know no valid location for this one can
8058 possibly exist. */
8059 auto_vec<rtx, 4> pending;
8061 /* The maximum depth among the sub-expressions under expansion.
8062 Zero indicates no expansion so far. */
8063 expand_depth depth;
8066 /* Allocate the one-part auxiliary data structure for VAR, with enough
8067 room for COUNT dependencies. */
8069 static void
8070 loc_exp_dep_alloc (variable *var, int count)
8072 size_t allocsize;
8074 gcc_checking_assert (var->onepart);
8076 /* We can be called with COUNT == 0 to allocate the data structure
8077 without any dependencies, e.g. for the backlinks only. However,
8078 if we are specifying a COUNT, then the dependency list must have
8079 been emptied before. It would be possible to adjust pointers or
8080 force it empty here, but this is better done at an earlier point
8081 in the algorithm, so we instead leave an assertion to catch
8082 errors. */
8083 gcc_checking_assert (!count
8084 || VAR_LOC_DEP_VEC (var) == NULL
8085 || VAR_LOC_DEP_VEC (var)->is_empty ());
8087 if (VAR_LOC_1PAUX (var) && VAR_LOC_DEP_VEC (var)->space (count))
8088 return;
8090 allocsize = offsetof (struct onepart_aux, deps)
8091 + vec<loc_exp_dep, va_heap, vl_embed>::embedded_size (count);
8093 if (VAR_LOC_1PAUX (var))
8095 VAR_LOC_1PAUX (var) = XRESIZEVAR (struct onepart_aux,
8096 VAR_LOC_1PAUX (var), allocsize);
8097 /* If the reallocation moves the onepaux structure, the
8098 back-pointer to BACKLINKS in the first list member will still
8099 point to its old location. Adjust it. */
8100 if (VAR_LOC_DEP_LST (var))
8101 VAR_LOC_DEP_LST (var)->pprev = VAR_LOC_DEP_LSTP (var);
8103 else
8105 VAR_LOC_1PAUX (var) = XNEWVAR (struct onepart_aux, allocsize);
8106 *VAR_LOC_DEP_LSTP (var) = NULL;
8107 VAR_LOC_FROM (var) = NULL;
8108 VAR_LOC_DEPTH (var).complexity = 0;
8109 VAR_LOC_DEPTH (var).entryvals = 0;
8111 VAR_LOC_DEP_VEC (var)->embedded_init (count);
8114 /* Remove all entries from the vector of active dependencies of VAR,
8115 removing them from the back-links lists too. */
8117 static void
8118 loc_exp_dep_clear (variable *var)
8120 while (VAR_LOC_DEP_VEC (var) && !VAR_LOC_DEP_VEC (var)->is_empty ())
8122 loc_exp_dep *led = &VAR_LOC_DEP_VEC (var)->last ();
8123 if (led->next)
8124 led->next->pprev = led->pprev;
8125 if (led->pprev)
8126 *led->pprev = led->next;
8127 VAR_LOC_DEP_VEC (var)->pop ();
8131 /* Insert an active dependency from VAR on X to the vector of
8132 dependencies, and add the corresponding back-link to X's list of
8133 back-links in VARS. */
8135 static void
8136 loc_exp_insert_dep (variable *var, rtx x, variable_table_type *vars)
8138 decl_or_value dv;
8139 variable *xvar;
8140 loc_exp_dep *led;
8142 dv = dv_from_rtx (x);
8144 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8145 an additional look up? */
8146 xvar = vars->find_with_hash (dv, dv_htab_hash (dv));
8148 if (!xvar)
8150 xvar = variable_from_dropped (dv, NO_INSERT);
8151 gcc_checking_assert (xvar);
8154 /* No point in adding the same backlink more than once. This may
8155 arise if say the same value appears in two complex expressions in
8156 the same loc_list, or even more than once in a single
8157 expression. */
8158 if (VAR_LOC_DEP_LST (xvar) && VAR_LOC_DEP_LST (xvar)->dv == var->dv)
8159 return;
8161 if (var->onepart == NOT_ONEPART)
8162 led = new loc_exp_dep;
8163 else
8165 loc_exp_dep empty;
8166 memset (&empty, 0, sizeof (empty));
8167 VAR_LOC_DEP_VEC (var)->quick_push (empty);
8168 led = &VAR_LOC_DEP_VEC (var)->last ();
8170 led->dv = var->dv;
8171 led->value = x;
8173 loc_exp_dep_alloc (xvar, 0);
8174 led->pprev = VAR_LOC_DEP_LSTP (xvar);
8175 led->next = *led->pprev;
8176 if (led->next)
8177 led->next->pprev = &led->next;
8178 *led->pprev = led;
8181 /* Create active dependencies of VAR on COUNT values starting at
8182 VALUE, and corresponding back-links to the entries in VARS. Return
8183 true if we found any pending-recursion results. */
8185 static bool
8186 loc_exp_dep_set (variable *var, rtx result, rtx *value, int count,
8187 variable_table_type *vars)
8189 bool pending_recursion = false;
8191 gcc_checking_assert (VAR_LOC_DEP_VEC (var) == NULL
8192 || VAR_LOC_DEP_VEC (var)->is_empty ());
8194 /* Set up all dependencies from last_child (as set up at the end of
8195 the loop above) to the end. */
8196 loc_exp_dep_alloc (var, count);
8198 while (count--)
8200 rtx x = *value++;
8202 if (!pending_recursion)
8203 pending_recursion = !result && VALUE_RECURSED_INTO (x);
8205 loc_exp_insert_dep (var, x, vars);
8208 return pending_recursion;
8211 /* Notify the back-links of IVAR that are pending recursion that we
8212 have found a non-NIL value for it, so they are cleared for another
8213 attempt to compute a current location. */
8215 static void
8216 notify_dependents_of_resolved_value (variable *ivar, variable_table_type *vars)
8218 loc_exp_dep *led, *next;
8220 for (led = VAR_LOC_DEP_LST (ivar); led; led = next)
8222 decl_or_value dv = led->dv;
8223 variable *var;
8225 next = led->next;
8227 if (dv_is_value_p (dv))
8229 rtx value = dv_as_value (dv);
8231 /* If we have already resolved it, leave it alone. */
8232 if (!VALUE_RECURSED_INTO (value))
8233 continue;
8235 /* Check that VALUE_RECURSED_INTO, true from the test above,
8236 implies NO_LOC_P. */
8237 gcc_checking_assert (NO_LOC_P (value));
8239 /* We won't notify variables that are being expanded,
8240 because their dependency list is cleared before
8241 recursing. */
8242 NO_LOC_P (value) = false;
8243 VALUE_RECURSED_INTO (value) = false;
8245 gcc_checking_assert (dv_changed_p (dv));
8247 else
8249 gcc_checking_assert (dv_onepart_p (dv) != NOT_ONEPART);
8250 if (!dv_changed_p (dv))
8251 continue;
8254 var = vars->find_with_hash (dv, dv_htab_hash (dv));
8256 if (!var)
8257 var = variable_from_dropped (dv, NO_INSERT);
8259 if (var)
8260 notify_dependents_of_resolved_value (var, vars);
8262 if (next)
8263 next->pprev = led->pprev;
8264 if (led->pprev)
8265 *led->pprev = next;
8266 led->next = NULL;
8267 led->pprev = NULL;
8271 static rtx vt_expand_loc_callback (rtx x, bitmap regs,
8272 int max_depth, void *data);
8274 /* Return the combined depth, when one sub-expression evaluated to
8275 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8277 static inline expand_depth
8278 update_depth (expand_depth saved_depth, expand_depth best_depth)
8280 /* If we didn't find anything, stick with what we had. */
8281 if (!best_depth.complexity)
8282 return saved_depth;
8284 /* If we found hadn't found anything, use the depth of the current
8285 expression. Do NOT add one extra level, we want to compute the
8286 maximum depth among sub-expressions. We'll increment it later,
8287 if appropriate. */
8288 if (!saved_depth.complexity)
8289 return best_depth;
8291 /* Combine the entryval count so that regardless of which one we
8292 return, the entryval count is accurate. */
8293 best_depth.entryvals = saved_depth.entryvals
8294 = best_depth.entryvals + saved_depth.entryvals;
8296 if (saved_depth.complexity < best_depth.complexity)
8297 return best_depth;
8298 else
8299 return saved_depth;
8302 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8303 DATA for cselib expand callback. If PENDRECP is given, indicate in
8304 it whether any sub-expression couldn't be fully evaluated because
8305 it is pending recursion resolution. */
8307 static inline rtx
8308 vt_expand_var_loc_chain (variable *var, bitmap regs, void *data,
8309 bool *pendrecp)
8311 struct expand_loc_callback_data *elcd
8312 = (struct expand_loc_callback_data *) data;
8313 location_chain *loc, *next;
8314 rtx result = NULL;
8315 int first_child, result_first_child, last_child;
8316 bool pending_recursion;
8317 rtx loc_from = NULL;
8318 struct elt_loc_list *cloc = NULL;
8319 expand_depth depth = { 0, 0 }, saved_depth = elcd->depth;
8320 int wanted_entryvals, found_entryvals = 0;
8322 /* Clear all backlinks pointing at this, so that we're not notified
8323 while we're active. */
8324 loc_exp_dep_clear (var);
8326 retry:
8327 if (var->onepart == ONEPART_VALUE)
8329 cselib_val *val = CSELIB_VAL_PTR (dv_as_value (var->dv));
8331 gcc_checking_assert (cselib_preserved_value_p (val));
8333 cloc = val->locs;
8336 first_child = result_first_child = last_child
8337 = elcd->expanding.length ();
8339 wanted_entryvals = found_entryvals;
8341 /* Attempt to expand each available location in turn. */
8342 for (next = loc = var->n_var_parts ? var->var_part[0].loc_chain : NULL;
8343 loc || cloc; loc = next)
8345 result_first_child = last_child;
8347 if (!loc)
8349 loc_from = cloc->loc;
8350 next = loc;
8351 cloc = cloc->next;
8352 if (unsuitable_loc (loc_from))
8353 continue;
8355 else
8357 loc_from = loc->loc;
8358 next = loc->next;
8361 gcc_checking_assert (!unsuitable_loc (loc_from));
8363 elcd->depth.complexity = elcd->depth.entryvals = 0;
8364 result = cselib_expand_value_rtx_cb (loc_from, regs, EXPR_DEPTH,
8365 vt_expand_loc_callback, data);
8366 last_child = elcd->expanding.length ();
8368 if (result)
8370 depth = elcd->depth;
8372 gcc_checking_assert (depth.complexity
8373 || result_first_child == last_child);
8375 if (last_child - result_first_child != 1)
8377 if (!depth.complexity && GET_CODE (result) == ENTRY_VALUE)
8378 depth.entryvals++;
8379 depth.complexity++;
8382 if (depth.complexity <= EXPR_USE_DEPTH)
8384 if (depth.entryvals <= wanted_entryvals)
8385 break;
8386 else if (!found_entryvals || depth.entryvals < found_entryvals)
8387 found_entryvals = depth.entryvals;
8390 result = NULL;
8393 /* Set it up in case we leave the loop. */
8394 depth.complexity = depth.entryvals = 0;
8395 loc_from = NULL;
8396 result_first_child = first_child;
8399 if (!loc_from && wanted_entryvals < found_entryvals)
8401 /* We found entries with ENTRY_VALUEs and skipped them. Since
8402 we could not find any expansions without ENTRY_VALUEs, but we
8403 found at least one with them, go back and get an entry with
8404 the minimum number ENTRY_VALUE count that we found. We could
8405 avoid looping, but since each sub-loc is already resolved,
8406 the re-expansion should be trivial. ??? Should we record all
8407 attempted locs as dependencies, so that we retry the
8408 expansion should any of them change, in the hope it can give
8409 us a new entry without an ENTRY_VALUE? */
8410 elcd->expanding.truncate (first_child);
8411 goto retry;
8414 /* Register all encountered dependencies as active. */
8415 pending_recursion = loc_exp_dep_set
8416 (var, result, elcd->expanding.address () + result_first_child,
8417 last_child - result_first_child, elcd->vars);
8419 elcd->expanding.truncate (first_child);
8421 /* Record where the expansion came from. */
8422 gcc_checking_assert (!result || !pending_recursion);
8423 VAR_LOC_FROM (var) = loc_from;
8424 VAR_LOC_DEPTH (var) = depth;
8426 gcc_checking_assert (!depth.complexity == !result);
8428 elcd->depth = update_depth (saved_depth, depth);
8430 /* Indicate whether any of the dependencies are pending recursion
8431 resolution. */
8432 if (pendrecp)
8433 *pendrecp = pending_recursion;
8435 if (!pendrecp || !pending_recursion)
8436 var->var_part[0].cur_loc = result;
8438 return result;
8441 /* Callback for cselib_expand_value, that looks for expressions
8442 holding the value in the var-tracking hash tables. Return X for
8443 standard processing, anything else is to be used as-is. */
8445 static rtx
8446 vt_expand_loc_callback (rtx x, bitmap regs,
8447 int max_depth ATTRIBUTE_UNUSED,
8448 void *data)
8450 struct expand_loc_callback_data *elcd
8451 = (struct expand_loc_callback_data *) data;
8452 decl_or_value dv;
8453 variable *var;
8454 rtx result, subreg;
8455 bool pending_recursion = false;
8456 bool from_empty = false;
8458 switch (GET_CODE (x))
8460 case SUBREG:
8461 subreg = cselib_expand_value_rtx_cb (SUBREG_REG (x), regs,
8462 EXPR_DEPTH,
8463 vt_expand_loc_callback, data);
8465 if (!subreg)
8466 return NULL;
8468 result = simplify_gen_subreg (GET_MODE (x), subreg,
8469 GET_MODE (SUBREG_REG (x)),
8470 SUBREG_BYTE (x));
8472 /* Invalid SUBREGs are ok in debug info. ??? We could try
8473 alternate expansions for the VALUE as well. */
8474 if (!result)
8475 result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
8477 return result;
8479 case DEBUG_EXPR:
8480 case VALUE:
8481 dv = dv_from_rtx (x);
8482 break;
8484 default:
8485 return x;
8488 elcd->expanding.safe_push (x);
8490 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8491 gcc_checking_assert (!VALUE_RECURSED_INTO (x) || NO_LOC_P (x));
8493 if (NO_LOC_P (x))
8495 gcc_checking_assert (VALUE_RECURSED_INTO (x) || !dv_changed_p (dv));
8496 return NULL;
8499 var = elcd->vars->find_with_hash (dv, dv_htab_hash (dv));
8501 if (!var)
8503 from_empty = true;
8504 var = variable_from_dropped (dv, INSERT);
8507 gcc_checking_assert (var);
8509 if (!dv_changed_p (dv))
8511 gcc_checking_assert (!NO_LOC_P (x));
8512 gcc_checking_assert (var->var_part[0].cur_loc);
8513 gcc_checking_assert (VAR_LOC_1PAUX (var));
8514 gcc_checking_assert (VAR_LOC_1PAUX (var)->depth.complexity);
8516 elcd->depth = update_depth (elcd->depth, VAR_LOC_1PAUX (var)->depth);
8518 return var->var_part[0].cur_loc;
8521 VALUE_RECURSED_INTO (x) = true;
8522 /* This is tentative, but it makes some tests simpler. */
8523 NO_LOC_P (x) = true;
8525 gcc_checking_assert (var->n_var_parts == 1 || from_empty);
8527 result = vt_expand_var_loc_chain (var, regs, data, &pending_recursion);
8529 if (pending_recursion)
8531 gcc_checking_assert (!result);
8532 elcd->pending.safe_push (x);
8534 else
8536 NO_LOC_P (x) = !result;
8537 VALUE_RECURSED_INTO (x) = false;
8538 set_dv_changed (dv, false);
8540 if (result)
8541 notify_dependents_of_resolved_value (var, elcd->vars);
8544 return result;
8547 /* While expanding variables, we may encounter recursion cycles
8548 because of mutual (possibly indirect) dependencies between two
8549 particular variables (or values), say A and B. If we're trying to
8550 expand A when we get to B, which in turn attempts to expand A, if
8551 we can't find any other expansion for B, we'll add B to this
8552 pending-recursion stack, and tentatively return NULL for its
8553 location. This tentative value will be used for any other
8554 occurrences of B, unless A gets some other location, in which case
8555 it will notify B that it is worth another try at computing a
8556 location for it, and it will use the location computed for A then.
8557 At the end of the expansion, the tentative NULL locations become
8558 final for all members of PENDING that didn't get a notification.
8559 This function performs this finalization of NULL locations. */
8561 static void
8562 resolve_expansions_pending_recursion (vec<rtx, va_heap> *pending)
8564 while (!pending->is_empty ())
8566 rtx x = pending->pop ();
8567 decl_or_value dv;
8569 if (!VALUE_RECURSED_INTO (x))
8570 continue;
8572 gcc_checking_assert (NO_LOC_P (x));
8573 VALUE_RECURSED_INTO (x) = false;
8574 dv = dv_from_rtx (x);
8575 gcc_checking_assert (dv_changed_p (dv));
8576 set_dv_changed (dv, false);
8580 /* Initialize expand_loc_callback_data D with variable hash table V.
8581 It must be a macro because of alloca (vec stack). */
8582 #define INIT_ELCD(d, v) \
8583 do \
8585 (d).vars = (v); \
8586 (d).depth.complexity = (d).depth.entryvals = 0; \
8588 while (0)
8589 /* Finalize expand_loc_callback_data D, resolved to location L. */
8590 #define FINI_ELCD(d, l) \
8591 do \
8593 resolve_expansions_pending_recursion (&(d).pending); \
8594 (d).pending.release (); \
8595 (d).expanding.release (); \
8597 if ((l) && MEM_P (l)) \
8598 (l) = targetm.delegitimize_address (l); \
8600 while (0)
8602 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8603 equivalences in VARS, updating their CUR_LOCs in the process. */
8605 static rtx
8606 vt_expand_loc (rtx loc, variable_table_type *vars)
8608 struct expand_loc_callback_data data;
8609 rtx result;
8611 if (!MAY_HAVE_DEBUG_BIND_INSNS)
8612 return loc;
8614 INIT_ELCD (data, vars);
8616 result = cselib_expand_value_rtx_cb (loc, scratch_regs, EXPR_DEPTH,
8617 vt_expand_loc_callback, &data);
8619 FINI_ELCD (data, result);
8621 return result;
8624 /* Expand the one-part VARiable to a location, using the equivalences
8625 in VARS, updating their CUR_LOCs in the process. */
8627 static rtx
8628 vt_expand_1pvar (variable *var, variable_table_type *vars)
8630 struct expand_loc_callback_data data;
8631 rtx loc;
8633 gcc_checking_assert (var->onepart && var->n_var_parts == 1);
8635 if (!dv_changed_p (var->dv))
8636 return var->var_part[0].cur_loc;
8638 INIT_ELCD (data, vars);
8640 loc = vt_expand_var_loc_chain (var, scratch_regs, &data, NULL);
8642 gcc_checking_assert (data.expanding.is_empty ());
8644 FINI_ELCD (data, loc);
8646 return loc;
8649 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8650 additional parameters: WHERE specifies whether the note shall be emitted
8651 before or after instruction INSN. */
8654 emit_note_insn_var_location (variable **varp, emit_note_data *data)
8656 variable *var = *varp;
8657 rtx_insn *insn = data->insn;
8658 enum emit_note_where where = data->where;
8659 variable_table_type *vars = data->vars;
8660 rtx_note *note;
8661 rtx note_vl;
8662 int i, j, n_var_parts;
8663 bool complete;
8664 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
8665 HOST_WIDE_INT last_limit;
8666 tree type_size_unit;
8667 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
8668 rtx loc[MAX_VAR_PARTS];
8669 tree decl;
8670 location_chain *lc;
8672 gcc_checking_assert (var->onepart == NOT_ONEPART
8673 || var->onepart == ONEPART_VDECL);
8675 decl = dv_as_decl (var->dv);
8677 complete = true;
8678 last_limit = 0;
8679 n_var_parts = 0;
8680 if (!var->onepart)
8681 for (i = 0; i < var->n_var_parts; i++)
8682 if (var->var_part[i].cur_loc == NULL && var->var_part[i].loc_chain)
8683 var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
8684 for (i = 0; i < var->n_var_parts; i++)
8686 machine_mode mode, wider_mode;
8687 rtx loc2;
8688 HOST_WIDE_INT offset, size, wider_size;
8690 if (i == 0 && var->onepart)
8692 gcc_checking_assert (var->n_var_parts == 1);
8693 offset = 0;
8694 initialized = VAR_INIT_STATUS_INITIALIZED;
8695 loc2 = vt_expand_1pvar (var, vars);
8697 else
8699 if (last_limit < VAR_PART_OFFSET (var, i))
8701 complete = false;
8702 break;
8704 else if (last_limit > VAR_PART_OFFSET (var, i))
8705 continue;
8706 offset = VAR_PART_OFFSET (var, i);
8707 loc2 = var->var_part[i].cur_loc;
8708 if (loc2 && GET_CODE (loc2) == MEM
8709 && GET_CODE (XEXP (loc2, 0)) == VALUE)
8711 rtx depval = XEXP (loc2, 0);
8713 loc2 = vt_expand_loc (loc2, vars);
8715 if (loc2)
8716 loc_exp_insert_dep (var, depval, vars);
8718 if (!loc2)
8720 complete = false;
8721 continue;
8723 gcc_checking_assert (GET_CODE (loc2) != VALUE);
8724 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
8725 if (var->var_part[i].cur_loc == lc->loc)
8727 initialized = lc->init;
8728 break;
8730 gcc_assert (lc);
8733 offsets[n_var_parts] = offset;
8734 if (!loc2)
8736 complete = false;
8737 continue;
8739 loc[n_var_parts] = loc2;
8740 mode = GET_MODE (var->var_part[i].cur_loc);
8741 if (mode == VOIDmode && var->onepart)
8742 mode = DECL_MODE (decl);
8743 /* We ony track subparts of constant-sized objects, since at present
8744 there's no representation for polynomial pieces. */
8745 if (!GET_MODE_SIZE (mode).is_constant (&size))
8747 complete = false;
8748 continue;
8750 last_limit = offsets[n_var_parts] + size;
8752 /* Attempt to merge adjacent registers or memory. */
8753 for (j = i + 1; j < var->n_var_parts; j++)
8754 if (last_limit <= VAR_PART_OFFSET (var, j))
8755 break;
8756 if (j < var->n_var_parts
8757 && GET_MODE_WIDER_MODE (mode).exists (&wider_mode)
8758 && GET_MODE_SIZE (wider_mode).is_constant (&wider_size)
8759 && var->var_part[j].cur_loc
8760 && mode == GET_MODE (var->var_part[j].cur_loc)
8761 && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
8762 && last_limit == (var->onepart ? 0 : VAR_PART_OFFSET (var, j))
8763 && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
8764 && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
8766 rtx new_loc = NULL;
8768 if (REG_P (loc[n_var_parts])
8769 && hard_regno_nregs (REGNO (loc[n_var_parts]), mode) * 2
8770 == hard_regno_nregs (REGNO (loc[n_var_parts]), wider_mode)
8771 && end_hard_regno (mode, REGNO (loc[n_var_parts]))
8772 == REGNO (loc2))
8774 if (! WORDS_BIG_ENDIAN && ! BYTES_BIG_ENDIAN)
8775 new_loc = simplify_subreg (wider_mode, loc[n_var_parts],
8776 mode, 0);
8777 else if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
8778 new_loc = simplify_subreg (wider_mode, loc2, mode, 0);
8779 if (new_loc)
8781 if (!REG_P (new_loc)
8782 || REGNO (new_loc) != REGNO (loc[n_var_parts]))
8783 new_loc = NULL;
8784 else
8785 REG_ATTRS (new_loc) = REG_ATTRS (loc[n_var_parts]);
8788 else if (MEM_P (loc[n_var_parts])
8789 && GET_CODE (XEXP (loc2, 0)) == PLUS
8790 && REG_P (XEXP (XEXP (loc2, 0), 0))
8791 && CONST_INT_P (XEXP (XEXP (loc2, 0), 1)))
8793 if ((REG_P (XEXP (loc[n_var_parts], 0))
8794 && rtx_equal_p (XEXP (loc[n_var_parts], 0),
8795 XEXP (XEXP (loc2, 0), 0))
8796 && INTVAL (XEXP (XEXP (loc2, 0), 1)) == size)
8797 || (GET_CODE (XEXP (loc[n_var_parts], 0)) == PLUS
8798 && CONST_INT_P (XEXP (XEXP (loc[n_var_parts], 0), 1))
8799 && rtx_equal_p (XEXP (XEXP (loc[n_var_parts], 0), 0),
8800 XEXP (XEXP (loc2, 0), 0))
8801 && INTVAL (XEXP (XEXP (loc[n_var_parts], 0), 1)) + size
8802 == INTVAL (XEXP (XEXP (loc2, 0), 1))))
8803 new_loc = adjust_address_nv (loc[n_var_parts],
8804 wider_mode, 0);
8807 if (new_loc)
8809 loc[n_var_parts] = new_loc;
8810 mode = wider_mode;
8811 last_limit = offsets[n_var_parts] + wider_size;
8812 i = j;
8815 ++n_var_parts;
8817 type_size_unit = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8818 if ((unsigned HOST_WIDE_INT) last_limit < TREE_INT_CST_LOW (type_size_unit))
8819 complete = false;
8821 if (! flag_var_tracking_uninit)
8822 initialized = VAR_INIT_STATUS_INITIALIZED;
8824 note_vl = NULL_RTX;
8825 if (!complete)
8826 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, NULL_RTX, initialized);
8827 else if (n_var_parts == 1)
8829 rtx expr_list;
8831 if (offsets[0] || GET_CODE (loc[0]) == PARALLEL)
8832 expr_list = gen_rtx_EXPR_LIST (VOIDmode, loc[0], GEN_INT (offsets[0]));
8833 else
8834 expr_list = loc[0];
8836 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, expr_list, initialized);
8838 else if (n_var_parts)
8840 rtx parallel;
8842 for (i = 0; i < n_var_parts; i++)
8843 loc[i]
8844 = gen_rtx_EXPR_LIST (VOIDmode, loc[i], GEN_INT (offsets[i]));
8846 parallel = gen_rtx_PARALLEL (VOIDmode,
8847 gen_rtvec_v (n_var_parts, loc));
8848 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl,
8849 parallel, initialized);
8852 if (where != EMIT_NOTE_BEFORE_INSN)
8854 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8855 if (where == EMIT_NOTE_AFTER_CALL_INSN)
8856 NOTE_DURING_CALL_P (note) = true;
8858 else
8860 /* Make sure that the call related notes come first. */
8861 while (NEXT_INSN (insn)
8862 && NOTE_P (insn)
8863 && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8864 && NOTE_DURING_CALL_P (insn))
8865 insn = NEXT_INSN (insn);
8866 if (NOTE_P (insn)
8867 && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8868 && NOTE_DURING_CALL_P (insn))
8869 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8870 else
8871 note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
8873 NOTE_VAR_LOCATION (note) = note_vl;
8875 set_dv_changed (var->dv, false);
8876 gcc_assert (var->in_changed_variables);
8877 var->in_changed_variables = false;
8878 changed_variables->clear_slot (varp);
8880 /* Continue traversing the hash table. */
8881 return 1;
8884 /* While traversing changed_variables, push onto DATA (a stack of RTX
8885 values) entries that aren't user variables. */
8888 var_track_values_to_stack (variable **slot,
8889 vec<rtx, va_heap> *changed_values_stack)
8891 variable *var = *slot;
8893 if (var->onepart == ONEPART_VALUE)
8894 changed_values_stack->safe_push (dv_as_value (var->dv));
8895 else if (var->onepart == ONEPART_DEXPR)
8896 changed_values_stack->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var->dv)));
8898 return 1;
8901 /* Remove from changed_variables the entry whose DV corresponds to
8902 value or debug_expr VAL. */
8903 static void
8904 remove_value_from_changed_variables (rtx val)
8906 decl_or_value dv = dv_from_rtx (val);
8907 variable **slot;
8908 variable *var;
8910 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8911 NO_INSERT);
8912 var = *slot;
8913 var->in_changed_variables = false;
8914 changed_variables->clear_slot (slot);
8917 /* If VAL (a value or debug_expr) has backlinks to variables actively
8918 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8919 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8920 have dependencies of their own to notify. */
8922 static void
8923 notify_dependents_of_changed_value (rtx val, variable_table_type *htab,
8924 vec<rtx, va_heap> *changed_values_stack)
8926 variable **slot;
8927 variable *var;
8928 loc_exp_dep *led;
8929 decl_or_value dv = dv_from_rtx (val);
8931 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8932 NO_INSERT);
8933 if (!slot)
8934 slot = htab->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT);
8935 if (!slot)
8936 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv),
8937 NO_INSERT);
8938 var = *slot;
8940 while ((led = VAR_LOC_DEP_LST (var)))
8942 decl_or_value ldv = led->dv;
8943 variable *ivar;
8945 /* Deactivate and remove the backlink, as it was “used up”. It
8946 makes no sense to attempt to notify the same entity again:
8947 either it will be recomputed and re-register an active
8948 dependency, or it will still have the changed mark. */
8949 if (led->next)
8950 led->next->pprev = led->pprev;
8951 if (led->pprev)
8952 *led->pprev = led->next;
8953 led->next = NULL;
8954 led->pprev = NULL;
8956 if (dv_changed_p (ldv))
8957 continue;
8959 switch (dv_onepart_p (ldv))
8961 case ONEPART_VALUE:
8962 case ONEPART_DEXPR:
8963 set_dv_changed (ldv, true);
8964 changed_values_stack->safe_push (dv_as_rtx (ldv));
8965 break;
8967 case ONEPART_VDECL:
8968 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8969 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar));
8970 variable_was_changed (ivar, NULL);
8971 break;
8973 case NOT_ONEPART:
8974 delete led;
8975 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8976 if (ivar)
8978 int i = ivar->n_var_parts;
8979 while (i--)
8981 rtx loc = ivar->var_part[i].cur_loc;
8983 if (loc && GET_CODE (loc) == MEM
8984 && XEXP (loc, 0) == val)
8986 variable_was_changed (ivar, NULL);
8987 break;
8991 break;
8993 default:
8994 gcc_unreachable ();
8999 /* Take out of changed_variables any entries that don't refer to use
9000 variables. Back-propagate change notifications from values and
9001 debug_exprs to their active dependencies in HTAB or in
9002 CHANGED_VARIABLES. */
9004 static void
9005 process_changed_values (variable_table_type *htab)
9007 int i, n;
9008 rtx val;
9009 auto_vec<rtx, 20> changed_values_stack;
9011 /* Move values from changed_variables to changed_values_stack. */
9012 changed_variables
9013 ->traverse <vec<rtx, va_heap>*, var_track_values_to_stack>
9014 (&changed_values_stack);
9016 /* Back-propagate change notifications in values while popping
9017 them from the stack. */
9018 for (n = i = changed_values_stack.length ();
9019 i > 0; i = changed_values_stack.length ())
9021 val = changed_values_stack.pop ();
9022 notify_dependents_of_changed_value (val, htab, &changed_values_stack);
9024 /* This condition will hold when visiting each of the entries
9025 originally in changed_variables. We can't remove them
9026 earlier because this could drop the backlinks before we got a
9027 chance to use them. */
9028 if (i == n)
9030 remove_value_from_changed_variables (val);
9031 n--;
9036 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
9037 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
9038 the notes shall be emitted before of after instruction INSN. */
9040 static void
9041 emit_notes_for_changes (rtx_insn *insn, enum emit_note_where where,
9042 shared_hash *vars)
9044 emit_note_data data;
9045 variable_table_type *htab = shared_hash_htab (vars);
9047 if (!changed_variables->elements ())
9048 return;
9050 if (MAY_HAVE_DEBUG_BIND_INSNS)
9051 process_changed_values (htab);
9053 data.insn = insn;
9054 data.where = where;
9055 data.vars = htab;
9057 changed_variables
9058 ->traverse <emit_note_data*, emit_note_insn_var_location> (&data);
9061 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9062 same variable in hash table DATA or is not there at all. */
9065 emit_notes_for_differences_1 (variable **slot, variable_table_type *new_vars)
9067 variable *old_var, *new_var;
9069 old_var = *slot;
9070 new_var = new_vars->find_with_hash (old_var->dv, dv_htab_hash (old_var->dv));
9072 if (!new_var)
9074 /* Variable has disappeared. */
9075 variable *empty_var = NULL;
9077 if (old_var->onepart == ONEPART_VALUE
9078 || old_var->onepart == ONEPART_DEXPR)
9080 empty_var = variable_from_dropped (old_var->dv, NO_INSERT);
9081 if (empty_var)
9083 gcc_checking_assert (!empty_var->in_changed_variables);
9084 if (!VAR_LOC_1PAUX (old_var))
9086 VAR_LOC_1PAUX (old_var) = VAR_LOC_1PAUX (empty_var);
9087 VAR_LOC_1PAUX (empty_var) = NULL;
9089 else
9090 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
9094 if (!empty_var)
9096 empty_var = onepart_pool_allocate (old_var->onepart);
9097 empty_var->dv = old_var->dv;
9098 empty_var->refcount = 0;
9099 empty_var->n_var_parts = 0;
9100 empty_var->onepart = old_var->onepart;
9101 empty_var->in_changed_variables = false;
9104 if (empty_var->onepart)
9106 /* Propagate the auxiliary data to (ultimately)
9107 changed_variables. */
9108 empty_var->var_part[0].loc_chain = NULL;
9109 empty_var->var_part[0].cur_loc = NULL;
9110 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (old_var);
9111 VAR_LOC_1PAUX (old_var) = NULL;
9113 variable_was_changed (empty_var, NULL);
9114 /* Continue traversing the hash table. */
9115 return 1;
9117 /* Update cur_loc and one-part auxiliary data, before new_var goes
9118 through variable_was_changed. */
9119 if (old_var != new_var && new_var->onepart)
9121 gcc_checking_assert (VAR_LOC_1PAUX (new_var) == NULL);
9122 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (old_var);
9123 VAR_LOC_1PAUX (old_var) = NULL;
9124 new_var->var_part[0].cur_loc = old_var->var_part[0].cur_loc;
9126 if (variable_different_p (old_var, new_var))
9127 variable_was_changed (new_var, NULL);
9129 /* Continue traversing the hash table. */
9130 return 1;
9133 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9134 table DATA. */
9137 emit_notes_for_differences_2 (variable **slot, variable_table_type *old_vars)
9139 variable *old_var, *new_var;
9141 new_var = *slot;
9142 old_var = old_vars->find_with_hash (new_var->dv, dv_htab_hash (new_var->dv));
9143 if (!old_var)
9145 int i;
9146 for (i = 0; i < new_var->n_var_parts; i++)
9147 new_var->var_part[i].cur_loc = NULL;
9148 variable_was_changed (new_var, NULL);
9151 /* Continue traversing the hash table. */
9152 return 1;
9155 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9156 NEW_SET. */
9158 static void
9159 emit_notes_for_differences (rtx_insn *insn, dataflow_set *old_set,
9160 dataflow_set *new_set)
9162 shared_hash_htab (old_set->vars)
9163 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9164 (shared_hash_htab (new_set->vars));
9165 shared_hash_htab (new_set->vars)
9166 ->traverse <variable_table_type *, emit_notes_for_differences_2>
9167 (shared_hash_htab (old_set->vars));
9168 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
9171 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9173 static rtx_insn *
9174 next_non_note_insn_var_location (rtx_insn *insn)
9176 while (insn)
9178 insn = NEXT_INSN (insn);
9179 if (insn == 0
9180 || !NOTE_P (insn)
9181 || NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION)
9182 break;
9185 return insn;
9188 /* Emit the notes for changes of location parts in the basic block BB. */
9190 static void
9191 emit_notes_in_bb (basic_block bb, dataflow_set *set)
9193 unsigned int i;
9194 micro_operation *mo;
9196 dataflow_set_clear (set);
9197 dataflow_set_copy (set, &VTI (bb)->in);
9199 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
9201 rtx_insn *insn = mo->insn;
9202 rtx_insn *next_insn = next_non_note_insn_var_location (insn);
9204 switch (mo->type)
9206 case MO_CALL:
9207 dataflow_set_clear_at_call (set, insn);
9208 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
9210 rtx arguments = mo->u.loc, *p = &arguments;
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))
9219 XEXP (XEXP (*p, 0), 1)
9220 = copy_rtx_if_shared (XEXP (XEXP (*p, 0), 1));
9221 p = &XEXP (*p, 1);
9223 /* Otherwise, if the following item is data_value for it,
9224 drop it too too. */
9225 else if (XEXP (*p, 1)
9226 && REG_P (XEXP (XEXP (*p, 0), 0))
9227 && MEM_P (XEXP (XEXP (XEXP (*p, 1), 0), 0))
9228 && REG_P (XEXP (XEXP (XEXP (XEXP (*p, 1), 0), 0),
9230 && REGNO (XEXP (XEXP (*p, 0), 0))
9231 == REGNO (XEXP (XEXP (XEXP (XEXP (*p, 1), 0),
9232 0), 0)))
9233 *p = XEXP (XEXP (*p, 1), 1);
9234 /* Just drop this item. */
9235 else
9236 *p = XEXP (*p, 1);
9238 add_reg_note (insn, REG_CALL_ARG_LOCATION, arguments);
9240 break;
9242 case MO_USE:
9244 rtx loc = mo->u.loc;
9246 if (REG_P (loc))
9247 var_reg_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9248 else
9249 var_mem_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9251 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9253 break;
9255 case MO_VAL_LOC:
9257 rtx loc = mo->u.loc;
9258 rtx val, vloc;
9259 tree var;
9261 if (GET_CODE (loc) == CONCAT)
9263 val = XEXP (loc, 0);
9264 vloc = XEXP (loc, 1);
9266 else
9268 val = NULL_RTX;
9269 vloc = loc;
9272 var = PAT_VAR_LOCATION_DECL (vloc);
9274 clobber_variable_part (set, NULL_RTX,
9275 dv_from_decl (var), 0, NULL_RTX);
9276 if (val)
9278 if (VAL_NEEDS_RESOLUTION (loc))
9279 val_resolve (set, val, PAT_VAR_LOCATION_LOC (vloc), insn);
9280 set_variable_part (set, val, dv_from_decl (var), 0,
9281 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9282 INSERT);
9284 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
9285 set_variable_part (set, PAT_VAR_LOCATION_LOC (vloc),
9286 dv_from_decl (var), 0,
9287 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9288 INSERT);
9290 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9292 break;
9294 case MO_VAL_USE:
9296 rtx loc = mo->u.loc;
9297 rtx val, vloc, uloc;
9299 vloc = uloc = XEXP (loc, 1);
9300 val = XEXP (loc, 0);
9302 if (GET_CODE (val) == CONCAT)
9304 uloc = XEXP (val, 1);
9305 val = XEXP (val, 0);
9308 if (VAL_NEEDS_RESOLUTION (loc))
9309 val_resolve (set, val, vloc, insn);
9310 else
9311 val_store (set, val, uloc, insn, false);
9313 if (VAL_HOLDS_TRACK_EXPR (loc))
9315 if (GET_CODE (uloc) == REG)
9316 var_reg_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9317 NULL);
9318 else if (GET_CODE (uloc) == MEM)
9319 var_mem_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9320 NULL);
9323 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9325 break;
9327 case MO_VAL_SET:
9329 rtx loc = mo->u.loc;
9330 rtx val, vloc, uloc;
9331 rtx dstv, srcv;
9333 vloc = loc;
9334 uloc = XEXP (vloc, 1);
9335 val = XEXP (vloc, 0);
9336 vloc = uloc;
9338 if (GET_CODE (uloc) == SET)
9340 dstv = SET_DEST (uloc);
9341 srcv = SET_SRC (uloc);
9343 else
9345 dstv = uloc;
9346 srcv = NULL;
9349 if (GET_CODE (val) == CONCAT)
9351 dstv = vloc = XEXP (val, 1);
9352 val = XEXP (val, 0);
9355 if (GET_CODE (vloc) == SET)
9357 srcv = SET_SRC (vloc);
9359 gcc_assert (val != srcv);
9360 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
9362 dstv = vloc = SET_DEST (vloc);
9364 if (VAL_NEEDS_RESOLUTION (loc))
9365 val_resolve (set, val, srcv, insn);
9367 else if (VAL_NEEDS_RESOLUTION (loc))
9369 gcc_assert (GET_CODE (uloc) == SET
9370 && GET_CODE (SET_SRC (uloc)) == REG);
9371 val_resolve (set, val, SET_SRC (uloc), insn);
9374 if (VAL_HOLDS_TRACK_EXPR (loc))
9376 if (VAL_EXPR_IS_CLOBBERED (loc))
9378 if (REG_P (uloc))
9379 var_reg_delete (set, uloc, true);
9380 else if (MEM_P (uloc))
9382 gcc_assert (MEM_P (dstv));
9383 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
9384 var_mem_delete (set, dstv, true);
9387 else
9389 bool copied_p = VAL_EXPR_IS_COPIED (loc);
9390 rtx src = NULL, dst = uloc;
9391 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
9393 if (GET_CODE (uloc) == SET)
9395 src = SET_SRC (uloc);
9396 dst = SET_DEST (uloc);
9399 if (copied_p)
9401 status = find_src_status (set, src);
9403 src = find_src_set_src (set, src);
9406 if (REG_P (dst))
9407 var_reg_delete_and_set (set, dst, !copied_p,
9408 status, srcv);
9409 else if (MEM_P (dst))
9411 gcc_assert (MEM_P (dstv));
9412 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
9413 var_mem_delete_and_set (set, dstv, !copied_p,
9414 status, srcv);
9418 else if (REG_P (uloc))
9419 var_regno_delete (set, REGNO (uloc));
9420 else if (MEM_P (uloc))
9422 gcc_checking_assert (GET_CODE (vloc) == MEM);
9423 gcc_checking_assert (vloc == dstv);
9424 if (vloc != dstv)
9425 clobber_overlapping_mems (set, vloc);
9428 val_store (set, val, dstv, insn, true);
9430 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9431 set->vars);
9433 break;
9435 case MO_SET:
9437 rtx loc = mo->u.loc;
9438 rtx set_src = NULL;
9440 if (GET_CODE (loc) == SET)
9442 set_src = SET_SRC (loc);
9443 loc = SET_DEST (loc);
9446 if (REG_P (loc))
9447 var_reg_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9448 set_src);
9449 else
9450 var_mem_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9451 set_src);
9453 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9454 set->vars);
9456 break;
9458 case MO_COPY:
9460 rtx loc = mo->u.loc;
9461 enum var_init_status src_status;
9462 rtx set_src = NULL;
9464 if (GET_CODE (loc) == SET)
9466 set_src = SET_SRC (loc);
9467 loc = SET_DEST (loc);
9470 src_status = find_src_status (set, set_src);
9471 set_src = find_src_set_src (set, set_src);
9473 if (REG_P (loc))
9474 var_reg_delete_and_set (set, loc, false, src_status, set_src);
9475 else
9476 var_mem_delete_and_set (set, loc, false, src_status, set_src);
9478 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9479 set->vars);
9481 break;
9483 case MO_USE_NO_VAR:
9485 rtx loc = mo->u.loc;
9487 if (REG_P (loc))
9488 var_reg_delete (set, loc, false);
9489 else
9490 var_mem_delete (set, loc, false);
9492 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9494 break;
9496 case MO_CLOBBER:
9498 rtx loc = mo->u.loc;
9500 if (REG_P (loc))
9501 var_reg_delete (set, loc, true);
9502 else
9503 var_mem_delete (set, loc, true);
9505 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9506 set->vars);
9508 break;
9510 case MO_ADJUST:
9511 set->stack_adjust += mo->u.adjust;
9512 break;
9517 /* Emit notes for the whole function. */
9519 static void
9520 vt_emit_notes (void)
9522 basic_block bb;
9523 dataflow_set cur;
9525 gcc_assert (!changed_variables->elements ());
9527 /* Free memory occupied by the out hash tables, as they aren't used
9528 anymore. */
9529 FOR_EACH_BB_FN (bb, cfun)
9530 dataflow_set_clear (&VTI (bb)->out);
9532 /* Enable emitting notes by functions (mainly by set_variable_part and
9533 delete_variable_part). */
9534 emit_notes = true;
9536 if (MAY_HAVE_DEBUG_BIND_INSNS)
9537 dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
9539 dataflow_set_init (&cur);
9541 FOR_EACH_BB_FN (bb, cfun)
9543 /* Emit the notes for changes of variable locations between two
9544 subsequent basic blocks. */
9545 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
9547 if (MAY_HAVE_DEBUG_BIND_INSNS)
9548 local_get_addr_cache = new hash_map<rtx, rtx>;
9550 /* Emit the notes for the changes in the basic block itself. */
9551 emit_notes_in_bb (bb, &cur);
9553 if (MAY_HAVE_DEBUG_BIND_INSNS)
9554 delete local_get_addr_cache;
9555 local_get_addr_cache = NULL;
9557 /* Free memory occupied by the in hash table, we won't need it
9558 again. */
9559 dataflow_set_clear (&VTI (bb)->in);
9562 if (flag_checking)
9563 shared_hash_htab (cur.vars)
9564 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9565 (shared_hash_htab (empty_shared_hash));
9567 dataflow_set_destroy (&cur);
9569 if (MAY_HAVE_DEBUG_BIND_INSNS)
9570 delete dropped_values;
9571 dropped_values = NULL;
9573 emit_notes = false;
9576 /* If there is a declaration and offset associated with register/memory RTL
9577 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9579 static bool
9580 vt_get_decl_and_offset (rtx rtl, tree *declp, poly_int64 *offsetp)
9582 if (REG_P (rtl))
9584 if (REG_ATTRS (rtl))
9586 *declp = REG_EXPR (rtl);
9587 *offsetp = REG_OFFSET (rtl);
9588 return true;
9591 else if (GET_CODE (rtl) == PARALLEL)
9593 tree decl = NULL_TREE;
9594 HOST_WIDE_INT offset = MAX_VAR_PARTS;
9595 int len = XVECLEN (rtl, 0), i;
9597 for (i = 0; i < len; i++)
9599 rtx reg = XEXP (XVECEXP (rtl, 0, i), 0);
9600 if (!REG_P (reg) || !REG_ATTRS (reg))
9601 break;
9602 if (!decl)
9603 decl = REG_EXPR (reg);
9604 if (REG_EXPR (reg) != decl)
9605 break;
9606 HOST_WIDE_INT this_offset;
9607 if (!track_offset_p (REG_OFFSET (reg), &this_offset))
9608 break;
9609 offset = MIN (offset, this_offset);
9612 if (i == len)
9614 *declp = decl;
9615 *offsetp = offset;
9616 return true;
9619 else if (MEM_P (rtl))
9621 if (MEM_ATTRS (rtl))
9623 *declp = MEM_EXPR (rtl);
9624 *offsetp = int_mem_offset (rtl);
9625 return true;
9628 return false;
9631 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9632 of VAL. */
9634 static void
9635 record_entry_value (cselib_val *val, rtx rtl)
9637 rtx ev = gen_rtx_ENTRY_VALUE (GET_MODE (rtl));
9639 ENTRY_VALUE_EXP (ev) = rtl;
9641 cselib_add_permanent_equiv (val, ev, get_insns ());
9644 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9646 static void
9647 vt_add_function_parameter (tree parm)
9649 rtx decl_rtl = DECL_RTL_IF_SET (parm);
9650 rtx incoming = DECL_INCOMING_RTL (parm);
9651 tree decl;
9652 machine_mode mode;
9653 poly_int64 offset;
9654 dataflow_set *out;
9655 decl_or_value dv;
9656 bool incoming_ok = true;
9658 if (TREE_CODE (parm) != PARM_DECL)
9659 return;
9661 if (!decl_rtl || !incoming)
9662 return;
9664 if (GET_MODE (decl_rtl) == BLKmode || GET_MODE (incoming) == BLKmode)
9665 return;
9667 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9668 rewrite the incoming location of parameters passed on the stack
9669 into MEMs based on the argument pointer, so that incoming doesn't
9670 depend on a pseudo. */
9671 if (MEM_P (incoming)
9672 && (XEXP (incoming, 0) == crtl->args.internal_arg_pointer
9673 || (GET_CODE (XEXP (incoming, 0)) == PLUS
9674 && XEXP (XEXP (incoming, 0), 0)
9675 == crtl->args.internal_arg_pointer
9676 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
9678 HOST_WIDE_INT off = -FIRST_PARM_OFFSET (current_function_decl);
9679 if (GET_CODE (XEXP (incoming, 0)) == PLUS)
9680 off += INTVAL (XEXP (XEXP (incoming, 0), 1));
9681 incoming
9682 = replace_equiv_address_nv (incoming,
9683 plus_constant (Pmode,
9684 arg_pointer_rtx, off));
9687 #ifdef HAVE_window_save
9688 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9689 If the target machine has an explicit window save instruction, the
9690 actual entry value is the corresponding OUTGOING_REGNO instead. */
9691 if (HAVE_window_save && !crtl->uses_only_leaf_regs)
9693 if (REG_P (incoming)
9694 && HARD_REGISTER_P (incoming)
9695 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
9697 parm_reg p;
9698 p.incoming = incoming;
9699 incoming
9700 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
9701 OUTGOING_REGNO (REGNO (incoming)), 0);
9702 p.outgoing = incoming;
9703 vec_safe_push (windowed_parm_regs, p);
9705 else if (GET_CODE (incoming) == PARALLEL)
9707 rtx outgoing
9708 = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (XVECLEN (incoming, 0)));
9709 int i;
9711 for (i = 0; i < XVECLEN (incoming, 0); i++)
9713 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9714 parm_reg p;
9715 p.incoming = reg;
9716 reg = gen_rtx_REG_offset (reg, GET_MODE (reg),
9717 OUTGOING_REGNO (REGNO (reg)), 0);
9718 p.outgoing = reg;
9719 XVECEXP (outgoing, 0, i)
9720 = gen_rtx_EXPR_LIST (VOIDmode, reg,
9721 XEXP (XVECEXP (incoming, 0, i), 1));
9722 vec_safe_push (windowed_parm_regs, p);
9725 incoming = outgoing;
9727 else if (MEM_P (incoming)
9728 && REG_P (XEXP (incoming, 0))
9729 && HARD_REGISTER_P (XEXP (incoming, 0)))
9731 rtx reg = XEXP (incoming, 0);
9732 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
9734 parm_reg p;
9735 p.incoming = reg;
9736 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
9737 p.outgoing = reg;
9738 vec_safe_push (windowed_parm_regs, p);
9739 incoming = replace_equiv_address_nv (incoming, reg);
9743 #endif
9745 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
9747 incoming_ok = false;
9748 if (MEM_P (incoming))
9750 /* This means argument is passed by invisible reference. */
9751 offset = 0;
9752 decl = parm;
9754 else
9756 if (!vt_get_decl_and_offset (decl_rtl, &decl, &offset))
9757 return;
9758 offset += byte_lowpart_offset (GET_MODE (incoming),
9759 GET_MODE (decl_rtl));
9763 if (!decl)
9764 return;
9766 if (parm != decl)
9768 /* If that DECL_RTL wasn't a pseudo that got spilled to
9769 memory, bail out. Otherwise, the spill slot sharing code
9770 will force the memory to reference spill_slot_decl (%sfp),
9771 so we don't match above. That's ok, the pseudo must have
9772 referenced the entire parameter, so just reset OFFSET. */
9773 if (decl != get_spill_slot_decl (false))
9774 return;
9775 offset = 0;
9778 HOST_WIDE_INT const_offset;
9779 if (!track_loc_p (incoming, parm, offset, false, &mode, &const_offset))
9780 return;
9782 out = &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out;
9784 dv = dv_from_decl (parm);
9786 if (target_for_debug_bind (parm)
9787 /* We can't deal with these right now, because this kind of
9788 variable is single-part. ??? We could handle parallels
9789 that describe multiple locations for the same single
9790 value, but ATM we don't. */
9791 && GET_CODE (incoming) != PARALLEL)
9793 cselib_val *val;
9794 rtx lowpart;
9796 /* ??? We shouldn't ever hit this, but it may happen because
9797 arguments passed by invisible reference aren't dealt with
9798 above: incoming-rtl will have Pmode rather than the
9799 expected mode for the type. */
9800 if (const_offset)
9801 return;
9803 lowpart = var_lowpart (mode, incoming);
9804 if (!lowpart)
9805 return;
9807 val = cselib_lookup_from_insn (lowpart, mode, true,
9808 VOIDmode, get_insns ());
9810 /* ??? Float-typed values in memory are not handled by
9811 cselib. */
9812 if (val)
9814 preserve_value (val);
9815 set_variable_part (out, val->val_rtx, dv, const_offset,
9816 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9817 dv = dv_from_value (val->val_rtx);
9820 if (MEM_P (incoming))
9822 val = cselib_lookup_from_insn (XEXP (incoming, 0), mode, true,
9823 VOIDmode, get_insns ());
9824 if (val)
9826 preserve_value (val);
9827 incoming = replace_equiv_address_nv (incoming, val->val_rtx);
9832 if (REG_P (incoming))
9834 incoming = var_lowpart (mode, incoming);
9835 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
9836 attrs_list_insert (&out->regs[REGNO (incoming)], dv, const_offset,
9837 incoming);
9838 set_variable_part (out, incoming, dv, const_offset,
9839 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9840 if (dv_is_value_p (dv))
9842 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv)), incoming);
9843 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
9844 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm))))
9846 machine_mode indmode
9847 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm)));
9848 rtx mem = gen_rtx_MEM (indmode, incoming);
9849 cselib_val *val = cselib_lookup_from_insn (mem, indmode, true,
9850 VOIDmode,
9851 get_insns ());
9852 if (val)
9854 preserve_value (val);
9855 record_entry_value (val, mem);
9856 set_variable_part (out, mem, dv_from_value (val->val_rtx), 0,
9857 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9862 else if (GET_CODE (incoming) == PARALLEL && !dv_onepart_p (dv))
9864 int i;
9866 /* The following code relies on vt_get_decl_and_offset returning true for
9867 incoming, which might not be always the case. */
9868 if (!incoming_ok)
9869 return;
9870 for (i = 0; i < XVECLEN (incoming, 0); i++)
9872 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9873 /* vt_get_decl_and_offset has already checked that the offset
9874 is a valid variable part. */
9875 const_offset = get_tracked_reg_offset (reg);
9876 gcc_assert (REGNO (reg) < FIRST_PSEUDO_REGISTER);
9877 attrs_list_insert (&out->regs[REGNO (reg)], dv, const_offset, reg);
9878 set_variable_part (out, reg, dv, const_offset,
9879 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9882 else if (MEM_P (incoming))
9884 incoming = var_lowpart (mode, incoming);
9885 set_variable_part (out, incoming, dv, const_offset,
9886 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9890 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9892 static void
9893 vt_add_function_parameters (void)
9895 tree parm;
9897 for (parm = DECL_ARGUMENTS (current_function_decl);
9898 parm; parm = DECL_CHAIN (parm))
9899 if (!POINTER_BOUNDS_P (parm))
9900 vt_add_function_parameter (parm);
9902 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl)))
9904 tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
9906 if (TREE_CODE (vexpr) == INDIRECT_REF)
9907 vexpr = TREE_OPERAND (vexpr, 0);
9909 if (TREE_CODE (vexpr) == PARM_DECL
9910 && DECL_ARTIFICIAL (vexpr)
9911 && !DECL_IGNORED_P (vexpr)
9912 && DECL_NAMELESS (vexpr))
9913 vt_add_function_parameter (vexpr);
9917 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9918 ensure it isn't flushed during cselib_reset_table.
9919 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9920 has been eliminated. */
9922 static void
9923 vt_init_cfa_base (void)
9925 cselib_val *val;
9927 #ifdef FRAME_POINTER_CFA_OFFSET
9928 cfa_base_rtx = frame_pointer_rtx;
9929 cfa_base_offset = -FRAME_POINTER_CFA_OFFSET (current_function_decl);
9930 #else
9931 cfa_base_rtx = arg_pointer_rtx;
9932 cfa_base_offset = -ARG_POINTER_CFA_OFFSET (current_function_decl);
9933 #endif
9934 if (cfa_base_rtx == hard_frame_pointer_rtx
9935 || !fixed_regs[REGNO (cfa_base_rtx)])
9937 cfa_base_rtx = NULL_RTX;
9938 return;
9940 if (!MAY_HAVE_DEBUG_BIND_INSNS)
9941 return;
9943 /* Tell alias analysis that cfa_base_rtx should share
9944 find_base_term value with stack pointer or hard frame pointer. */
9945 if (!frame_pointer_needed)
9946 vt_equate_reg_base_value (cfa_base_rtx, stack_pointer_rtx);
9947 else if (!crtl->stack_realign_tried)
9948 vt_equate_reg_base_value (cfa_base_rtx, hard_frame_pointer_rtx);
9950 val = cselib_lookup_from_insn (cfa_base_rtx, GET_MODE (cfa_base_rtx), 1,
9951 VOIDmode, get_insns ());
9952 preserve_value (val);
9953 cselib_preserve_cfa_base_value (val, REGNO (cfa_base_rtx));
9956 /* Reemit INSN, a MARKER_DEBUG_INSN, as a note. */
9958 static rtx_insn *
9959 reemit_marker_as_note (rtx_insn *insn)
9961 gcc_checking_assert (DEBUG_MARKER_INSN_P (insn));
9963 enum insn_note kind = INSN_DEBUG_MARKER_KIND (insn);
9965 switch (kind)
9967 case NOTE_INSN_BEGIN_STMT:
9968 case NOTE_INSN_INLINE_ENTRY:
9970 rtx_insn *note = NULL;
9971 if (cfun->debug_nonbind_markers)
9973 note = emit_note_before (kind, insn);
9974 NOTE_MARKER_LOCATION (note) = INSN_LOCATION (insn);
9976 delete_insn (insn);
9977 return note;
9980 default:
9981 gcc_unreachable ();
9985 /* Allocate and initialize the data structures for variable tracking
9986 and parse the RTL to get the micro operations. */
9988 static bool
9989 vt_initialize (void)
9991 basic_block bb;
9992 HOST_WIDE_INT fp_cfa_offset = -1;
9994 alloc_aux_for_blocks (sizeof (variable_tracking_info));
9996 empty_shared_hash = shared_hash_pool.allocate ();
9997 empty_shared_hash->refcount = 1;
9998 empty_shared_hash->htab = new variable_table_type (1);
9999 changed_variables = new variable_table_type (10);
10001 /* Init the IN and OUT sets. */
10002 FOR_ALL_BB_FN (bb, cfun)
10004 VTI (bb)->visited = false;
10005 VTI (bb)->flooded = false;
10006 dataflow_set_init (&VTI (bb)->in);
10007 dataflow_set_init (&VTI (bb)->out);
10008 VTI (bb)->permp = NULL;
10011 if (MAY_HAVE_DEBUG_BIND_INSNS)
10013 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
10014 scratch_regs = BITMAP_ALLOC (NULL);
10015 preserved_values.create (256);
10016 global_get_addr_cache = new hash_map<rtx, rtx>;
10018 else
10020 scratch_regs = NULL;
10021 global_get_addr_cache = NULL;
10024 if (MAY_HAVE_DEBUG_BIND_INSNS)
10026 rtx reg, expr;
10027 int ofst;
10028 cselib_val *val;
10030 #ifdef FRAME_POINTER_CFA_OFFSET
10031 reg = frame_pointer_rtx;
10032 ofst = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10033 #else
10034 reg = arg_pointer_rtx;
10035 ofst = ARG_POINTER_CFA_OFFSET (current_function_decl);
10036 #endif
10038 ofst -= INCOMING_FRAME_SP_OFFSET;
10040 val = cselib_lookup_from_insn (reg, GET_MODE (reg), 1,
10041 VOIDmode, get_insns ());
10042 preserve_value (val);
10043 if (reg != hard_frame_pointer_rtx && fixed_regs[REGNO (reg)])
10044 cselib_preserve_cfa_base_value (val, REGNO (reg));
10045 expr = plus_constant (GET_MODE (stack_pointer_rtx),
10046 stack_pointer_rtx, -ofst);
10047 cselib_add_permanent_equiv (val, expr, get_insns ());
10049 if (ofst)
10051 val = cselib_lookup_from_insn (stack_pointer_rtx,
10052 GET_MODE (stack_pointer_rtx), 1,
10053 VOIDmode, get_insns ());
10054 preserve_value (val);
10055 expr = plus_constant (GET_MODE (reg), reg, ofst);
10056 cselib_add_permanent_equiv (val, expr, get_insns ());
10060 /* In order to factor out the adjustments made to the stack pointer or to
10061 the hard frame pointer and thus be able to use DW_OP_fbreg operations
10062 instead of individual location lists, we're going to rewrite MEMs based
10063 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
10064 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
10065 resp. arg_pointer_rtx. We can do this either when there is no frame
10066 pointer in the function and stack adjustments are consistent for all
10067 basic blocks or when there is a frame pointer and no stack realignment.
10068 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
10069 has been eliminated. */
10070 if (!frame_pointer_needed)
10072 rtx reg, elim;
10074 if (!vt_stack_adjustments ())
10075 return false;
10077 #ifdef FRAME_POINTER_CFA_OFFSET
10078 reg = frame_pointer_rtx;
10079 #else
10080 reg = arg_pointer_rtx;
10081 #endif
10082 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10083 if (elim != reg)
10085 if (GET_CODE (elim) == PLUS)
10086 elim = XEXP (elim, 0);
10087 if (elim == stack_pointer_rtx)
10088 vt_init_cfa_base ();
10091 else if (!crtl->stack_realign_tried)
10093 rtx reg, elim;
10095 #ifdef FRAME_POINTER_CFA_OFFSET
10096 reg = frame_pointer_rtx;
10097 fp_cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10098 #else
10099 reg = arg_pointer_rtx;
10100 fp_cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10101 #endif
10102 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10103 if (elim != reg)
10105 if (GET_CODE (elim) == PLUS)
10107 fp_cfa_offset -= INTVAL (XEXP (elim, 1));
10108 elim = XEXP (elim, 0);
10110 if (elim != hard_frame_pointer_rtx)
10111 fp_cfa_offset = -1;
10113 else
10114 fp_cfa_offset = -1;
10117 /* If the stack is realigned and a DRAP register is used, we're going to
10118 rewrite MEMs based on it representing incoming locations of parameters
10119 passed on the stack into MEMs based on the argument pointer. Although
10120 we aren't going to rewrite other MEMs, we still need to initialize the
10121 virtual CFA pointer in order to ensure that the argument pointer will
10122 be seen as a constant throughout the function.
10124 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10125 else if (stack_realign_drap)
10127 rtx reg, elim;
10129 #ifdef FRAME_POINTER_CFA_OFFSET
10130 reg = frame_pointer_rtx;
10131 #else
10132 reg = arg_pointer_rtx;
10133 #endif
10134 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10135 if (elim != reg)
10137 if (GET_CODE (elim) == PLUS)
10138 elim = XEXP (elim, 0);
10139 if (elim == hard_frame_pointer_rtx)
10140 vt_init_cfa_base ();
10144 hard_frame_pointer_adjustment = -1;
10146 vt_add_function_parameters ();
10148 FOR_EACH_BB_FN (bb, cfun)
10150 rtx_insn *insn;
10151 HOST_WIDE_INT pre, post = 0;
10152 basic_block first_bb, last_bb;
10154 if (MAY_HAVE_DEBUG_BIND_INSNS)
10156 cselib_record_sets_hook = add_with_sets;
10157 if (dump_file && (dump_flags & TDF_DETAILS))
10158 fprintf (dump_file, "first value: %i\n",
10159 cselib_get_next_uid ());
10162 first_bb = bb;
10163 for (;;)
10165 edge e;
10166 if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
10167 || ! single_pred_p (bb->next_bb))
10168 break;
10169 e = find_edge (bb, bb->next_bb);
10170 if (! e || (e->flags & EDGE_FALLTHRU) == 0)
10171 break;
10172 bb = bb->next_bb;
10174 last_bb = bb;
10176 /* Add the micro-operations to the vector. */
10177 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
10179 HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
10180 VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
10182 rtx_insn *next;
10183 FOR_BB_INSNS_SAFE (bb, insn, next)
10185 if (INSN_P (insn))
10187 if (!frame_pointer_needed)
10189 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
10190 if (pre)
10192 micro_operation mo;
10193 mo.type = MO_ADJUST;
10194 mo.u.adjust = pre;
10195 mo.insn = insn;
10196 if (dump_file && (dump_flags & TDF_DETAILS))
10197 log_op_type (PATTERN (insn), bb, insn,
10198 MO_ADJUST, dump_file);
10199 VTI (bb)->mos.safe_push (mo);
10200 VTI (bb)->out.stack_adjust += pre;
10204 cselib_hook_called = false;
10205 adjust_insn (bb, insn);
10206 if (DEBUG_MARKER_INSN_P (insn))
10208 reemit_marker_as_note (insn);
10209 continue;
10212 if (MAY_HAVE_DEBUG_BIND_INSNS)
10214 if (CALL_P (insn))
10215 prepare_call_arguments (bb, insn);
10216 cselib_process_insn (insn);
10217 if (dump_file && (dump_flags & TDF_DETAILS))
10219 print_rtl_single (dump_file, insn);
10220 dump_cselib_table (dump_file);
10223 if (!cselib_hook_called)
10224 add_with_sets (insn, 0, 0);
10225 cancel_changes (0);
10227 if (!frame_pointer_needed && post)
10229 micro_operation mo;
10230 mo.type = MO_ADJUST;
10231 mo.u.adjust = post;
10232 mo.insn = insn;
10233 if (dump_file && (dump_flags & TDF_DETAILS))
10234 log_op_type (PATTERN (insn), bb, insn,
10235 MO_ADJUST, dump_file);
10236 VTI (bb)->mos.safe_push (mo);
10237 VTI (bb)->out.stack_adjust += post;
10240 if (fp_cfa_offset != -1
10241 && hard_frame_pointer_adjustment == -1
10242 && fp_setter_insn (insn))
10244 vt_init_cfa_base ();
10245 hard_frame_pointer_adjustment = fp_cfa_offset;
10246 /* Disassociate sp from fp now. */
10247 if (MAY_HAVE_DEBUG_BIND_INSNS)
10249 cselib_val *v;
10250 cselib_invalidate_rtx (stack_pointer_rtx);
10251 v = cselib_lookup (stack_pointer_rtx, Pmode, 1,
10252 VOIDmode);
10253 if (v && !cselib_preserved_value_p (v))
10255 cselib_set_value_sp_based (v);
10256 preserve_value (v);
10262 gcc_assert (offset == VTI (bb)->out.stack_adjust);
10265 bb = last_bb;
10267 if (MAY_HAVE_DEBUG_BIND_INSNS)
10269 cselib_preserve_only_values ();
10270 cselib_reset_table (cselib_get_next_uid ());
10271 cselib_record_sets_hook = NULL;
10275 hard_frame_pointer_adjustment = -1;
10276 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flooded = true;
10277 cfa_base_rtx = NULL_RTX;
10278 return true;
10281 /* This is *not* reset after each function. It gives each
10282 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10283 a unique label number. */
10285 static int debug_label_num = 1;
10287 /* Remove from the insn stream a single debug insn used for
10288 variable tracking at assignments. */
10290 static inline void
10291 delete_vta_debug_insn (rtx_insn *insn)
10293 if (DEBUG_MARKER_INSN_P (insn))
10295 reemit_marker_as_note (insn);
10296 return;
10299 tree decl = INSN_VAR_LOCATION_DECL (insn);
10300 if (TREE_CODE (decl) == LABEL_DECL
10301 && DECL_NAME (decl)
10302 && !DECL_RTL_SET_P (decl))
10304 PUT_CODE (insn, NOTE);
10305 NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
10306 NOTE_DELETED_LABEL_NAME (insn)
10307 = IDENTIFIER_POINTER (DECL_NAME (decl));
10308 SET_DECL_RTL (decl, insn);
10309 CODE_LABEL_NUMBER (insn) = debug_label_num++;
10311 else
10312 delete_insn (insn);
10315 /* Remove from the insn stream all debug insns used for variable
10316 tracking at assignments. USE_CFG should be false if the cfg is no
10317 longer usable. */
10319 void
10320 delete_vta_debug_insns (bool use_cfg)
10322 basic_block bb;
10323 rtx_insn *insn, *next;
10325 if (!MAY_HAVE_DEBUG_INSNS)
10326 return;
10328 if (use_cfg)
10329 FOR_EACH_BB_FN (bb, cfun)
10331 FOR_BB_INSNS_SAFE (bb, insn, next)
10332 if (DEBUG_INSN_P (insn))
10333 delete_vta_debug_insn (insn);
10335 else
10336 for (insn = get_insns (); insn; insn = next)
10338 next = NEXT_INSN (insn);
10339 if (DEBUG_INSN_P (insn))
10340 delete_vta_debug_insn (insn);
10344 /* Run a fast, BB-local only version of var tracking, to take care of
10345 information that we don't do global analysis on, such that not all
10346 information is lost. If SKIPPED holds, we're skipping the global
10347 pass entirely, so we should try to use information it would have
10348 handled as well.. */
10350 static void
10351 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
10353 /* ??? Just skip it all for now. */
10354 delete_vta_debug_insns (true);
10357 /* Free the data structures needed for variable tracking. */
10359 static void
10360 vt_finalize (void)
10362 basic_block bb;
10364 FOR_EACH_BB_FN (bb, cfun)
10366 VTI (bb)->mos.release ();
10369 FOR_ALL_BB_FN (bb, cfun)
10371 dataflow_set_destroy (&VTI (bb)->in);
10372 dataflow_set_destroy (&VTI (bb)->out);
10373 if (VTI (bb)->permp)
10375 dataflow_set_destroy (VTI (bb)->permp);
10376 XDELETE (VTI (bb)->permp);
10379 free_aux_for_blocks ();
10380 delete empty_shared_hash->htab;
10381 empty_shared_hash->htab = NULL;
10382 delete changed_variables;
10383 changed_variables = NULL;
10384 attrs_pool.release ();
10385 var_pool.release ();
10386 location_chain_pool.release ();
10387 shared_hash_pool.release ();
10389 if (MAY_HAVE_DEBUG_BIND_INSNS)
10391 if (global_get_addr_cache)
10392 delete global_get_addr_cache;
10393 global_get_addr_cache = NULL;
10394 loc_exp_dep_pool.release ();
10395 valvar_pool.release ();
10396 preserved_values.release ();
10397 cselib_finish ();
10398 BITMAP_FREE (scratch_regs);
10399 scratch_regs = NULL;
10402 #ifdef HAVE_window_save
10403 vec_free (windowed_parm_regs);
10404 #endif
10406 if (vui_vec)
10407 XDELETEVEC (vui_vec);
10408 vui_vec = NULL;
10409 vui_allocated = 0;
10412 /* The entry point to variable tracking pass. */
10414 static inline unsigned int
10415 variable_tracking_main_1 (void)
10417 bool success;
10419 /* We won't be called as a separate pass if flag_var_tracking is not
10420 set, but final may call us to turn debug markers into notes. */
10421 if ((!flag_var_tracking && MAY_HAVE_DEBUG_INSNS)
10422 || flag_var_tracking_assignments < 0
10423 /* Var-tracking right now assumes the IR doesn't contain
10424 any pseudos at this point. */
10425 || targetm.no_register_allocation)
10427 delete_vta_debug_insns (true);
10428 return 0;
10431 if (!flag_var_tracking)
10432 return 0;
10434 if (n_basic_blocks_for_fn (cfun) > 500
10435 && n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
10437 vt_debug_insns_local (true);
10438 return 0;
10441 mark_dfs_back_edges ();
10442 if (!vt_initialize ())
10444 vt_finalize ();
10445 vt_debug_insns_local (true);
10446 return 0;
10449 success = vt_find_locations ();
10451 if (!success && flag_var_tracking_assignments > 0)
10453 vt_finalize ();
10455 delete_vta_debug_insns (true);
10457 /* This is later restored by our caller. */
10458 flag_var_tracking_assignments = 0;
10460 success = vt_initialize ();
10461 gcc_assert (success);
10463 success = vt_find_locations ();
10466 if (!success)
10468 vt_finalize ();
10469 vt_debug_insns_local (false);
10470 return 0;
10473 if (dump_file && (dump_flags & TDF_DETAILS))
10475 dump_dataflow_sets ();
10476 dump_reg_info (dump_file);
10477 dump_flow_info (dump_file, dump_flags);
10480 timevar_push (TV_VAR_TRACKING_EMIT);
10481 vt_emit_notes ();
10482 timevar_pop (TV_VAR_TRACKING_EMIT);
10484 vt_finalize ();
10485 vt_debug_insns_local (false);
10486 return 0;
10489 unsigned int
10490 variable_tracking_main (void)
10492 unsigned int ret;
10493 int save = flag_var_tracking_assignments;
10495 ret = variable_tracking_main_1 ();
10497 flag_var_tracking_assignments = save;
10499 return ret;
10502 namespace {
10504 const pass_data pass_data_variable_tracking =
10506 RTL_PASS, /* type */
10507 "vartrack", /* name */
10508 OPTGROUP_NONE, /* optinfo_flags */
10509 TV_VAR_TRACKING, /* tv_id */
10510 0, /* properties_required */
10511 0, /* properties_provided */
10512 0, /* properties_destroyed */
10513 0, /* todo_flags_start */
10514 0, /* todo_flags_finish */
10517 class pass_variable_tracking : public rtl_opt_pass
10519 public:
10520 pass_variable_tracking (gcc::context *ctxt)
10521 : rtl_opt_pass (pass_data_variable_tracking, ctxt)
10524 /* opt_pass methods: */
10525 virtual bool gate (function *)
10527 return (flag_var_tracking && !targetm.delay_vartrack);
10530 virtual unsigned int execute (function *)
10532 return variable_tracking_main ();
10535 }; // class pass_variable_tracking
10537 } // anon namespace
10539 rtl_opt_pass *
10540 make_pass_variable_tracking (gcc::context *ctxt)
10542 return new pass_variable_tracking (ctxt);