PR bootstrap/66085
[official-gcc.git] / gcc / var-tracking.c
blob460f6e752789b5c92eabb822d23777946be31ff8
1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2015 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 "tm.h"
92 #include "rtl.h"
93 #include "hash-set.h"
94 #include "machmode.h"
95 #include "vec.h"
96 #include "double-int.h"
97 #include "input.h"
98 #include "alias.h"
99 #include "symtab.h"
100 #include "wide-int.h"
101 #include "inchash.h"
102 #include "tree.h"
103 #include "varasm.h"
104 #include "stor-layout.h"
105 #include "hash-map.h"
106 #include "hash-table.h"
107 #include "predict.h"
108 #include "hard-reg-set.h"
109 #include "function.h"
110 #include "dominance.h"
111 #include "cfg.h"
112 #include "cfgrtl.h"
113 #include "cfganal.h"
114 #include "basic-block.h"
115 #include "tm_p.h"
116 #include "flags.h"
117 #include "insn-config.h"
118 #include "reload.h"
119 #include "sbitmap.h"
120 #include "alloc-pool.h"
121 #include "regs.h"
122 #include "hashtab.h"
123 #include "statistics.h"
124 #include "real.h"
125 #include "fixed-value.h"
126 #include "expmed.h"
127 #include "dojump.h"
128 #include "explow.h"
129 #include "calls.h"
130 #include "emit-rtl.h"
131 #include "stmt.h"
132 #include "expr.h"
133 #include "tree-pass.h"
134 #include "bitmap.h"
135 #include "tree-dfa.h"
136 #include "tree-ssa.h"
137 #include "cselib.h"
138 #include "target.h"
139 #include "params.h"
140 #include "diagnostic.h"
141 #include "tree-pretty-print.h"
142 #include "recog.h"
143 #include "rtl-iter.h"
144 #include "fibonacci_heap.h"
146 typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
147 typedef fibonacci_node <long, basic_block_def> bb_heap_node_t;
149 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
150 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
151 Currently the value is the same as IDENTIFIER_NODE, which has such
152 a property. If this compile time assertion ever fails, make sure that
153 the new tree code that equals (int) VALUE has the same property. */
154 extern char check_value_val[(int) VALUE == (int) IDENTIFIER_NODE ? 1 : -1];
156 /* Type of micro operation. */
157 enum micro_operation_type
159 MO_USE, /* Use location (REG or MEM). */
160 MO_USE_NO_VAR,/* Use location which is not associated with a variable
161 or the variable is not trackable. */
162 MO_VAL_USE, /* Use location which is associated with a value. */
163 MO_VAL_LOC, /* Use location which appears in a debug insn. */
164 MO_VAL_SET, /* Set location associated with a value. */
165 MO_SET, /* Set location. */
166 MO_COPY, /* Copy the same portion of a variable from one
167 location to another. */
168 MO_CLOBBER, /* Clobber location. */
169 MO_CALL, /* Call insn. */
170 MO_ADJUST /* Adjust stack pointer. */
174 static const char * const ATTRIBUTE_UNUSED
175 micro_operation_type_name[] = {
176 "MO_USE",
177 "MO_USE_NO_VAR",
178 "MO_VAL_USE",
179 "MO_VAL_LOC",
180 "MO_VAL_SET",
181 "MO_SET",
182 "MO_COPY",
183 "MO_CLOBBER",
184 "MO_CALL",
185 "MO_ADJUST"
188 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
189 Notes emitted as AFTER_CALL are to take effect during the call,
190 rather than after the call. */
191 enum emit_note_where
193 EMIT_NOTE_BEFORE_INSN,
194 EMIT_NOTE_AFTER_INSN,
195 EMIT_NOTE_AFTER_CALL_INSN
198 /* Structure holding information about micro operation. */
199 typedef struct micro_operation_def
201 /* Type of micro operation. */
202 enum micro_operation_type type;
204 /* The instruction which the micro operation is in, for MO_USE,
205 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
206 instruction or note in the original flow (before any var-tracking
207 notes are inserted, to simplify emission of notes), for MO_SET
208 and MO_CLOBBER. */
209 rtx_insn *insn;
211 union {
212 /* Location. For MO_SET and MO_COPY, this is the SET that
213 performs the assignment, if known, otherwise it is the target
214 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
215 CONCAT of the VALUE and the LOC associated with it. For
216 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
217 associated with it. */
218 rtx loc;
220 /* Stack adjustment. */
221 HOST_WIDE_INT adjust;
222 } u;
223 } micro_operation;
226 /* A declaration of a variable, or an RTL value being handled like a
227 declaration. */
228 typedef void *decl_or_value;
230 /* Return true if a decl_or_value DV is a DECL or NULL. */
231 static inline bool
232 dv_is_decl_p (decl_or_value dv)
234 return !dv || (int) TREE_CODE ((tree) dv) != (int) VALUE;
237 /* Return true if a decl_or_value is a VALUE rtl. */
238 static inline bool
239 dv_is_value_p (decl_or_value dv)
241 return dv && !dv_is_decl_p (dv);
244 /* Return the decl in the decl_or_value. */
245 static inline tree
246 dv_as_decl (decl_or_value dv)
248 gcc_checking_assert (dv_is_decl_p (dv));
249 return (tree) dv;
252 /* Return the value in the decl_or_value. */
253 static inline rtx
254 dv_as_value (decl_or_value dv)
256 gcc_checking_assert (dv_is_value_p (dv));
257 return (rtx)dv;
260 /* Return the opaque pointer in the decl_or_value. */
261 static inline void *
262 dv_as_opaque (decl_or_value dv)
264 return dv;
268 /* Description of location of a part of a variable. The content of a physical
269 register is described by a chain of these structures.
270 The chains are pretty short (usually 1 or 2 elements) and thus
271 chain is the best data structure. */
272 typedef struct attrs_def
274 /* Pointer to next member of the list. */
275 struct attrs_def *next;
277 /* The rtx of register. */
278 rtx loc;
280 /* The declaration corresponding to LOC. */
281 decl_or_value dv;
283 /* Offset from start of DECL. */
284 HOST_WIDE_INT offset;
285 } *attrs;
287 /* Structure for chaining the locations. */
288 typedef struct location_chain_def
290 /* Next element in the chain. */
291 struct location_chain_def *next;
293 /* The location (REG, MEM or VALUE). */
294 rtx loc;
296 /* The "value" stored in this location. */
297 rtx set_src;
299 /* Initialized? */
300 enum var_init_status init;
301 } *location_chain;
303 /* A vector of loc_exp_dep holds the active dependencies of a one-part
304 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
305 location of DV. Each entry is also part of VALUE' s linked-list of
306 backlinks back to DV. */
307 typedef struct loc_exp_dep_s
309 /* The dependent DV. */
310 decl_or_value dv;
311 /* The dependency VALUE or DECL_DEBUG. */
312 rtx value;
313 /* The next entry in VALUE's backlinks list. */
314 struct loc_exp_dep_s *next;
315 /* A pointer to the pointer to this entry (head or prev's next) in
316 the doubly-linked list. */
317 struct loc_exp_dep_s **pprev;
318 } loc_exp_dep;
321 /* This data structure holds information about the depth of a variable
322 expansion. */
323 typedef struct expand_depth_struct
325 /* This measures the complexity of the expanded expression. It
326 grows by one for each level of expansion that adds more than one
327 operand. */
328 int complexity;
329 /* This counts the number of ENTRY_VALUE expressions in an
330 expansion. We want to minimize their use. */
331 int entryvals;
332 } expand_depth;
334 /* This data structure is allocated for one-part variables at the time
335 of emitting notes. */
336 struct onepart_aux
338 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
339 computation used the expansion of this variable, and that ought
340 to be notified should this variable change. If the DV's cur_loc
341 expanded to NULL, all components of the loc list are regarded as
342 active, so that any changes in them give us a chance to get a
343 location. Otherwise, only components of the loc that expanded to
344 non-NULL are regarded as active dependencies. */
345 loc_exp_dep *backlinks;
346 /* This holds the LOC that was expanded into cur_loc. We need only
347 mark a one-part variable as changed if the FROM loc is removed,
348 or if it has no known location and a loc is added, or if it gets
349 a change notification from any of its active dependencies. */
350 rtx from;
351 /* The depth of the cur_loc expression. */
352 expand_depth depth;
353 /* Dependencies actively used when expand FROM into cur_loc. */
354 vec<loc_exp_dep, va_heap, vl_embed> deps;
357 /* Structure describing one part of variable. */
358 typedef struct variable_part_def
360 /* Chain of locations of the part. */
361 location_chain loc_chain;
363 /* Location which was last emitted to location list. */
364 rtx cur_loc;
366 union variable_aux
368 /* The offset in the variable, if !var->onepart. */
369 HOST_WIDE_INT offset;
371 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
372 struct onepart_aux *onepaux;
373 } aux;
374 } variable_part;
376 /* Maximum number of location parts. */
377 #define MAX_VAR_PARTS 16
379 /* Enumeration type used to discriminate various types of one-part
380 variables. */
381 typedef enum onepart_enum
383 /* Not a one-part variable. */
384 NOT_ONEPART = 0,
385 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
386 ONEPART_VDECL = 1,
387 /* A DEBUG_EXPR_DECL. */
388 ONEPART_DEXPR = 2,
389 /* A VALUE. */
390 ONEPART_VALUE = 3
391 } onepart_enum_t;
393 /* Structure describing where the variable is located. */
394 typedef struct variable_def
396 /* The declaration of the variable, or an RTL value being handled
397 like a declaration. */
398 decl_or_value dv;
400 /* Reference count. */
401 int refcount;
403 /* Number of variable parts. */
404 char n_var_parts;
406 /* What type of DV this is, according to enum onepart_enum. */
407 ENUM_BITFIELD (onepart_enum) onepart : CHAR_BIT;
409 /* True if this variable_def struct is currently in the
410 changed_variables hash table. */
411 bool in_changed_variables;
413 /* The variable parts. */
414 variable_part var_part[1];
415 } *variable;
416 typedef const struct variable_def *const_variable;
418 /* Pointer to the BB's information specific to variable tracking pass. */
419 #define VTI(BB) ((variable_tracking_info) (BB)->aux)
421 /* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
422 #define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
424 #if ENABLE_CHECKING && (GCC_VERSION >= 2007)
426 /* Access VAR's Ith part's offset, checking that it's not a one-part
427 variable. */
428 #define VAR_PART_OFFSET(var, i) __extension__ \
429 (*({ variable const __v = (var); \
430 gcc_checking_assert (!__v->onepart); \
431 &__v->var_part[(i)].aux.offset; }))
433 /* Access VAR's one-part auxiliary data, checking that it is a
434 one-part variable. */
435 #define VAR_LOC_1PAUX(var) __extension__ \
436 (*({ variable const __v = (var); \
437 gcc_checking_assert (__v->onepart); \
438 &__v->var_part[0].aux.onepaux; }))
440 #else
441 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
442 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
443 #endif
445 /* These are accessor macros for the one-part auxiliary data. When
446 convenient for users, they're guarded by tests that the data was
447 allocated. */
448 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
449 ? VAR_LOC_1PAUX (var)->backlinks \
450 : NULL)
451 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
452 ? &VAR_LOC_1PAUX (var)->backlinks \
453 : NULL)
454 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
455 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
456 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
457 ? &VAR_LOC_1PAUX (var)->deps \
458 : NULL)
462 typedef unsigned int dvuid;
464 /* Return the uid of DV. */
466 static inline dvuid
467 dv_uid (decl_or_value dv)
469 if (dv_is_value_p (dv))
470 return CSELIB_VAL_PTR (dv_as_value (dv))->uid;
471 else
472 return DECL_UID (dv_as_decl (dv));
475 /* Compute the hash from the uid. */
477 static inline hashval_t
478 dv_uid2hash (dvuid uid)
480 return uid;
483 /* The hash function for a mask table in a shared_htab chain. */
485 static inline hashval_t
486 dv_htab_hash (decl_or_value dv)
488 return dv_uid2hash (dv_uid (dv));
491 static void variable_htab_free (void *);
493 /* Variable hashtable helpers. */
495 struct variable_hasher
497 typedef variable_def *value_type;
498 typedef void *compare_type;
499 static inline hashval_t hash (const variable_def *);
500 static inline bool equal (const variable_def *, const void *);
501 static inline void remove (variable_def *);
504 /* The hash function for variable_htab, computes the hash value
505 from the declaration of variable X. */
507 inline hashval_t
508 variable_hasher::hash (const variable_def *v)
510 return dv_htab_hash (v->dv);
513 /* Compare the declaration of variable X with declaration Y. */
515 inline bool
516 variable_hasher::equal (const variable_def *v, const void *y)
518 decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y);
520 return (dv_as_opaque (v->dv) == dv_as_opaque (dv));
523 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
525 inline void
526 variable_hasher::remove (variable_def *var)
528 variable_htab_free (var);
531 typedef hash_table<variable_hasher> variable_table_type;
532 typedef variable_table_type::iterator variable_iterator_type;
534 /* Structure for passing some other parameters to function
535 emit_note_insn_var_location. */
536 typedef struct emit_note_data_def
538 /* The instruction which the note will be emitted before/after. */
539 rtx_insn *insn;
541 /* Where the note will be emitted (before/after insn)? */
542 enum emit_note_where where;
544 /* The variables and values active at this point. */
545 variable_table_type *vars;
546 } emit_note_data;
548 /* Structure holding a refcounted hash table. If refcount > 1,
549 it must be first unshared before modified. */
550 typedef struct shared_hash_def
552 /* Reference count. */
553 int refcount;
555 /* Actual hash table. */
556 variable_table_type *htab;
557 } *shared_hash;
559 /* Structure holding the IN or OUT set for a basic block. */
560 typedef struct dataflow_set_def
562 /* Adjustment of stack offset. */
563 HOST_WIDE_INT stack_adjust;
565 /* Attributes for registers (lists of attrs). */
566 attrs regs[FIRST_PSEUDO_REGISTER];
568 /* Variable locations. */
569 shared_hash vars;
571 /* Vars that is being traversed. */
572 shared_hash traversed_vars;
573 } dataflow_set;
575 /* The structure (one for each basic block) containing the information
576 needed for variable tracking. */
577 typedef struct variable_tracking_info_def
579 /* The vector of micro operations. */
580 vec<micro_operation> mos;
582 /* The IN and OUT set for dataflow analysis. */
583 dataflow_set in;
584 dataflow_set out;
586 /* The permanent-in dataflow set for this block. This is used to
587 hold values for which we had to compute entry values. ??? This
588 should probably be dynamically allocated, to avoid using more
589 memory in non-debug builds. */
590 dataflow_set *permp;
592 /* Has the block been visited in DFS? */
593 bool visited;
595 /* Has the block been flooded in VTA? */
596 bool flooded;
598 } *variable_tracking_info;
600 /* Alloc pool for struct attrs_def. */
601 static alloc_pool attrs_pool;
603 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
604 static alloc_pool var_pool;
606 /* Alloc pool for struct variable_def with a single var_part entry. */
607 static alloc_pool valvar_pool;
609 /* Alloc pool for struct location_chain_def. */
610 static alloc_pool loc_chain_pool;
612 /* Alloc pool for struct shared_hash_def. */
613 static alloc_pool shared_hash_pool;
615 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
616 static alloc_pool loc_exp_dep_pool;
618 /* Changed variables, notes will be emitted for them. */
619 static variable_table_type *changed_variables;
621 /* Shall notes be emitted? */
622 static bool emit_notes;
624 /* Values whose dynamic location lists have gone empty, but whose
625 cselib location lists are still usable. Use this to hold the
626 current location, the backlinks, etc, during emit_notes. */
627 static variable_table_type *dropped_values;
629 /* Empty shared hashtable. */
630 static shared_hash empty_shared_hash;
632 /* Scratch register bitmap used by cselib_expand_value_rtx. */
633 static bitmap scratch_regs = NULL;
635 #ifdef HAVE_window_save
636 typedef struct GTY(()) parm_reg {
637 rtx outgoing;
638 rtx incoming;
639 } parm_reg_t;
642 /* Vector of windowed parameter registers, if any. */
643 static vec<parm_reg_t, va_gc> *windowed_parm_regs = NULL;
644 #endif
646 /* Variable used to tell whether cselib_process_insn called our hook. */
647 static bool cselib_hook_called;
649 /* Local function prototypes. */
650 static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,
651 HOST_WIDE_INT *);
652 static void insn_stack_adjust_offset_pre_post (rtx_insn *, HOST_WIDE_INT *,
653 HOST_WIDE_INT *);
654 static bool vt_stack_adjustments (void);
656 static void init_attrs_list_set (attrs *);
657 static void attrs_list_clear (attrs *);
658 static attrs attrs_list_member (attrs, decl_or_value, HOST_WIDE_INT);
659 static void attrs_list_insert (attrs *, decl_or_value, HOST_WIDE_INT, rtx);
660 static void attrs_list_copy (attrs *, attrs);
661 static void attrs_list_union (attrs *, attrs);
663 static variable_def **unshare_variable (dataflow_set *set, variable_def **slot,
664 variable var, enum var_init_status);
665 static void vars_copy (variable_table_type *, variable_table_type *);
666 static tree var_debug_decl (tree);
667 static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx);
668 static void var_reg_delete_and_set (dataflow_set *, rtx, bool,
669 enum var_init_status, rtx);
670 static void var_reg_delete (dataflow_set *, rtx, bool);
671 static void var_regno_delete (dataflow_set *, int);
672 static void var_mem_set (dataflow_set *, rtx, enum var_init_status, rtx);
673 static void var_mem_delete_and_set (dataflow_set *, rtx, bool,
674 enum var_init_status, rtx);
675 static void var_mem_delete (dataflow_set *, rtx, bool);
677 static void dataflow_set_init (dataflow_set *);
678 static void dataflow_set_clear (dataflow_set *);
679 static void dataflow_set_copy (dataflow_set *, dataflow_set *);
680 static int variable_union_info_cmp_pos (const void *, const void *);
681 static void dataflow_set_union (dataflow_set *, dataflow_set *);
682 static location_chain find_loc_in_1pdv (rtx, variable, variable_table_type *);
683 static bool canon_value_cmp (rtx, rtx);
684 static int loc_cmp (rtx, rtx);
685 static bool variable_part_different_p (variable_part *, variable_part *);
686 static bool onepart_variable_different_p (variable, variable);
687 static bool variable_different_p (variable, variable);
688 static bool dataflow_set_different (dataflow_set *, dataflow_set *);
689 static void dataflow_set_destroy (dataflow_set *);
691 static bool contains_symbol_ref (rtx);
692 static bool track_expr_p (tree, bool);
693 static bool same_variable_part_p (rtx, tree, HOST_WIDE_INT);
694 static void add_uses_1 (rtx *, void *);
695 static void add_stores (rtx, const_rtx, void *);
696 static bool compute_bb_dataflow (basic_block);
697 static bool vt_find_locations (void);
699 static void dump_attrs_list (attrs);
700 static void dump_var (variable);
701 static void dump_vars (variable_table_type *);
702 static void dump_dataflow_set (dataflow_set *);
703 static void dump_dataflow_sets (void);
705 static void set_dv_changed (decl_or_value, bool);
706 static void variable_was_changed (variable, dataflow_set *);
707 static variable_def **set_slot_part (dataflow_set *, rtx, variable_def **,
708 decl_or_value, HOST_WIDE_INT,
709 enum var_init_status, rtx);
710 static void set_variable_part (dataflow_set *, rtx,
711 decl_or_value, HOST_WIDE_INT,
712 enum var_init_status, rtx, enum insert_option);
713 static variable_def **clobber_slot_part (dataflow_set *, rtx,
714 variable_def **, HOST_WIDE_INT, rtx);
715 static void clobber_variable_part (dataflow_set *, rtx,
716 decl_or_value, HOST_WIDE_INT, rtx);
717 static variable_def **delete_slot_part (dataflow_set *, rtx, variable_def **,
718 HOST_WIDE_INT);
719 static void delete_variable_part (dataflow_set *, rtx,
720 decl_or_value, HOST_WIDE_INT);
721 static void emit_notes_in_bb (basic_block, dataflow_set *);
722 static void vt_emit_notes (void);
724 static bool vt_get_decl_and_offset (rtx, tree *, HOST_WIDE_INT *);
725 static void vt_add_function_parameters (void);
726 static bool vt_initialize (void);
727 static void vt_finalize (void);
729 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
731 static int
732 stack_adjust_offset_pre_post_cb (rtx, rtx op, rtx dest, rtx src, rtx srcoff,
733 void *arg)
735 if (dest != stack_pointer_rtx)
736 return 0;
738 switch (GET_CODE (op))
740 case PRE_INC:
741 case PRE_DEC:
742 ((HOST_WIDE_INT *)arg)[0] -= INTVAL (srcoff);
743 return 0;
744 case POST_INC:
745 case POST_DEC:
746 ((HOST_WIDE_INT *)arg)[1] -= INTVAL (srcoff);
747 return 0;
748 case PRE_MODIFY:
749 case POST_MODIFY:
750 /* We handle only adjustments by constant amount. */
751 gcc_assert (GET_CODE (src) == PLUS
752 && CONST_INT_P (XEXP (src, 1))
753 && XEXP (src, 0) == stack_pointer_rtx);
754 ((HOST_WIDE_INT *)arg)[GET_CODE (op) == POST_MODIFY]
755 -= INTVAL (XEXP (src, 1));
756 return 0;
757 default:
758 gcc_unreachable ();
762 /* Given a SET, calculate the amount of stack adjustment it contains
763 PRE- and POST-modifying stack pointer.
764 This function is similar to stack_adjust_offset. */
766 static void
767 stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INT *pre,
768 HOST_WIDE_INT *post)
770 rtx src = SET_SRC (pattern);
771 rtx dest = SET_DEST (pattern);
772 enum rtx_code code;
774 if (dest == stack_pointer_rtx)
776 /* (set (reg sp) (plus (reg sp) (const_int))) */
777 code = GET_CODE (src);
778 if (! (code == PLUS || code == MINUS)
779 || XEXP (src, 0) != stack_pointer_rtx
780 || !CONST_INT_P (XEXP (src, 1)))
781 return;
783 if (code == MINUS)
784 *post += INTVAL (XEXP (src, 1));
785 else
786 *post -= INTVAL (XEXP (src, 1));
787 return;
789 HOST_WIDE_INT res[2] = { 0, 0 };
790 for_each_inc_dec (pattern, stack_adjust_offset_pre_post_cb, res);
791 *pre += res[0];
792 *post += res[1];
795 /* Given an INSN, calculate the amount of stack adjustment it contains
796 PRE- and POST-modifying stack pointer. */
798 static void
799 insn_stack_adjust_offset_pre_post (rtx_insn *insn, HOST_WIDE_INT *pre,
800 HOST_WIDE_INT *post)
802 rtx pattern;
804 *pre = 0;
805 *post = 0;
807 pattern = PATTERN (insn);
808 if (RTX_FRAME_RELATED_P (insn))
810 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
811 if (expr)
812 pattern = XEXP (expr, 0);
815 if (GET_CODE (pattern) == SET)
816 stack_adjust_offset_pre_post (pattern, pre, post);
817 else if (GET_CODE (pattern) == PARALLEL
818 || GET_CODE (pattern) == SEQUENCE)
820 int i;
822 /* There may be stack adjustments inside compound insns. Search
823 for them. */
824 for ( i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
825 if (GET_CODE (XVECEXP (pattern, 0, i)) == SET)
826 stack_adjust_offset_pre_post (XVECEXP (pattern, 0, i), pre, post);
830 /* Compute stack adjustments for all blocks by traversing DFS tree.
831 Return true when the adjustments on all incoming edges are consistent.
832 Heavily borrowed from pre_and_rev_post_order_compute. */
834 static bool
835 vt_stack_adjustments (void)
837 edge_iterator *stack;
838 int sp;
840 /* Initialize entry block. */
841 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->visited = true;
842 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->in.stack_adjust
843 = INCOMING_FRAME_SP_OFFSET;
844 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out.stack_adjust
845 = INCOMING_FRAME_SP_OFFSET;
847 /* Allocate stack for back-tracking up CFG. */
848 stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1);
849 sp = 0;
851 /* Push the first edge on to the stack. */
852 stack[sp++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
854 while (sp)
856 edge_iterator ei;
857 basic_block src;
858 basic_block dest;
860 /* Look at the edge on the top of the stack. */
861 ei = stack[sp - 1];
862 src = ei_edge (ei)->src;
863 dest = ei_edge (ei)->dest;
865 /* Check if the edge destination has been visited yet. */
866 if (!VTI (dest)->visited)
868 rtx_insn *insn;
869 HOST_WIDE_INT pre, post, offset;
870 VTI (dest)->visited = true;
871 VTI (dest)->in.stack_adjust = offset = VTI (src)->out.stack_adjust;
873 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
874 for (insn = BB_HEAD (dest);
875 insn != NEXT_INSN (BB_END (dest));
876 insn = NEXT_INSN (insn))
877 if (INSN_P (insn))
879 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
880 offset += pre + post;
883 VTI (dest)->out.stack_adjust = offset;
885 if (EDGE_COUNT (dest->succs) > 0)
886 /* Since the DEST node has been visited for the first
887 time, check its successors. */
888 stack[sp++] = ei_start (dest->succs);
890 else
892 /* We can end up with different stack adjustments for the exit block
893 of a shrink-wrapped function if stack_adjust_offset_pre_post
894 doesn't understand the rtx pattern used to restore the stack
895 pointer in the epilogue. For example, on s390(x), the stack
896 pointer is often restored via a load-multiple instruction
897 and so no stack_adjust offset is recorded for it. This means
898 that the stack offset at the end of the epilogue block is the
899 the same as the offset before the epilogue, whereas other paths
900 to the exit block will have the correct stack_adjust.
902 It is safe to ignore these differences because (a) we never
903 use the stack_adjust for the exit block in this pass and
904 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
905 function are correct.
907 We must check whether the adjustments on other edges are
908 the same though. */
909 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
910 && VTI (dest)->in.stack_adjust != VTI (src)->out.stack_adjust)
912 free (stack);
913 return false;
916 if (! ei_one_before_end_p (ei))
917 /* Go to the next edge. */
918 ei_next (&stack[sp - 1]);
919 else
920 /* Return to previous level if there are no more edges. */
921 sp--;
925 free (stack);
926 return true;
929 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
930 hard_frame_pointer_rtx is being mapped to it and offset for it. */
931 static rtx cfa_base_rtx;
932 static HOST_WIDE_INT cfa_base_offset;
934 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
935 or hard_frame_pointer_rtx. */
937 static inline rtx
938 compute_cfa_pointer (HOST_WIDE_INT adjustment)
940 return plus_constant (Pmode, cfa_base_rtx, adjustment + cfa_base_offset);
943 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
944 or -1 if the replacement shouldn't be done. */
945 static HOST_WIDE_INT hard_frame_pointer_adjustment = -1;
947 /* Data for adjust_mems callback. */
949 struct adjust_mem_data
951 bool store;
952 machine_mode mem_mode;
953 HOST_WIDE_INT stack_adjust;
954 rtx_expr_list *side_effects;
957 /* Helper for adjust_mems. Return true if X is suitable for
958 transformation of wider mode arithmetics to narrower mode. */
960 static bool
961 use_narrower_mode_test (rtx x, const_rtx subreg)
963 subrtx_var_iterator::array_type array;
964 FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST)
966 rtx x = *iter;
967 if (CONSTANT_P (x))
968 iter.skip_subrtxes ();
969 else
970 switch (GET_CODE (x))
972 case REG:
973 if (cselib_lookup (x, GET_MODE (SUBREG_REG (subreg)), 0, VOIDmode))
974 return false;
975 if (!validate_subreg (GET_MODE (subreg), GET_MODE (x), x,
976 subreg_lowpart_offset (GET_MODE (subreg),
977 GET_MODE (x))))
978 return false;
979 break;
980 case PLUS:
981 case MINUS:
982 case MULT:
983 break;
984 case ASHIFT:
985 iter.substitute (XEXP (x, 0));
986 break;
987 default:
988 return false;
991 return true;
994 /* Transform X into narrower mode MODE from wider mode WMODE. */
996 static rtx
997 use_narrower_mode (rtx x, machine_mode mode, machine_mode wmode)
999 rtx op0, op1;
1000 if (CONSTANT_P (x))
1001 return lowpart_subreg (mode, x, wmode);
1002 switch (GET_CODE (x))
1004 case REG:
1005 return lowpart_subreg (mode, x, wmode);
1006 case PLUS:
1007 case MINUS:
1008 case MULT:
1009 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
1010 op1 = use_narrower_mode (XEXP (x, 1), mode, wmode);
1011 return simplify_gen_binary (GET_CODE (x), mode, op0, op1);
1012 case ASHIFT:
1013 op0 = use_narrower_mode (XEXP (x, 0), mode, wmode);
1014 op1 = XEXP (x, 1);
1015 /* Ensure shift amount is not wider than mode. */
1016 if (GET_MODE (op1) == VOIDmode)
1017 op1 = lowpart_subreg (mode, op1, wmode);
1018 else if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (GET_MODE (op1)))
1019 op1 = lowpart_subreg (mode, op1, GET_MODE (op1));
1020 return simplify_gen_binary (ASHIFT, mode, op0, op1);
1021 default:
1022 gcc_unreachable ();
1026 /* Helper function for adjusting used MEMs. */
1028 static rtx
1029 adjust_mems (rtx loc, const_rtx old_rtx, void *data)
1031 struct adjust_mem_data *amd = (struct adjust_mem_data *) data;
1032 rtx mem, addr = loc, tem;
1033 machine_mode mem_mode_save;
1034 bool store_save;
1035 switch (GET_CODE (loc))
1037 case REG:
1038 /* Don't do any sp or fp replacements outside of MEM addresses
1039 on the LHS. */
1040 if (amd->mem_mode == VOIDmode && amd->store)
1041 return loc;
1042 if (loc == stack_pointer_rtx
1043 && !frame_pointer_needed
1044 && cfa_base_rtx)
1045 return compute_cfa_pointer (amd->stack_adjust);
1046 else if (loc == hard_frame_pointer_rtx
1047 && frame_pointer_needed
1048 && hard_frame_pointer_adjustment != -1
1049 && cfa_base_rtx)
1050 return compute_cfa_pointer (hard_frame_pointer_adjustment);
1051 gcc_checking_assert (loc != virtual_incoming_args_rtx);
1052 return loc;
1053 case MEM:
1054 mem = loc;
1055 if (!amd->store)
1057 mem = targetm.delegitimize_address (mem);
1058 if (mem != loc && !MEM_P (mem))
1059 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
1062 addr = XEXP (mem, 0);
1063 mem_mode_save = amd->mem_mode;
1064 amd->mem_mode = GET_MODE (mem);
1065 store_save = amd->store;
1066 amd->store = false;
1067 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1068 amd->store = store_save;
1069 amd->mem_mode = mem_mode_save;
1070 if (mem == loc)
1071 addr = targetm.delegitimize_address (addr);
1072 if (addr != XEXP (mem, 0))
1073 mem = replace_equiv_address_nv (mem, addr);
1074 if (!amd->store)
1075 mem = avoid_constant_pool_reference (mem);
1076 return mem;
1077 case PRE_INC:
1078 case PRE_DEC:
1079 addr = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
1080 gen_int_mode (GET_CODE (loc) == PRE_INC
1081 ? GET_MODE_SIZE (amd->mem_mode)
1082 : -GET_MODE_SIZE (amd->mem_mode),
1083 GET_MODE (loc)));
1084 case POST_INC:
1085 case POST_DEC:
1086 if (addr == loc)
1087 addr = XEXP (loc, 0);
1088 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
1089 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1090 tem = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
1091 gen_int_mode ((GET_CODE (loc) == PRE_INC
1092 || GET_CODE (loc) == POST_INC)
1093 ? GET_MODE_SIZE (amd->mem_mode)
1094 : -GET_MODE_SIZE (amd->mem_mode),
1095 GET_MODE (loc)));
1096 store_save = amd->store;
1097 amd->store = false;
1098 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
1099 amd->store = store_save;
1100 amd->side_effects = alloc_EXPR_LIST (0,
1101 gen_rtx_SET (XEXP (loc, 0), tem),
1102 amd->side_effects);
1103 return addr;
1104 case PRE_MODIFY:
1105 addr = XEXP (loc, 1);
1106 case POST_MODIFY:
1107 if (addr == loc)
1108 addr = XEXP (loc, 0);
1109 gcc_assert (amd->mem_mode != VOIDmode);
1110 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1111 store_save = amd->store;
1112 amd->store = false;
1113 tem = simplify_replace_fn_rtx (XEXP (loc, 1), old_rtx,
1114 adjust_mems, data);
1115 amd->store = store_save;
1116 amd->side_effects = alloc_EXPR_LIST (0,
1117 gen_rtx_SET (XEXP (loc, 0), tem),
1118 amd->side_effects);
1119 return addr;
1120 case SUBREG:
1121 /* First try without delegitimization of whole MEMs and
1122 avoid_constant_pool_reference, which is more likely to succeed. */
1123 store_save = amd->store;
1124 amd->store = true;
1125 addr = simplify_replace_fn_rtx (SUBREG_REG (loc), old_rtx, adjust_mems,
1126 data);
1127 amd->store = store_save;
1128 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1129 if (mem == SUBREG_REG (loc))
1131 tem = loc;
1132 goto finish_subreg;
1134 tem = simplify_gen_subreg (GET_MODE (loc), mem,
1135 GET_MODE (SUBREG_REG (loc)),
1136 SUBREG_BYTE (loc));
1137 if (tem)
1138 goto finish_subreg;
1139 tem = simplify_gen_subreg (GET_MODE (loc), addr,
1140 GET_MODE (SUBREG_REG (loc)),
1141 SUBREG_BYTE (loc));
1142 if (tem == NULL_RTX)
1143 tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
1144 finish_subreg:
1145 if (MAY_HAVE_DEBUG_INSNS
1146 && GET_CODE (tem) == SUBREG
1147 && (GET_CODE (SUBREG_REG (tem)) == PLUS
1148 || GET_CODE (SUBREG_REG (tem)) == MINUS
1149 || GET_CODE (SUBREG_REG (tem)) == MULT
1150 || GET_CODE (SUBREG_REG (tem)) == ASHIFT)
1151 && (GET_MODE_CLASS (GET_MODE (tem)) == MODE_INT
1152 || GET_MODE_CLASS (GET_MODE (tem)) == MODE_PARTIAL_INT)
1153 && (GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem))) == MODE_INT
1154 || GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem))) == MODE_PARTIAL_INT)
1155 && GET_MODE_PRECISION (GET_MODE (tem))
1156 < GET_MODE_PRECISION (GET_MODE (SUBREG_REG (tem)))
1157 && subreg_lowpart_p (tem)
1158 && use_narrower_mode_test (SUBREG_REG (tem), tem))
1159 return use_narrower_mode (SUBREG_REG (tem), GET_MODE (tem),
1160 GET_MODE (SUBREG_REG (tem)));
1161 return tem;
1162 case ASM_OPERANDS:
1163 /* Don't do any replacements in second and following
1164 ASM_OPERANDS of inline-asm with multiple sets.
1165 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1166 and ASM_OPERANDS_LABEL_VEC need to be equal between
1167 all the ASM_OPERANDs in the insn and adjust_insn will
1168 fix this up. */
1169 if (ASM_OPERANDS_OUTPUT_IDX (loc) != 0)
1170 return loc;
1171 break;
1172 default:
1173 break;
1175 return NULL_RTX;
1178 /* Helper function for replacement of uses. */
1180 static void
1181 adjust_mem_uses (rtx *x, void *data)
1183 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX, adjust_mems, data);
1184 if (new_x != *x)
1185 validate_change (NULL_RTX, x, new_x, true);
1188 /* Helper function for replacement of stores. */
1190 static void
1191 adjust_mem_stores (rtx loc, const_rtx expr, void *data)
1193 if (MEM_P (loc))
1195 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr), NULL_RTX,
1196 adjust_mems, data);
1197 if (new_dest != SET_DEST (expr))
1199 rtx xexpr = CONST_CAST_RTX (expr);
1200 validate_change (NULL_RTX, &SET_DEST (xexpr), new_dest, true);
1205 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1206 replace them with their value in the insn and add the side-effects
1207 as other sets to the insn. */
1209 static void
1210 adjust_insn (basic_block bb, rtx_insn *insn)
1212 struct adjust_mem_data amd;
1213 rtx set;
1215 #ifdef HAVE_window_save
1216 /* If the target machine has an explicit window save instruction, the
1217 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1218 if (RTX_FRAME_RELATED_P (insn)
1219 && find_reg_note (insn, REG_CFA_WINDOW_SAVE, NULL_RTX))
1221 unsigned int i, nregs = vec_safe_length (windowed_parm_regs);
1222 rtx rtl = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs * 2));
1223 parm_reg_t *p;
1225 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)
1227 XVECEXP (rtl, 0, i * 2)
1228 = gen_rtx_SET (p->incoming, p->outgoing);
1229 /* Do not clobber the attached DECL, but only the REG. */
1230 XVECEXP (rtl, 0, i * 2 + 1)
1231 = gen_rtx_CLOBBER (GET_MODE (p->outgoing),
1232 gen_raw_REG (GET_MODE (p->outgoing),
1233 REGNO (p->outgoing)));
1236 validate_change (NULL_RTX, &PATTERN (insn), rtl, true);
1237 return;
1239 #endif
1241 amd.mem_mode = VOIDmode;
1242 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
1243 amd.side_effects = NULL;
1245 amd.store = true;
1246 note_stores (PATTERN (insn), adjust_mem_stores, &amd);
1248 amd.store = false;
1249 if (GET_CODE (PATTERN (insn)) == PARALLEL
1250 && asm_noperands (PATTERN (insn)) > 0
1251 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1253 rtx body, set0;
1254 int i;
1256 /* inline-asm with multiple sets is tiny bit more complicated,
1257 because the 3 vectors in ASM_OPERANDS need to be shared between
1258 all ASM_OPERANDS in the instruction. adjust_mems will
1259 not touch ASM_OPERANDS other than the first one, asm_noperands
1260 test above needs to be called before that (otherwise it would fail)
1261 and afterwards this code fixes it up. */
1262 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1263 body = PATTERN (insn);
1264 set0 = XVECEXP (body, 0, 0);
1265 gcc_checking_assert (GET_CODE (set0) == SET
1266 && GET_CODE (SET_SRC (set0)) == ASM_OPERANDS
1267 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0)) == 0);
1268 for (i = 1; i < XVECLEN (body, 0); i++)
1269 if (GET_CODE (XVECEXP (body, 0, i)) != SET)
1270 break;
1271 else
1273 set = XVECEXP (body, 0, i);
1274 gcc_checking_assert (GET_CODE (SET_SRC (set)) == ASM_OPERANDS
1275 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set))
1276 == i);
1277 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set))
1278 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))
1279 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set))
1280 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))
1281 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set))
1282 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0)))
1284 rtx newsrc = shallow_copy_rtx (SET_SRC (set));
1285 ASM_OPERANDS_INPUT_VEC (newsrc)
1286 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0));
1287 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc)
1288 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0));
1289 ASM_OPERANDS_LABEL_VEC (newsrc)
1290 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0));
1291 validate_change (NULL_RTX, &SET_SRC (set), newsrc, true);
1295 else
1296 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1298 /* For read-only MEMs containing some constant, prefer those
1299 constants. */
1300 set = single_set (insn);
1301 if (set && MEM_P (SET_SRC (set)) && MEM_READONLY_P (SET_SRC (set)))
1303 rtx note = find_reg_equal_equiv_note (insn);
1305 if (note && CONSTANT_P (XEXP (note, 0)))
1306 validate_change (NULL_RTX, &SET_SRC (set), XEXP (note, 0), true);
1309 if (amd.side_effects)
1311 rtx *pat, new_pat, s;
1312 int i, oldn, newn;
1314 pat = &PATTERN (insn);
1315 if (GET_CODE (*pat) == COND_EXEC)
1316 pat = &COND_EXEC_CODE (*pat);
1317 if (GET_CODE (*pat) == PARALLEL)
1318 oldn = XVECLEN (*pat, 0);
1319 else
1320 oldn = 1;
1321 for (s = amd.side_effects, newn = 0; s; newn++)
1322 s = XEXP (s, 1);
1323 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn));
1324 if (GET_CODE (*pat) == PARALLEL)
1325 for (i = 0; i < oldn; i++)
1326 XVECEXP (new_pat, 0, i) = XVECEXP (*pat, 0, i);
1327 else
1328 XVECEXP (new_pat, 0, 0) = *pat;
1329 for (s = amd.side_effects, i = oldn; i < oldn + newn; i++, s = XEXP (s, 1))
1330 XVECEXP (new_pat, 0, i) = XEXP (s, 0);
1331 free_EXPR_LIST_list (&amd.side_effects);
1332 validate_change (NULL_RTX, pat, new_pat, true);
1336 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1337 static inline rtx
1338 dv_as_rtx (decl_or_value dv)
1340 tree decl;
1342 if (dv_is_value_p (dv))
1343 return dv_as_value (dv);
1345 decl = dv_as_decl (dv);
1347 gcc_checking_assert (TREE_CODE (decl) == DEBUG_EXPR_DECL);
1348 return DECL_RTL_KNOWN_SET (decl);
1351 /* Return nonzero if a decl_or_value must not have more than one
1352 variable part. The returned value discriminates among various
1353 kinds of one-part DVs ccording to enum onepart_enum. */
1354 static inline onepart_enum_t
1355 dv_onepart_p (decl_or_value dv)
1357 tree decl;
1359 if (!MAY_HAVE_DEBUG_INSNS)
1360 return NOT_ONEPART;
1362 if (dv_is_value_p (dv))
1363 return ONEPART_VALUE;
1365 decl = dv_as_decl (dv);
1367 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
1368 return ONEPART_DEXPR;
1370 if (target_for_debug_bind (decl) != NULL_TREE)
1371 return ONEPART_VDECL;
1373 return NOT_ONEPART;
1376 /* Return the variable pool to be used for a dv of type ONEPART. */
1377 static inline alloc_pool
1378 onepart_pool (onepart_enum_t onepart)
1380 return onepart ? valvar_pool : var_pool;
1383 /* Build a decl_or_value out of a decl. */
1384 static inline decl_or_value
1385 dv_from_decl (tree decl)
1387 decl_or_value dv;
1388 dv = decl;
1389 gcc_checking_assert (dv_is_decl_p (dv));
1390 return dv;
1393 /* Build a decl_or_value out of a value. */
1394 static inline decl_or_value
1395 dv_from_value (rtx value)
1397 decl_or_value dv;
1398 dv = value;
1399 gcc_checking_assert (dv_is_value_p (dv));
1400 return dv;
1403 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1404 static inline decl_or_value
1405 dv_from_rtx (rtx x)
1407 decl_or_value dv;
1409 switch (GET_CODE (x))
1411 case DEBUG_EXPR:
1412 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x));
1413 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x)) == x);
1414 break;
1416 case VALUE:
1417 dv = dv_from_value (x);
1418 break;
1420 default:
1421 gcc_unreachable ();
1424 return dv;
1427 extern void debug_dv (decl_or_value dv);
1429 DEBUG_FUNCTION void
1430 debug_dv (decl_or_value dv)
1432 if (dv_is_value_p (dv))
1433 debug_rtx (dv_as_value (dv));
1434 else
1435 debug_generic_stmt (dv_as_decl (dv));
1438 static void loc_exp_dep_clear (variable var);
1440 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1442 static void
1443 variable_htab_free (void *elem)
1445 int i;
1446 variable var = (variable) elem;
1447 location_chain node, next;
1449 gcc_checking_assert (var->refcount > 0);
1451 var->refcount--;
1452 if (var->refcount > 0)
1453 return;
1455 for (i = 0; i < var->n_var_parts; i++)
1457 for (node = var->var_part[i].loc_chain; node; node = next)
1459 next = node->next;
1460 pool_free (loc_chain_pool, node);
1462 var->var_part[i].loc_chain = NULL;
1464 if (var->onepart && VAR_LOC_1PAUX (var))
1466 loc_exp_dep_clear (var);
1467 if (VAR_LOC_DEP_LST (var))
1468 VAR_LOC_DEP_LST (var)->pprev = NULL;
1469 XDELETE (VAR_LOC_1PAUX (var));
1470 /* These may be reused across functions, so reset
1471 e.g. NO_LOC_P. */
1472 if (var->onepart == ONEPART_DEXPR)
1473 set_dv_changed (var->dv, true);
1475 pool_free (onepart_pool (var->onepart), var);
1478 /* Initialize the set (array) SET of attrs to empty lists. */
1480 static void
1481 init_attrs_list_set (attrs *set)
1483 int i;
1485 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1486 set[i] = NULL;
1489 /* Make the list *LISTP empty. */
1491 static void
1492 attrs_list_clear (attrs *listp)
1494 attrs list, next;
1496 for (list = *listp; list; list = next)
1498 next = list->next;
1499 pool_free (attrs_pool, list);
1501 *listp = NULL;
1504 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1506 static attrs
1507 attrs_list_member (attrs list, decl_or_value dv, HOST_WIDE_INT offset)
1509 for (; list; list = list->next)
1510 if (dv_as_opaque (list->dv) == dv_as_opaque (dv) && list->offset == offset)
1511 return list;
1512 return NULL;
1515 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1517 static void
1518 attrs_list_insert (attrs *listp, decl_or_value dv,
1519 HOST_WIDE_INT offset, rtx loc)
1521 attrs list;
1523 list = (attrs) pool_alloc (attrs_pool);
1524 list->loc = loc;
1525 list->dv = dv;
1526 list->offset = offset;
1527 list->next = *listp;
1528 *listp = list;
1531 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1533 static void
1534 attrs_list_copy (attrs *dstp, attrs src)
1536 attrs n;
1538 attrs_list_clear (dstp);
1539 for (; src; src = src->next)
1541 n = (attrs) pool_alloc (attrs_pool);
1542 n->loc = src->loc;
1543 n->dv = src->dv;
1544 n->offset = src->offset;
1545 n->next = *dstp;
1546 *dstp = n;
1550 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1552 static void
1553 attrs_list_union (attrs *dstp, attrs src)
1555 for (; src; src = src->next)
1557 if (!attrs_list_member (*dstp, src->dv, src->offset))
1558 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1562 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1563 *DSTP. */
1565 static void
1566 attrs_list_mpdv_union (attrs *dstp, attrs src, attrs src2)
1568 gcc_assert (!*dstp);
1569 for (; src; src = src->next)
1571 if (!dv_onepart_p (src->dv))
1572 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1574 for (src = src2; src; src = src->next)
1576 if (!dv_onepart_p (src->dv)
1577 && !attrs_list_member (*dstp, src->dv, src->offset))
1578 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1582 /* Shared hashtable support. */
1584 /* Return true if VARS is shared. */
1586 static inline bool
1587 shared_hash_shared (shared_hash vars)
1589 return vars->refcount > 1;
1592 /* Return the hash table for VARS. */
1594 static inline variable_table_type *
1595 shared_hash_htab (shared_hash vars)
1597 return vars->htab;
1600 /* Return true if VAR is shared, or maybe because VARS is shared. */
1602 static inline bool
1603 shared_var_p (variable var, shared_hash vars)
1605 /* Don't count an entry in the changed_variables table as a duplicate. */
1606 return ((var->refcount > 1 + (int) var->in_changed_variables)
1607 || shared_hash_shared (vars));
1610 /* Copy variables into a new hash table. */
1612 static shared_hash
1613 shared_hash_unshare (shared_hash vars)
1615 shared_hash new_vars = (shared_hash) pool_alloc (shared_hash_pool);
1616 gcc_assert (vars->refcount > 1);
1617 new_vars->refcount = 1;
1618 new_vars->htab = new variable_table_type (vars->htab->elements () + 3);
1619 vars_copy (new_vars->htab, vars->htab);
1620 vars->refcount--;
1621 return new_vars;
1624 /* Increment reference counter on VARS and return it. */
1626 static inline shared_hash
1627 shared_hash_copy (shared_hash vars)
1629 vars->refcount++;
1630 return vars;
1633 /* Decrement reference counter and destroy hash table if not shared
1634 anymore. */
1636 static void
1637 shared_hash_destroy (shared_hash vars)
1639 gcc_checking_assert (vars->refcount > 0);
1640 if (--vars->refcount == 0)
1642 delete vars->htab;
1643 pool_free (shared_hash_pool, vars);
1647 /* Unshare *PVARS if shared and return slot for DV. If INS is
1648 INSERT, insert it if not already present. */
1650 static inline variable_def **
1651 shared_hash_find_slot_unshare_1 (shared_hash *pvars, decl_or_value dv,
1652 hashval_t dvhash, enum insert_option ins)
1654 if (shared_hash_shared (*pvars))
1655 *pvars = shared_hash_unshare (*pvars);
1656 return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins);
1659 static inline variable_def **
1660 shared_hash_find_slot_unshare (shared_hash *pvars, decl_or_value dv,
1661 enum insert_option ins)
1663 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1666 /* Return slot for DV, if it is already present in the hash table.
1667 If it is not present, insert it only VARS is not shared, otherwise
1668 return NULL. */
1670 static inline variable_def **
1671 shared_hash_find_slot_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
1673 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash,
1674 shared_hash_shared (vars)
1675 ? NO_INSERT : INSERT);
1678 static inline variable_def **
1679 shared_hash_find_slot (shared_hash vars, decl_or_value dv)
1681 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1684 /* Return slot for DV only if it is already present in the hash table. */
1686 static inline variable_def **
1687 shared_hash_find_slot_noinsert_1 (shared_hash vars, decl_or_value dv,
1688 hashval_t dvhash)
1690 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT);
1693 static inline variable_def **
1694 shared_hash_find_slot_noinsert (shared_hash vars, decl_or_value dv)
1696 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1699 /* Return variable for DV or NULL if not already present in the hash
1700 table. */
1702 static inline variable
1703 shared_hash_find_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
1705 return shared_hash_htab (vars)->find_with_hash (dv, dvhash);
1708 static inline variable
1709 shared_hash_find (shared_hash vars, decl_or_value dv)
1711 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1714 /* Return true if TVAL is better than CVAL as a canonival value. We
1715 choose lowest-numbered VALUEs, using the RTX address as a
1716 tie-breaker. The idea is to arrange them into a star topology,
1717 such that all of them are at most one step away from the canonical
1718 value, and the canonical value has backlinks to all of them, in
1719 addition to all the actual locations. We don't enforce this
1720 topology throughout the entire dataflow analysis, though.
1723 static inline bool
1724 canon_value_cmp (rtx tval, rtx cval)
1726 return !cval
1727 || CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
1730 static bool dst_can_be_shared;
1732 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1734 static variable_def **
1735 unshare_variable (dataflow_set *set, variable_def **slot, variable var,
1736 enum var_init_status initialized)
1738 variable new_var;
1739 int i;
1741 new_var = (variable) pool_alloc (onepart_pool (var->onepart));
1742 new_var->dv = var->dv;
1743 new_var->refcount = 1;
1744 var->refcount--;
1745 new_var->n_var_parts = var->n_var_parts;
1746 new_var->onepart = var->onepart;
1747 new_var->in_changed_variables = false;
1749 if (! flag_var_tracking_uninit)
1750 initialized = VAR_INIT_STATUS_INITIALIZED;
1752 for (i = 0; i < var->n_var_parts; i++)
1754 location_chain node;
1755 location_chain *nextp;
1757 if (i == 0 && var->onepart)
1759 /* One-part auxiliary data is only used while emitting
1760 notes, so propagate it to the new variable in the active
1761 dataflow set. If we're not emitting notes, this will be
1762 a no-op. */
1763 gcc_checking_assert (!VAR_LOC_1PAUX (var) || emit_notes);
1764 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (var);
1765 VAR_LOC_1PAUX (var) = NULL;
1767 else
1768 VAR_PART_OFFSET (new_var, i) = VAR_PART_OFFSET (var, i);
1769 nextp = &new_var->var_part[i].loc_chain;
1770 for (node = var->var_part[i].loc_chain; node; node = node->next)
1772 location_chain new_lc;
1774 new_lc = (location_chain) pool_alloc (loc_chain_pool);
1775 new_lc->next = NULL;
1776 if (node->init > initialized)
1777 new_lc->init = node->init;
1778 else
1779 new_lc->init = initialized;
1780 if (node->set_src && !(MEM_P (node->set_src)))
1781 new_lc->set_src = node->set_src;
1782 else
1783 new_lc->set_src = NULL;
1784 new_lc->loc = node->loc;
1786 *nextp = new_lc;
1787 nextp = &new_lc->next;
1790 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1793 dst_can_be_shared = false;
1794 if (shared_hash_shared (set->vars))
1795 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1796 else if (set->traversed_vars && set->vars != set->traversed_vars)
1797 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1798 *slot = new_var;
1799 if (var->in_changed_variables)
1801 variable_def **cslot
1802 = changed_variables->find_slot_with_hash (var->dv,
1803 dv_htab_hash (var->dv),
1804 NO_INSERT);
1805 gcc_assert (*cslot == (void *) var);
1806 var->in_changed_variables = false;
1807 variable_htab_free (var);
1808 *cslot = new_var;
1809 new_var->in_changed_variables = true;
1811 return slot;
1814 /* Copy all variables from hash table SRC to hash table DST. */
1816 static void
1817 vars_copy (variable_table_type *dst, variable_table_type *src)
1819 variable_iterator_type hi;
1820 variable var;
1822 FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi)
1824 variable_def **dstp;
1825 var->refcount++;
1826 dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv),
1827 INSERT);
1828 *dstp = var;
1832 /* Map a decl to its main debug decl. */
1834 static inline tree
1835 var_debug_decl (tree decl)
1837 if (decl && TREE_CODE (decl) == VAR_DECL
1838 && DECL_HAS_DEBUG_EXPR_P (decl))
1840 tree debugdecl = DECL_DEBUG_EXPR (decl);
1841 if (DECL_P (debugdecl))
1842 decl = debugdecl;
1845 return decl;
1848 /* Set the register LOC to contain DV, OFFSET. */
1850 static void
1851 var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1852 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1853 enum insert_option iopt)
1855 attrs node;
1856 bool decl_p = dv_is_decl_p (dv);
1858 if (decl_p)
1859 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1861 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1862 if (dv_as_opaque (node->dv) == dv_as_opaque (dv)
1863 && node->offset == offset)
1864 break;
1865 if (!node)
1866 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
1867 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1870 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1872 static void
1873 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1874 rtx set_src)
1876 tree decl = REG_EXPR (loc);
1877 HOST_WIDE_INT offset = REG_OFFSET (loc);
1879 var_reg_decl_set (set, loc, initialized,
1880 dv_from_decl (decl), offset, set_src, INSERT);
1883 static enum var_init_status
1884 get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1886 variable var;
1887 int i;
1888 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1890 if (! flag_var_tracking_uninit)
1891 return VAR_INIT_STATUS_INITIALIZED;
1893 var = shared_hash_find (set->vars, dv);
1894 if (var)
1896 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1898 location_chain nextp;
1899 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1900 if (rtx_equal_p (nextp->loc, loc))
1902 ret_val = nextp->init;
1903 break;
1908 return ret_val;
1911 /* Delete current content of register LOC in dataflow set SET and set
1912 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1913 MODIFY is true, any other live copies of the same variable part are
1914 also deleted from the dataflow set, otherwise the variable part is
1915 assumed to be copied from another location holding the same
1916 part. */
1918 static void
1919 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1920 enum var_init_status initialized, rtx set_src)
1922 tree decl = REG_EXPR (loc);
1923 HOST_WIDE_INT offset = REG_OFFSET (loc);
1924 attrs node, next;
1925 attrs *nextp;
1927 decl = var_debug_decl (decl);
1929 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1930 initialized = get_init_value (set, loc, dv_from_decl (decl));
1932 nextp = &set->regs[REGNO (loc)];
1933 for (node = *nextp; node; node = next)
1935 next = node->next;
1936 if (dv_as_opaque (node->dv) != decl || node->offset != offset)
1938 delete_variable_part (set, node->loc, node->dv, node->offset);
1939 pool_free (attrs_pool, node);
1940 *nextp = next;
1942 else
1944 node->loc = loc;
1945 nextp = &node->next;
1948 if (modify)
1949 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1950 var_reg_set (set, loc, initialized, set_src);
1953 /* Delete the association of register LOC in dataflow set SET with any
1954 variables that aren't onepart. If CLOBBER is true, also delete any
1955 other live copies of the same variable part, and delete the
1956 association with onepart dvs too. */
1958 static void
1959 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1961 attrs *nextp = &set->regs[REGNO (loc)];
1962 attrs node, next;
1964 if (clobber)
1966 tree decl = REG_EXPR (loc);
1967 HOST_WIDE_INT offset = REG_OFFSET (loc);
1969 decl = var_debug_decl (decl);
1971 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1974 for (node = *nextp; node; node = next)
1976 next = node->next;
1977 if (clobber || !dv_onepart_p (node->dv))
1979 delete_variable_part (set, node->loc, node->dv, node->offset);
1980 pool_free (attrs_pool, node);
1981 *nextp = next;
1983 else
1984 nextp = &node->next;
1988 /* Delete content of register with number REGNO in dataflow set SET. */
1990 static void
1991 var_regno_delete (dataflow_set *set, int regno)
1993 attrs *reg = &set->regs[regno];
1994 attrs node, next;
1996 for (node = *reg; node; node = next)
1998 next = node->next;
1999 delete_variable_part (set, node->loc, node->dv, node->offset);
2000 pool_free (attrs_pool, node);
2002 *reg = NULL;
2005 /* Return true if I is the negated value of a power of two. */
2006 static bool
2007 negative_power_of_two_p (HOST_WIDE_INT i)
2009 unsigned HOST_WIDE_INT x = -(unsigned HOST_WIDE_INT)i;
2010 return x == (x & -x);
2013 /* Strip constant offsets and alignments off of LOC. Return the base
2014 expression. */
2016 static rtx
2017 vt_get_canonicalize_base (rtx loc)
2019 while ((GET_CODE (loc) == PLUS
2020 || GET_CODE (loc) == AND)
2021 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2022 && (GET_CODE (loc) != AND
2023 || negative_power_of_two_p (INTVAL (XEXP (loc, 1)))))
2024 loc = XEXP (loc, 0);
2026 return loc;
2029 /* This caches canonicalized addresses for VALUEs, computed using
2030 information in the global cselib table. */
2031 static hash_map<rtx, rtx> *global_get_addr_cache;
2033 /* This caches canonicalized addresses for VALUEs, computed using
2034 information from the global cache and information pertaining to a
2035 basic block being analyzed. */
2036 static hash_map<rtx, rtx> *local_get_addr_cache;
2038 static rtx vt_canonicalize_addr (dataflow_set *, rtx);
2040 /* Return the canonical address for LOC, that must be a VALUE, using a
2041 cached global equivalence or computing it and storing it in the
2042 global cache. */
2044 static rtx
2045 get_addr_from_global_cache (rtx const loc)
2047 rtx x;
2049 gcc_checking_assert (GET_CODE (loc) == VALUE);
2051 bool existed;
2052 rtx *slot = &global_get_addr_cache->get_or_insert (loc, &existed);
2053 if (existed)
2054 return *slot;
2056 x = canon_rtx (get_addr (loc));
2058 /* Tentative, avoiding infinite recursion. */
2059 *slot = x;
2061 if (x != loc)
2063 rtx nx = vt_canonicalize_addr (NULL, x);
2064 if (nx != x)
2066 /* The table may have moved during recursion, recompute
2067 SLOT. */
2068 *global_get_addr_cache->get (loc) = x = nx;
2072 return x;
2075 /* Return the canonical address for LOC, that must be a VALUE, using a
2076 cached local equivalence or computing it and storing it in the
2077 local cache. */
2079 static rtx
2080 get_addr_from_local_cache (dataflow_set *set, rtx const loc)
2082 rtx x;
2083 decl_or_value dv;
2084 variable var;
2085 location_chain l;
2087 gcc_checking_assert (GET_CODE (loc) == VALUE);
2089 bool existed;
2090 rtx *slot = &local_get_addr_cache->get_or_insert (loc, &existed);
2091 if (existed)
2092 return *slot;
2094 x = get_addr_from_global_cache (loc);
2096 /* Tentative, avoiding infinite recursion. */
2097 *slot = x;
2099 /* Recurse to cache local expansion of X, or if we need to search
2100 for a VALUE in the expansion. */
2101 if (x != loc)
2103 rtx nx = vt_canonicalize_addr (set, x);
2104 if (nx != x)
2106 slot = local_get_addr_cache->get (loc);
2107 *slot = x = nx;
2109 return x;
2112 dv = dv_from_rtx (x);
2113 var = shared_hash_find (set->vars, dv);
2114 if (!var)
2115 return x;
2117 /* Look for an improved equivalent expression. */
2118 for (l = var->var_part[0].loc_chain; l; l = l->next)
2120 rtx base = vt_get_canonicalize_base (l->loc);
2121 if (GET_CODE (base) == VALUE
2122 && canon_value_cmp (base, loc))
2124 rtx nx = vt_canonicalize_addr (set, l->loc);
2125 if (x != nx)
2127 slot = local_get_addr_cache->get (loc);
2128 *slot = x = nx;
2130 break;
2134 return x;
2137 /* Canonicalize LOC using equivalences from SET in addition to those
2138 in the cselib static table. It expects a VALUE-based expression,
2139 and it will only substitute VALUEs with other VALUEs or
2140 function-global equivalences, so that, if two addresses have base
2141 VALUEs that are locally or globally related in ways that
2142 memrefs_conflict_p cares about, they will both canonicalize to
2143 expressions that have the same base VALUE.
2145 The use of VALUEs as canonical base addresses enables the canonical
2146 RTXs to remain unchanged globally, if they resolve to a constant,
2147 or throughout a basic block otherwise, so that they can be cached
2148 and the cache needs not be invalidated when REGs, MEMs or such
2149 change. */
2151 static rtx
2152 vt_canonicalize_addr (dataflow_set *set, rtx oloc)
2154 HOST_WIDE_INT ofst = 0;
2155 machine_mode mode = GET_MODE (oloc);
2156 rtx loc = oloc;
2157 rtx x;
2158 bool retry = true;
2160 while (retry)
2162 while (GET_CODE (loc) == PLUS
2163 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2165 ofst += INTVAL (XEXP (loc, 1));
2166 loc = XEXP (loc, 0);
2169 /* Alignment operations can't normally be combined, so just
2170 canonicalize the base and we're done. We'll normally have
2171 only one stack alignment anyway. */
2172 if (GET_CODE (loc) == AND
2173 && GET_CODE (XEXP (loc, 1)) == CONST_INT
2174 && negative_power_of_two_p (INTVAL (XEXP (loc, 1))))
2176 x = vt_canonicalize_addr (set, XEXP (loc, 0));
2177 if (x != XEXP (loc, 0))
2178 loc = gen_rtx_AND (mode, x, XEXP (loc, 1));
2179 retry = false;
2182 if (GET_CODE (loc) == VALUE)
2184 if (set)
2185 loc = get_addr_from_local_cache (set, loc);
2186 else
2187 loc = get_addr_from_global_cache (loc);
2189 /* Consolidate plus_constants. */
2190 while (ofst && GET_CODE (loc) == PLUS
2191 && GET_CODE (XEXP (loc, 1)) == CONST_INT)
2193 ofst += INTVAL (XEXP (loc, 1));
2194 loc = XEXP (loc, 0);
2197 retry = false;
2199 else
2201 x = canon_rtx (loc);
2202 if (retry)
2203 retry = (x != loc);
2204 loc = x;
2208 /* Add OFST back in. */
2209 if (ofst)
2211 /* Don't build new RTL if we can help it. */
2212 if (GET_CODE (oloc) == PLUS
2213 && XEXP (oloc, 0) == loc
2214 && INTVAL (XEXP (oloc, 1)) == ofst)
2215 return oloc;
2217 loc = plus_constant (mode, loc, ofst);
2220 return loc;
2223 /* Return true iff there's a true dependence between MLOC and LOC.
2224 MADDR must be a canonicalized version of MLOC's address. */
2226 static inline bool
2227 vt_canon_true_dep (dataflow_set *set, rtx mloc, rtx maddr, rtx loc)
2229 if (GET_CODE (loc) != MEM)
2230 return false;
2232 rtx addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2233 if (!canon_true_dependence (mloc, GET_MODE (mloc), maddr, loc, addr))
2234 return false;
2236 return true;
2239 /* Hold parameters for the hashtab traversal function
2240 drop_overlapping_mem_locs, see below. */
2242 struct overlapping_mems
2244 dataflow_set *set;
2245 rtx loc, addr;
2248 /* Remove all MEMs that overlap with COMS->LOC from the location list
2249 of a hash table entry for a value. COMS->ADDR must be a
2250 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2251 canonicalized itself. */
2254 drop_overlapping_mem_locs (variable_def **slot, overlapping_mems *coms)
2256 dataflow_set *set = coms->set;
2257 rtx mloc = coms->loc, addr = coms->addr;
2258 variable var = *slot;
2260 if (var->onepart == ONEPART_VALUE)
2262 location_chain loc, *locp;
2263 bool changed = false;
2264 rtx cur_loc;
2266 gcc_assert (var->n_var_parts == 1);
2268 if (shared_var_p (var, set->vars))
2270 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
2271 if (vt_canon_true_dep (set, mloc, addr, loc->loc))
2272 break;
2274 if (!loc)
2275 return 1;
2277 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
2278 var = *slot;
2279 gcc_assert (var->n_var_parts == 1);
2282 if (VAR_LOC_1PAUX (var))
2283 cur_loc = VAR_LOC_FROM (var);
2284 else
2285 cur_loc = var->var_part[0].cur_loc;
2287 for (locp = &var->var_part[0].loc_chain, loc = *locp;
2288 loc; loc = *locp)
2290 if (!vt_canon_true_dep (set, mloc, addr, loc->loc))
2292 locp = &loc->next;
2293 continue;
2296 *locp = loc->next;
2297 /* If we have deleted the location which was last emitted
2298 we have to emit new location so add the variable to set
2299 of changed variables. */
2300 if (cur_loc == loc->loc)
2302 changed = true;
2303 var->var_part[0].cur_loc = NULL;
2304 if (VAR_LOC_1PAUX (var))
2305 VAR_LOC_FROM (var) = NULL;
2307 pool_free (loc_chain_pool, loc);
2310 if (!var->var_part[0].loc_chain)
2312 var->n_var_parts--;
2313 changed = true;
2315 if (changed)
2316 variable_was_changed (var, set);
2319 return 1;
2322 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2324 static void
2325 clobber_overlapping_mems (dataflow_set *set, rtx loc)
2327 struct overlapping_mems coms;
2329 gcc_checking_assert (GET_CODE (loc) == MEM);
2331 coms.set = set;
2332 coms.loc = canon_rtx (loc);
2333 coms.addr = vt_canonicalize_addr (set, XEXP (loc, 0));
2335 set->traversed_vars = set->vars;
2336 shared_hash_htab (set->vars)
2337 ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms);
2338 set->traversed_vars = NULL;
2341 /* Set the location of DV, OFFSET as the MEM LOC. */
2343 static void
2344 var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2345 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
2346 enum insert_option iopt)
2348 if (dv_is_decl_p (dv))
2349 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
2351 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
2354 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2355 SET to LOC.
2356 Adjust the address first if it is stack pointer based. */
2358 static void
2359 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2360 rtx set_src)
2362 tree decl = MEM_EXPR (loc);
2363 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
2365 var_mem_decl_set (set, loc, initialized,
2366 dv_from_decl (decl), offset, set_src, INSERT);
2369 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2370 dataflow set SET to LOC. If MODIFY is true, any other live copies
2371 of the same variable part are also deleted from the dataflow set,
2372 otherwise the variable part is assumed to be copied from another
2373 location holding the same part.
2374 Adjust the address first if it is stack pointer based. */
2376 static void
2377 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
2378 enum var_init_status initialized, rtx set_src)
2380 tree decl = MEM_EXPR (loc);
2381 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
2383 clobber_overlapping_mems (set, loc);
2384 decl = var_debug_decl (decl);
2386 if (initialized == VAR_INIT_STATUS_UNKNOWN)
2387 initialized = get_init_value (set, loc, dv_from_decl (decl));
2389 if (modify)
2390 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, set_src);
2391 var_mem_set (set, loc, initialized, set_src);
2394 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2395 true, also delete any other live copies of the same variable part.
2396 Adjust the address first if it is stack pointer based. */
2398 static void
2399 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
2401 tree decl = MEM_EXPR (loc);
2402 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
2404 clobber_overlapping_mems (set, loc);
2405 decl = var_debug_decl (decl);
2406 if (clobber)
2407 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
2408 delete_variable_part (set, loc, dv_from_decl (decl), offset);
2411 /* Return true if LOC should not be expanded for location expressions,
2412 or used in them. */
2414 static inline bool
2415 unsuitable_loc (rtx loc)
2417 switch (GET_CODE (loc))
2419 case PC:
2420 case SCRATCH:
2421 case CC0:
2422 case ASM_INPUT:
2423 case ASM_OPERANDS:
2424 return true;
2426 default:
2427 return false;
2431 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2432 bound to it. */
2434 static inline void
2435 val_bind (dataflow_set *set, rtx val, rtx loc, bool modified)
2437 if (REG_P (loc))
2439 if (modified)
2440 var_regno_delete (set, REGNO (loc));
2441 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2442 dv_from_value (val), 0, NULL_RTX, INSERT);
2444 else if (MEM_P (loc))
2446 struct elt_loc_list *l = CSELIB_VAL_PTR (val)->locs;
2448 if (modified)
2449 clobber_overlapping_mems (set, loc);
2451 if (l && GET_CODE (l->loc) == VALUE)
2452 l = canonical_cselib_val (CSELIB_VAL_PTR (l->loc))->locs;
2454 /* If this MEM is a global constant, we don't need it in the
2455 dynamic tables. ??? We should test this before emitting the
2456 micro-op in the first place. */
2457 while (l)
2458 if (GET_CODE (l->loc) == MEM && XEXP (l->loc, 0) == XEXP (loc, 0))
2459 break;
2460 else
2461 l = l->next;
2463 if (!l)
2464 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2465 dv_from_value (val), 0, NULL_RTX, INSERT);
2467 else
2469 /* Other kinds of equivalences are necessarily static, at least
2470 so long as we do not perform substitutions while merging
2471 expressions. */
2472 gcc_unreachable ();
2473 set_variable_part (set, loc, dv_from_value (val), 0,
2474 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2478 /* Bind a value to a location it was just stored in. If MODIFIED
2479 holds, assume the location was modified, detaching it from any
2480 values bound to it. */
2482 static void
2483 val_store (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn,
2484 bool modified)
2486 cselib_val *v = CSELIB_VAL_PTR (val);
2488 gcc_assert (cselib_preserved_value_p (v));
2490 if (dump_file)
2492 fprintf (dump_file, "%i: ", insn ? INSN_UID (insn) : 0);
2493 print_inline_rtx (dump_file, loc, 0);
2494 fprintf (dump_file, " evaluates to ");
2495 print_inline_rtx (dump_file, val, 0);
2496 if (v->locs)
2498 struct elt_loc_list *l;
2499 for (l = v->locs; l; l = l->next)
2501 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
2502 print_inline_rtx (dump_file, l->loc, 0);
2505 fprintf (dump_file, "\n");
2508 gcc_checking_assert (!unsuitable_loc (loc));
2510 val_bind (set, val, loc, modified);
2513 /* Clear (canonical address) slots that reference X. */
2515 bool
2516 local_get_addr_clear_given_value (rtx const &, rtx *slot, rtx x)
2518 if (vt_get_canonicalize_base (*slot) == x)
2519 *slot = NULL;
2520 return true;
2523 /* Reset this node, detaching all its equivalences. Return the slot
2524 in the variable hash table that holds dv, if there is one. */
2526 static void
2527 val_reset (dataflow_set *set, decl_or_value dv)
2529 variable var = shared_hash_find (set->vars, dv) ;
2530 location_chain node;
2531 rtx cval;
2533 if (!var || !var->n_var_parts)
2534 return;
2536 gcc_assert (var->n_var_parts == 1);
2538 if (var->onepart == ONEPART_VALUE)
2540 rtx x = dv_as_value (dv);
2542 /* Relationships in the global cache don't change, so reset the
2543 local cache entry only. */
2544 rtx *slot = local_get_addr_cache->get (x);
2545 if (slot)
2547 /* If the value resolved back to itself, odds are that other
2548 values may have cached it too. These entries now refer
2549 to the old X, so detach them too. Entries that used the
2550 old X but resolved to something else remain ok as long as
2551 that something else isn't also reset. */
2552 if (*slot == x)
2553 local_get_addr_cache
2554 ->traverse<rtx, local_get_addr_clear_given_value> (x);
2555 *slot = NULL;
2559 cval = NULL;
2560 for (node = var->var_part[0].loc_chain; node; node = node->next)
2561 if (GET_CODE (node->loc) == VALUE
2562 && canon_value_cmp (node->loc, cval))
2563 cval = node->loc;
2565 for (node = var->var_part[0].loc_chain; node; node = node->next)
2566 if (GET_CODE (node->loc) == VALUE && cval != node->loc)
2568 /* Redirect the equivalence link to the new canonical
2569 value, or simply remove it if it would point at
2570 itself. */
2571 if (cval)
2572 set_variable_part (set, cval, dv_from_value (node->loc),
2573 0, node->init, node->set_src, NO_INSERT);
2574 delete_variable_part (set, dv_as_value (dv),
2575 dv_from_value (node->loc), 0);
2578 if (cval)
2580 decl_or_value cdv = dv_from_value (cval);
2582 /* Keep the remaining values connected, accummulating links
2583 in the canonical value. */
2584 for (node = var->var_part[0].loc_chain; node; node = node->next)
2586 if (node->loc == cval)
2587 continue;
2588 else if (GET_CODE (node->loc) == REG)
2589 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
2590 node->set_src, NO_INSERT);
2591 else if (GET_CODE (node->loc) == MEM)
2592 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
2593 node->set_src, NO_INSERT);
2594 else
2595 set_variable_part (set, node->loc, cdv, 0,
2596 node->init, node->set_src, NO_INSERT);
2600 /* We remove this last, to make sure that the canonical value is not
2601 removed to the point of requiring reinsertion. */
2602 if (cval)
2603 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
2605 clobber_variable_part (set, NULL, dv, 0, NULL);
2608 /* Find the values in a given location and map the val to another
2609 value, if it is unique, or add the location as one holding the
2610 value. */
2612 static void
2613 val_resolve (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn)
2615 decl_or_value dv = dv_from_value (val);
2617 if (dump_file && (dump_flags & TDF_DETAILS))
2619 if (insn)
2620 fprintf (dump_file, "%i: ", INSN_UID (insn));
2621 else
2622 fprintf (dump_file, "head: ");
2623 print_inline_rtx (dump_file, val, 0);
2624 fputs (" is at ", dump_file);
2625 print_inline_rtx (dump_file, loc, 0);
2626 fputc ('\n', dump_file);
2629 val_reset (set, dv);
2631 gcc_checking_assert (!unsuitable_loc (loc));
2633 if (REG_P (loc))
2635 attrs node, found = NULL;
2637 for (node = set->regs[REGNO (loc)]; node; node = node->next)
2638 if (dv_is_value_p (node->dv)
2639 && GET_MODE (dv_as_value (node->dv)) == GET_MODE (loc))
2641 found = node;
2643 /* Map incoming equivalences. ??? Wouldn't it be nice if
2644 we just started sharing the location lists? Maybe a
2645 circular list ending at the value itself or some
2646 such. */
2647 set_variable_part (set, dv_as_value (node->dv),
2648 dv_from_value (val), node->offset,
2649 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2650 set_variable_part (set, val, node->dv, node->offset,
2651 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
2654 /* If we didn't find any equivalence, we need to remember that
2655 this value is held in the named register. */
2656 if (found)
2657 return;
2659 /* ??? Attempt to find and merge equivalent MEMs or other
2660 expressions too. */
2662 val_bind (set, val, loc, false);
2665 /* Initialize dataflow set SET to be empty.
2666 VARS_SIZE is the initial size of hash table VARS. */
2668 static void
2669 dataflow_set_init (dataflow_set *set)
2671 init_attrs_list_set (set->regs);
2672 set->vars = shared_hash_copy (empty_shared_hash);
2673 set->stack_adjust = 0;
2674 set->traversed_vars = NULL;
2677 /* Delete the contents of dataflow set SET. */
2679 static void
2680 dataflow_set_clear (dataflow_set *set)
2682 int i;
2684 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2685 attrs_list_clear (&set->regs[i]);
2687 shared_hash_destroy (set->vars);
2688 set->vars = shared_hash_copy (empty_shared_hash);
2691 /* Copy the contents of dataflow set SRC to DST. */
2693 static void
2694 dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
2696 int i;
2698 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2699 attrs_list_copy (&dst->regs[i], src->regs[i]);
2701 shared_hash_destroy (dst->vars);
2702 dst->vars = shared_hash_copy (src->vars);
2703 dst->stack_adjust = src->stack_adjust;
2706 /* Information for merging lists of locations for a given offset of variable.
2708 struct variable_union_info
2710 /* Node of the location chain. */
2711 location_chain lc;
2713 /* The sum of positions in the input chains. */
2714 int pos;
2716 /* The position in the chain of DST dataflow set. */
2717 int pos_dst;
2720 /* Buffer for location list sorting and its allocated size. */
2721 static struct variable_union_info *vui_vec;
2722 static int vui_allocated;
2724 /* Compare function for qsort, order the structures by POS element. */
2726 static int
2727 variable_union_info_cmp_pos (const void *n1, const void *n2)
2729 const struct variable_union_info *const i1 =
2730 (const struct variable_union_info *) n1;
2731 const struct variable_union_info *const i2 =
2732 ( const struct variable_union_info *) n2;
2734 if (i1->pos != i2->pos)
2735 return i1->pos - i2->pos;
2737 return (i1->pos_dst - i2->pos_dst);
2740 /* Compute union of location parts of variable *SLOT and the same variable
2741 from hash table DATA. Compute "sorted" union of the location chains
2742 for common offsets, i.e. the locations of a variable part are sorted by
2743 a priority where the priority is the sum of the positions in the 2 chains
2744 (if a location is only in one list the position in the second list is
2745 defined to be larger than the length of the chains).
2746 When we are updating the location parts the newest location is in the
2747 beginning of the chain, so when we do the described "sorted" union
2748 we keep the newest locations in the beginning. */
2750 static int
2751 variable_union (variable src, dataflow_set *set)
2753 variable dst;
2754 variable_def **dstp;
2755 int i, j, k;
2757 dstp = shared_hash_find_slot (set->vars, src->dv);
2758 if (!dstp || !*dstp)
2760 src->refcount++;
2762 dst_can_be_shared = false;
2763 if (!dstp)
2764 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2766 *dstp = src;
2768 /* Continue traversing the hash table. */
2769 return 1;
2771 else
2772 dst = *dstp;
2774 gcc_assert (src->n_var_parts);
2775 gcc_checking_assert (src->onepart == dst->onepart);
2777 /* We can combine one-part variables very efficiently, because their
2778 entries are in canonical order. */
2779 if (src->onepart)
2781 location_chain *nodep, dnode, snode;
2783 gcc_assert (src->n_var_parts == 1
2784 && dst->n_var_parts == 1);
2786 snode = src->var_part[0].loc_chain;
2787 gcc_assert (snode);
2789 restart_onepart_unshared:
2790 nodep = &dst->var_part[0].loc_chain;
2791 dnode = *nodep;
2792 gcc_assert (dnode);
2794 while (snode)
2796 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2798 if (r > 0)
2800 location_chain nnode;
2802 if (shared_var_p (dst, set->vars))
2804 dstp = unshare_variable (set, dstp, dst,
2805 VAR_INIT_STATUS_INITIALIZED);
2806 dst = *dstp;
2807 goto restart_onepart_unshared;
2810 *nodep = nnode = (location_chain) pool_alloc (loc_chain_pool);
2811 nnode->loc = snode->loc;
2812 nnode->init = snode->init;
2813 if (!snode->set_src || MEM_P (snode->set_src))
2814 nnode->set_src = NULL;
2815 else
2816 nnode->set_src = snode->set_src;
2817 nnode->next = dnode;
2818 dnode = nnode;
2820 else if (r == 0)
2821 gcc_checking_assert (rtx_equal_p (dnode->loc, snode->loc));
2823 if (r >= 0)
2824 snode = snode->next;
2826 nodep = &dnode->next;
2827 dnode = *nodep;
2830 return 1;
2833 gcc_checking_assert (!src->onepart);
2835 /* Count the number of location parts, result is K. */
2836 for (i = 0, j = 0, k = 0;
2837 i < src->n_var_parts && j < dst->n_var_parts; k++)
2839 if (VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2841 i++;
2842 j++;
2844 else if (VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
2845 i++;
2846 else
2847 j++;
2849 k += src->n_var_parts - i;
2850 k += dst->n_var_parts - j;
2852 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2853 thus there are at most MAX_VAR_PARTS different offsets. */
2854 gcc_checking_assert (dst->onepart ? k == 1 : k <= MAX_VAR_PARTS);
2856 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2858 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2859 dst = *dstp;
2862 i = src->n_var_parts - 1;
2863 j = dst->n_var_parts - 1;
2864 dst->n_var_parts = k;
2866 for (k--; k >= 0; k--)
2868 location_chain node, node2;
2870 if (i >= 0 && j >= 0
2871 && VAR_PART_OFFSET (src, i) == VAR_PART_OFFSET (dst, j))
2873 /* Compute the "sorted" union of the chains, i.e. the locations which
2874 are in both chains go first, they are sorted by the sum of
2875 positions in the chains. */
2876 int dst_l, src_l;
2877 int ii, jj, n;
2878 struct variable_union_info *vui;
2880 /* If DST is shared compare the location chains.
2881 If they are different we will modify the chain in DST with
2882 high probability so make a copy of DST. */
2883 if (shared_var_p (dst, set->vars))
2885 for (node = src->var_part[i].loc_chain,
2886 node2 = dst->var_part[j].loc_chain; node && node2;
2887 node = node->next, node2 = node2->next)
2889 if (!((REG_P (node2->loc)
2890 && REG_P (node->loc)
2891 && REGNO (node2->loc) == REGNO (node->loc))
2892 || rtx_equal_p (node2->loc, node->loc)))
2894 if (node2->init < node->init)
2895 node2->init = node->init;
2896 break;
2899 if (node || node2)
2901 dstp = unshare_variable (set, dstp, dst,
2902 VAR_INIT_STATUS_UNKNOWN);
2903 dst = (variable)*dstp;
2907 src_l = 0;
2908 for (node = src->var_part[i].loc_chain; node; node = node->next)
2909 src_l++;
2910 dst_l = 0;
2911 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2912 dst_l++;
2914 if (dst_l == 1)
2916 /* The most common case, much simpler, no qsort is needed. */
2917 location_chain dstnode = dst->var_part[j].loc_chain;
2918 dst->var_part[k].loc_chain = dstnode;
2919 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
2920 node2 = dstnode;
2921 for (node = src->var_part[i].loc_chain; node; node = node->next)
2922 if (!((REG_P (dstnode->loc)
2923 && REG_P (node->loc)
2924 && REGNO (dstnode->loc) == REGNO (node->loc))
2925 || rtx_equal_p (dstnode->loc, node->loc)))
2927 location_chain new_node;
2929 /* Copy the location from SRC. */
2930 new_node = (location_chain) pool_alloc (loc_chain_pool);
2931 new_node->loc = node->loc;
2932 new_node->init = node->init;
2933 if (!node->set_src || MEM_P (node->set_src))
2934 new_node->set_src = NULL;
2935 else
2936 new_node->set_src = node->set_src;
2937 node2->next = new_node;
2938 node2 = new_node;
2940 node2->next = NULL;
2942 else
2944 if (src_l + dst_l > vui_allocated)
2946 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l);
2947 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,
2948 vui_allocated);
2950 vui = vui_vec;
2952 /* Fill in the locations from DST. */
2953 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2954 node = node->next, jj++)
2956 vui[jj].lc = node;
2957 vui[jj].pos_dst = jj;
2959 /* Pos plus value larger than a sum of 2 valid positions. */
2960 vui[jj].pos = jj + src_l + dst_l;
2963 /* Fill in the locations from SRC. */
2964 n = dst_l;
2965 for (node = src->var_part[i].loc_chain, ii = 0; node;
2966 node = node->next, ii++)
2968 /* Find location from NODE. */
2969 for (jj = 0; jj < dst_l; jj++)
2971 if ((REG_P (vui[jj].lc->loc)
2972 && REG_P (node->loc)
2973 && REGNO (vui[jj].lc->loc) == REGNO (node->loc))
2974 || rtx_equal_p (vui[jj].lc->loc, node->loc))
2976 vui[jj].pos = jj + ii;
2977 break;
2980 if (jj >= dst_l) /* The location has not been found. */
2982 location_chain new_node;
2984 /* Copy the location from SRC. */
2985 new_node = (location_chain) pool_alloc (loc_chain_pool);
2986 new_node->loc = node->loc;
2987 new_node->init = node->init;
2988 if (!node->set_src || MEM_P (node->set_src))
2989 new_node->set_src = NULL;
2990 else
2991 new_node->set_src = node->set_src;
2992 vui[n].lc = new_node;
2993 vui[n].pos_dst = src_l + dst_l;
2994 vui[n].pos = ii + src_l + dst_l;
2995 n++;
2999 if (dst_l == 2)
3001 /* Special case still very common case. For dst_l == 2
3002 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3003 vui[i].pos == i + src_l + dst_l. */
3004 if (vui[0].pos > vui[1].pos)
3006 /* Order should be 1, 0, 2... */
3007 dst->var_part[k].loc_chain = vui[1].lc;
3008 vui[1].lc->next = vui[0].lc;
3009 if (n >= 3)
3011 vui[0].lc->next = vui[2].lc;
3012 vui[n - 1].lc->next = NULL;
3014 else
3015 vui[0].lc->next = NULL;
3016 ii = 3;
3018 else
3020 dst->var_part[k].loc_chain = vui[0].lc;
3021 if (n >= 3 && vui[2].pos < vui[1].pos)
3023 /* Order should be 0, 2, 1, 3... */
3024 vui[0].lc->next = vui[2].lc;
3025 vui[2].lc->next = vui[1].lc;
3026 if (n >= 4)
3028 vui[1].lc->next = vui[3].lc;
3029 vui[n - 1].lc->next = NULL;
3031 else
3032 vui[1].lc->next = NULL;
3033 ii = 4;
3035 else
3037 /* Order should be 0, 1, 2... */
3038 ii = 1;
3039 vui[n - 1].lc->next = NULL;
3042 for (; ii < n; ii++)
3043 vui[ii - 1].lc->next = vui[ii].lc;
3045 else
3047 qsort (vui, n, sizeof (struct variable_union_info),
3048 variable_union_info_cmp_pos);
3050 /* Reconnect the nodes in sorted order. */
3051 for (ii = 1; ii < n; ii++)
3052 vui[ii - 1].lc->next = vui[ii].lc;
3053 vui[n - 1].lc->next = NULL;
3054 dst->var_part[k].loc_chain = vui[0].lc;
3057 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
3059 i--;
3060 j--;
3062 else if ((i >= 0 && j >= 0
3063 && VAR_PART_OFFSET (src, i) < VAR_PART_OFFSET (dst, j))
3064 || i < 0)
3066 dst->var_part[k] = dst->var_part[j];
3067 j--;
3069 else if ((i >= 0 && j >= 0
3070 && VAR_PART_OFFSET (src, i) > VAR_PART_OFFSET (dst, j))
3071 || j < 0)
3073 location_chain *nextp;
3075 /* Copy the chain from SRC. */
3076 nextp = &dst->var_part[k].loc_chain;
3077 for (node = src->var_part[i].loc_chain; node; node = node->next)
3079 location_chain new_lc;
3081 new_lc = (location_chain) pool_alloc (loc_chain_pool);
3082 new_lc->next = NULL;
3083 new_lc->init = node->init;
3084 if (!node->set_src || MEM_P (node->set_src))
3085 new_lc->set_src = NULL;
3086 else
3087 new_lc->set_src = node->set_src;
3088 new_lc->loc = node->loc;
3090 *nextp = new_lc;
3091 nextp = &new_lc->next;
3094 VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (src, i);
3095 i--;
3097 dst->var_part[k].cur_loc = NULL;
3100 if (flag_var_tracking_uninit)
3101 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
3103 location_chain node, node2;
3104 for (node = src->var_part[i].loc_chain; node; node = node->next)
3105 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
3106 if (rtx_equal_p (node->loc, node2->loc))
3108 if (node->init > node2->init)
3109 node2->init = node->init;
3113 /* Continue traversing the hash table. */
3114 return 1;
3117 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3119 static void
3120 dataflow_set_union (dataflow_set *dst, dataflow_set *src)
3122 int i;
3124 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3125 attrs_list_union (&dst->regs[i], src->regs[i]);
3127 if (dst->vars == empty_shared_hash)
3129 shared_hash_destroy (dst->vars);
3130 dst->vars = shared_hash_copy (src->vars);
3132 else
3134 variable_iterator_type hi;
3135 variable var;
3137 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars),
3138 var, variable, hi)
3139 variable_union (var, dst);
3143 /* Whether the value is currently being expanded. */
3144 #define VALUE_RECURSED_INTO(x) \
3145 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3147 /* Whether no expansion was found, saving useless lookups.
3148 It must only be set when VALUE_CHANGED is clear. */
3149 #define NO_LOC_P(x) \
3150 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3152 /* Whether cur_loc in the value needs to be (re)computed. */
3153 #define VALUE_CHANGED(x) \
3154 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3155 /* Whether cur_loc in the decl needs to be (re)computed. */
3156 #define DECL_CHANGED(x) TREE_VISITED (x)
3158 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3159 user DECLs, this means they're in changed_variables. Values and
3160 debug exprs may be left with this flag set if no user variable
3161 requires them to be evaluated. */
3163 static inline void
3164 set_dv_changed (decl_or_value dv, bool newv)
3166 switch (dv_onepart_p (dv))
3168 case ONEPART_VALUE:
3169 if (newv)
3170 NO_LOC_P (dv_as_value (dv)) = false;
3171 VALUE_CHANGED (dv_as_value (dv)) = newv;
3172 break;
3174 case ONEPART_DEXPR:
3175 if (newv)
3176 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv))) = false;
3177 /* Fall through... */
3179 default:
3180 DECL_CHANGED (dv_as_decl (dv)) = newv;
3181 break;
3185 /* Return true if DV needs to have its cur_loc recomputed. */
3187 static inline bool
3188 dv_changed_p (decl_or_value dv)
3190 return (dv_is_value_p (dv)
3191 ? VALUE_CHANGED (dv_as_value (dv))
3192 : DECL_CHANGED (dv_as_decl (dv)));
3195 /* Return a location list node whose loc is rtx_equal to LOC, in the
3196 location list of a one-part variable or value VAR, or in that of
3197 any values recursively mentioned in the location lists. VARS must
3198 be in star-canonical form. */
3200 static location_chain
3201 find_loc_in_1pdv (rtx loc, variable var, variable_table_type *vars)
3203 location_chain node;
3204 enum rtx_code loc_code;
3206 if (!var)
3207 return NULL;
3209 gcc_checking_assert (var->onepart);
3211 if (!var->n_var_parts)
3212 return NULL;
3214 gcc_checking_assert (loc != dv_as_opaque (var->dv));
3216 loc_code = GET_CODE (loc);
3217 for (node = var->var_part[0].loc_chain; node; node = node->next)
3219 decl_or_value dv;
3220 variable rvar;
3222 if (GET_CODE (node->loc) != loc_code)
3224 if (GET_CODE (node->loc) != VALUE)
3225 continue;
3227 else if (loc == node->loc)
3228 return node;
3229 else if (loc_code != VALUE)
3231 if (rtx_equal_p (loc, node->loc))
3232 return node;
3233 continue;
3236 /* Since we're in star-canonical form, we don't need to visit
3237 non-canonical nodes: one-part variables and non-canonical
3238 values would only point back to the canonical node. */
3239 if (dv_is_value_p (var->dv)
3240 && !canon_value_cmp (node->loc, dv_as_value (var->dv)))
3242 /* Skip all subsequent VALUEs. */
3243 while (node->next && GET_CODE (node->next->loc) == VALUE)
3245 node = node->next;
3246 gcc_checking_assert (!canon_value_cmp (node->loc,
3247 dv_as_value (var->dv)));
3248 if (loc == node->loc)
3249 return node;
3251 continue;
3254 gcc_checking_assert (node == var->var_part[0].loc_chain);
3255 gcc_checking_assert (!node->next);
3257 dv = dv_from_value (node->loc);
3258 rvar = vars->find_with_hash (dv, dv_htab_hash (dv));
3259 return find_loc_in_1pdv (loc, rvar, vars);
3262 /* ??? Gotta look in cselib_val locations too. */
3264 return NULL;
3267 /* Hash table iteration argument passed to variable_merge. */
3268 struct dfset_merge
3270 /* The set in which the merge is to be inserted. */
3271 dataflow_set *dst;
3272 /* The set that we're iterating in. */
3273 dataflow_set *cur;
3274 /* The set that may contain the other dv we are to merge with. */
3275 dataflow_set *src;
3276 /* Number of onepart dvs in src. */
3277 int src_onepart_cnt;
3280 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3281 loc_cmp order, and it is maintained as such. */
3283 static void
3284 insert_into_intersection (location_chain *nodep, rtx loc,
3285 enum var_init_status status)
3287 location_chain node;
3288 int r;
3290 for (node = *nodep; node; nodep = &node->next, node = *nodep)
3291 if ((r = loc_cmp (node->loc, loc)) == 0)
3293 node->init = MIN (node->init, status);
3294 return;
3296 else if (r > 0)
3297 break;
3299 node = (location_chain) pool_alloc (loc_chain_pool);
3301 node->loc = loc;
3302 node->set_src = NULL;
3303 node->init = status;
3304 node->next = *nodep;
3305 *nodep = node;
3308 /* Insert in DEST the intersection of the locations present in both
3309 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3310 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3311 DSM->dst. */
3313 static void
3314 intersect_loc_chains (rtx val, location_chain *dest, struct dfset_merge *dsm,
3315 location_chain s1node, variable s2var)
3317 dataflow_set *s1set = dsm->cur;
3318 dataflow_set *s2set = dsm->src;
3319 location_chain found;
3321 if (s2var)
3323 location_chain s2node;
3325 gcc_checking_assert (s2var->onepart);
3327 if (s2var->n_var_parts)
3329 s2node = s2var->var_part[0].loc_chain;
3331 for (; s1node && s2node;
3332 s1node = s1node->next, s2node = s2node->next)
3333 if (s1node->loc != s2node->loc)
3334 break;
3335 else if (s1node->loc == val)
3336 continue;
3337 else
3338 insert_into_intersection (dest, s1node->loc,
3339 MIN (s1node->init, s2node->init));
3343 for (; s1node; s1node = s1node->next)
3345 if (s1node->loc == val)
3346 continue;
3348 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
3349 shared_hash_htab (s2set->vars))))
3351 insert_into_intersection (dest, s1node->loc,
3352 MIN (s1node->init, found->init));
3353 continue;
3356 if (GET_CODE (s1node->loc) == VALUE
3357 && !VALUE_RECURSED_INTO (s1node->loc))
3359 decl_or_value dv = dv_from_value (s1node->loc);
3360 variable svar = shared_hash_find (s1set->vars, dv);
3361 if (svar)
3363 if (svar->n_var_parts == 1)
3365 VALUE_RECURSED_INTO (s1node->loc) = true;
3366 intersect_loc_chains (val, dest, dsm,
3367 svar->var_part[0].loc_chain,
3368 s2var);
3369 VALUE_RECURSED_INTO (s1node->loc) = false;
3374 /* ??? gotta look in cselib_val locations too. */
3376 /* ??? if the location is equivalent to any location in src,
3377 searched recursively
3379 add to dst the values needed to represent the equivalence
3381 telling whether locations S is equivalent to another dv's
3382 location list:
3384 for each location D in the list
3386 if S and D satisfy rtx_equal_p, then it is present
3388 else if D is a value, recurse without cycles
3390 else if S and D have the same CODE and MODE
3392 for each operand oS and the corresponding oD
3394 if oS and oD are not equivalent, then S an D are not equivalent
3396 else if they are RTX vectors
3398 if any vector oS element is not equivalent to its respective oD,
3399 then S and D are not equivalent
3407 /* Return -1 if X should be before Y in a location list for a 1-part
3408 variable, 1 if Y should be before X, and 0 if they're equivalent
3409 and should not appear in the list. */
3411 static int
3412 loc_cmp (rtx x, rtx y)
3414 int i, j, r;
3415 RTX_CODE code = GET_CODE (x);
3416 const char *fmt;
3418 if (x == y)
3419 return 0;
3421 if (REG_P (x))
3423 if (!REG_P (y))
3424 return -1;
3425 gcc_assert (GET_MODE (x) == GET_MODE (y));
3426 if (REGNO (x) == REGNO (y))
3427 return 0;
3428 else if (REGNO (x) < REGNO (y))
3429 return -1;
3430 else
3431 return 1;
3434 if (REG_P (y))
3435 return 1;
3437 if (MEM_P (x))
3439 if (!MEM_P (y))
3440 return -1;
3441 gcc_assert (GET_MODE (x) == GET_MODE (y));
3442 return loc_cmp (XEXP (x, 0), XEXP (y, 0));
3445 if (MEM_P (y))
3446 return 1;
3448 if (GET_CODE (x) == VALUE)
3450 if (GET_CODE (y) != VALUE)
3451 return -1;
3452 /* Don't assert the modes are the same, that is true only
3453 when not recursing. (subreg:QI (value:SI 1:1) 0)
3454 and (subreg:QI (value:DI 2:2) 0) can be compared,
3455 even when the modes are different. */
3456 if (canon_value_cmp (x, y))
3457 return -1;
3458 else
3459 return 1;
3462 if (GET_CODE (y) == VALUE)
3463 return 1;
3465 /* Entry value is the least preferable kind of expression. */
3466 if (GET_CODE (x) == ENTRY_VALUE)
3468 if (GET_CODE (y) != ENTRY_VALUE)
3469 return 1;
3470 gcc_assert (GET_MODE (x) == GET_MODE (y));
3471 return loc_cmp (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
3474 if (GET_CODE (y) == ENTRY_VALUE)
3475 return -1;
3477 if (GET_CODE (x) == GET_CODE (y))
3478 /* Compare operands below. */;
3479 else if (GET_CODE (x) < GET_CODE (y))
3480 return -1;
3481 else
3482 return 1;
3484 gcc_assert (GET_MODE (x) == GET_MODE (y));
3486 if (GET_CODE (x) == DEBUG_EXPR)
3488 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3489 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))
3490 return -1;
3491 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
3492 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)));
3493 return 1;
3496 fmt = GET_RTX_FORMAT (code);
3497 for (i = 0; i < GET_RTX_LENGTH (code); i++)
3498 switch (fmt[i])
3500 case 'w':
3501 if (XWINT (x, i) == XWINT (y, i))
3502 break;
3503 else if (XWINT (x, i) < XWINT (y, i))
3504 return -1;
3505 else
3506 return 1;
3508 case 'n':
3509 case 'i':
3510 if (XINT (x, i) == XINT (y, i))
3511 break;
3512 else if (XINT (x, i) < XINT (y, i))
3513 return -1;
3514 else
3515 return 1;
3517 case 'V':
3518 case 'E':
3519 /* Compare the vector length first. */
3520 if (XVECLEN (x, i) == XVECLEN (y, i))
3521 /* Compare the vectors elements. */;
3522 else if (XVECLEN (x, i) < XVECLEN (y, i))
3523 return -1;
3524 else
3525 return 1;
3527 for (j = 0; j < XVECLEN (x, i); j++)
3528 if ((r = loc_cmp (XVECEXP (x, i, j),
3529 XVECEXP (y, i, j))))
3530 return r;
3531 break;
3533 case 'e':
3534 if ((r = loc_cmp (XEXP (x, i), XEXP (y, i))))
3535 return r;
3536 break;
3538 case 'S':
3539 case 's':
3540 if (XSTR (x, i) == XSTR (y, i))
3541 break;
3542 if (!XSTR (x, i))
3543 return -1;
3544 if (!XSTR (y, i))
3545 return 1;
3546 if ((r = strcmp (XSTR (x, i), XSTR (y, i))) == 0)
3547 break;
3548 else if (r < 0)
3549 return -1;
3550 else
3551 return 1;
3553 case 'u':
3554 /* These are just backpointers, so they don't matter. */
3555 break;
3557 case '0':
3558 case 't':
3559 break;
3561 /* It is believed that rtx's at this level will never
3562 contain anything but integers and other rtx's,
3563 except for within LABEL_REFs and SYMBOL_REFs. */
3564 default:
3565 gcc_unreachable ();
3567 if (CONST_WIDE_INT_P (x))
3569 /* Compare the vector length first. */
3570 if (CONST_WIDE_INT_NUNITS (x) >= CONST_WIDE_INT_NUNITS (y))
3571 return 1;
3572 else if (CONST_WIDE_INT_NUNITS (x) < CONST_WIDE_INT_NUNITS (y))
3573 return -1;
3575 /* Compare the vectors elements. */;
3576 for (j = CONST_WIDE_INT_NUNITS (x) - 1; j >= 0 ; j--)
3578 if (CONST_WIDE_INT_ELT (x, j) < CONST_WIDE_INT_ELT (y, j))
3579 return -1;
3580 if (CONST_WIDE_INT_ELT (x, j) > CONST_WIDE_INT_ELT (y, j))
3581 return 1;
3585 return 0;
3588 #if ENABLE_CHECKING
3589 /* Check the order of entries in one-part variables. */
3592 canonicalize_loc_order_check (variable_def **slot,
3593 dataflow_set *data ATTRIBUTE_UNUSED)
3595 variable var = *slot;
3596 location_chain node, next;
3598 #ifdef ENABLE_RTL_CHECKING
3599 int i;
3600 for (i = 0; i < var->n_var_parts; i++)
3601 gcc_assert (var->var_part[0].cur_loc == NULL);
3602 gcc_assert (!var->in_changed_variables);
3603 #endif
3605 if (!var->onepart)
3606 return 1;
3608 gcc_assert (var->n_var_parts == 1);
3609 node = var->var_part[0].loc_chain;
3610 gcc_assert (node);
3612 while ((next = node->next))
3614 gcc_assert (loc_cmp (node->loc, next->loc) < 0);
3615 node = next;
3618 return 1;
3620 #endif
3622 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3623 more likely to be chosen as canonical for an equivalence set.
3624 Ensure less likely values can reach more likely neighbors, making
3625 the connections bidirectional. */
3628 canonicalize_values_mark (variable_def **slot, dataflow_set *set)
3630 variable var = *slot;
3631 decl_or_value dv = var->dv;
3632 rtx val;
3633 location_chain node;
3635 if (!dv_is_value_p (dv))
3636 return 1;
3638 gcc_checking_assert (var->n_var_parts == 1);
3640 val = dv_as_value (dv);
3642 for (node = var->var_part[0].loc_chain; node; node = node->next)
3643 if (GET_CODE (node->loc) == VALUE)
3645 if (canon_value_cmp (node->loc, val))
3646 VALUE_RECURSED_INTO (val) = true;
3647 else
3649 decl_or_value odv = dv_from_value (node->loc);
3650 variable_def **oslot;
3651 oslot = shared_hash_find_slot_noinsert (set->vars, odv);
3653 set_slot_part (set, val, oslot, odv, 0,
3654 node->init, NULL_RTX);
3656 VALUE_RECURSED_INTO (node->loc) = true;
3660 return 1;
3663 /* Remove redundant entries from equivalence lists in onepart
3664 variables, canonicalizing equivalence sets into star shapes. */
3667 canonicalize_values_star (variable_def **slot, dataflow_set *set)
3669 variable var = *slot;
3670 decl_or_value dv = var->dv;
3671 location_chain node;
3672 decl_or_value cdv;
3673 rtx val, cval;
3674 variable_def **cslot;
3675 bool has_value;
3676 bool has_marks;
3678 if (!var->onepart)
3679 return 1;
3681 gcc_checking_assert (var->n_var_parts == 1);
3683 if (dv_is_value_p (dv))
3685 cval = dv_as_value (dv);
3686 if (!VALUE_RECURSED_INTO (cval))
3687 return 1;
3688 VALUE_RECURSED_INTO (cval) = false;
3690 else
3691 cval = NULL_RTX;
3693 restart:
3694 val = cval;
3695 has_value = false;
3696 has_marks = false;
3698 gcc_assert (var->n_var_parts == 1);
3700 for (node = var->var_part[0].loc_chain; node; node = node->next)
3701 if (GET_CODE (node->loc) == VALUE)
3703 has_value = true;
3704 if (VALUE_RECURSED_INTO (node->loc))
3705 has_marks = true;
3706 if (canon_value_cmp (node->loc, cval))
3707 cval = node->loc;
3710 if (!has_value)
3711 return 1;
3713 if (cval == val)
3715 if (!has_marks || dv_is_decl_p (dv))
3716 return 1;
3718 /* Keep it marked so that we revisit it, either after visiting a
3719 child node, or after visiting a new parent that might be
3720 found out. */
3721 VALUE_RECURSED_INTO (val) = true;
3723 for (node = var->var_part[0].loc_chain; node; node = node->next)
3724 if (GET_CODE (node->loc) == VALUE
3725 && VALUE_RECURSED_INTO (node->loc))
3727 cval = node->loc;
3728 restart_with_cval:
3729 VALUE_RECURSED_INTO (cval) = false;
3730 dv = dv_from_value (cval);
3731 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3732 if (!slot)
3734 gcc_assert (dv_is_decl_p (var->dv));
3735 /* The canonical value was reset and dropped.
3736 Remove it. */
3737 clobber_variable_part (set, NULL, var->dv, 0, NULL);
3738 return 1;
3740 var = *slot;
3741 gcc_assert (dv_is_value_p (var->dv));
3742 if (var->n_var_parts == 0)
3743 return 1;
3744 gcc_assert (var->n_var_parts == 1);
3745 goto restart;
3748 VALUE_RECURSED_INTO (val) = false;
3750 return 1;
3753 /* Push values to the canonical one. */
3754 cdv = dv_from_value (cval);
3755 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3757 for (node = var->var_part[0].loc_chain; node; node = node->next)
3758 if (node->loc != cval)
3760 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3761 node->init, NULL_RTX);
3762 if (GET_CODE (node->loc) == VALUE)
3764 decl_or_value ndv = dv_from_value (node->loc);
3766 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX,
3767 NO_INSERT);
3769 if (canon_value_cmp (node->loc, val))
3771 /* If it could have been a local minimum, it's not any more,
3772 since it's now neighbor to cval, so it may have to push
3773 to it. Conversely, if it wouldn't have prevailed over
3774 val, then whatever mark it has is fine: if it was to
3775 push, it will now push to a more canonical node, but if
3776 it wasn't, then it has already pushed any values it might
3777 have to. */
3778 VALUE_RECURSED_INTO (node->loc) = true;
3779 /* Make sure we visit node->loc by ensuring we cval is
3780 visited too. */
3781 VALUE_RECURSED_INTO (cval) = true;
3783 else if (!VALUE_RECURSED_INTO (node->loc))
3784 /* If we have no need to "recurse" into this node, it's
3785 already "canonicalized", so drop the link to the old
3786 parent. */
3787 clobber_variable_part (set, cval, ndv, 0, NULL);
3789 else if (GET_CODE (node->loc) == REG)
3791 attrs list = set->regs[REGNO (node->loc)], *listp;
3793 /* Change an existing attribute referring to dv so that it
3794 refers to cdv, removing any duplicate this might
3795 introduce, and checking that no previous duplicates
3796 existed, all in a single pass. */
3798 while (list)
3800 if (list->offset == 0
3801 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3802 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3803 break;
3805 list = list->next;
3808 gcc_assert (list);
3809 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3811 list->dv = cdv;
3812 for (listp = &list->next; (list = *listp); listp = &list->next)
3814 if (list->offset)
3815 continue;
3817 if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3819 *listp = list->next;
3820 pool_free (attrs_pool, list);
3821 list = *listp;
3822 break;
3825 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (dv));
3828 else if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3830 for (listp = &list->next; (list = *listp); listp = &list->next)
3832 if (list->offset)
3833 continue;
3835 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3837 *listp = list->next;
3838 pool_free (attrs_pool, list);
3839 list = *listp;
3840 break;
3843 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (cdv));
3846 else
3847 gcc_unreachable ();
3849 #if ENABLE_CHECKING
3850 while (list)
3852 if (list->offset == 0
3853 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3854 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3855 gcc_unreachable ();
3857 list = list->next;
3859 #endif
3863 if (val)
3864 set_slot_part (set, val, cslot, cdv, 0,
3865 VAR_INIT_STATUS_INITIALIZED, NULL_RTX);
3867 slot = clobber_slot_part (set, cval, slot, 0, NULL);
3869 /* Variable may have been unshared. */
3870 var = *slot;
3871 gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
3872 && var->var_part[0].loc_chain->next == NULL);
3874 if (VALUE_RECURSED_INTO (cval))
3875 goto restart_with_cval;
3877 return 1;
3880 /* Bind one-part variables to the canonical value in an equivalence
3881 set. Not doing this causes dataflow convergence failure in rare
3882 circumstances, see PR42873. Unfortunately we can't do this
3883 efficiently as part of canonicalize_values_star, since we may not
3884 have determined or even seen the canonical value of a set when we
3885 get to a variable that references another member of the set. */
3888 canonicalize_vars_star (variable_def **slot, dataflow_set *set)
3890 variable var = *slot;
3891 decl_or_value dv = var->dv;
3892 location_chain node;
3893 rtx cval;
3894 decl_or_value cdv;
3895 variable_def **cslot;
3896 variable cvar;
3897 location_chain cnode;
3899 if (!var->onepart || var->onepart == ONEPART_VALUE)
3900 return 1;
3902 gcc_assert (var->n_var_parts == 1);
3904 node = var->var_part[0].loc_chain;
3906 if (GET_CODE (node->loc) != VALUE)
3907 return 1;
3909 gcc_assert (!node->next);
3910 cval = node->loc;
3912 /* Push values to the canonical one. */
3913 cdv = dv_from_value (cval);
3914 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3915 if (!cslot)
3916 return 1;
3917 cvar = *cslot;
3918 gcc_assert (cvar->n_var_parts == 1);
3920 cnode = cvar->var_part[0].loc_chain;
3922 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3923 that are not “more canonical” than it. */
3924 if (GET_CODE (cnode->loc) != VALUE
3925 || !canon_value_cmp (cnode->loc, cval))
3926 return 1;
3928 /* CVAL was found to be non-canonical. Change the variable to point
3929 to the canonical VALUE. */
3930 gcc_assert (!cnode->next);
3931 cval = cnode->loc;
3933 slot = set_slot_part (set, cval, slot, dv, 0,
3934 node->init, node->set_src);
3935 clobber_slot_part (set, cval, slot, 0, node->set_src);
3937 return 1;
3940 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3941 corresponding entry in DSM->src. Multi-part variables are combined
3942 with variable_union, whereas onepart dvs are combined with
3943 intersection. */
3945 static int
3946 variable_merge_over_cur (variable s1var, struct dfset_merge *dsm)
3948 dataflow_set *dst = dsm->dst;
3949 variable_def **dstslot;
3950 variable s2var, dvar = NULL;
3951 decl_or_value dv = s1var->dv;
3952 onepart_enum_t onepart = s1var->onepart;
3953 rtx val;
3954 hashval_t dvhash;
3955 location_chain node, *nodep;
3957 /* If the incoming onepart variable has an empty location list, then
3958 the intersection will be just as empty. For other variables,
3959 it's always union. */
3960 gcc_checking_assert (s1var->n_var_parts
3961 && s1var->var_part[0].loc_chain);
3963 if (!onepart)
3964 return variable_union (s1var, dst);
3966 gcc_checking_assert (s1var->n_var_parts == 1);
3968 dvhash = dv_htab_hash (dv);
3969 if (dv_is_value_p (dv))
3970 val = dv_as_value (dv);
3971 else
3972 val = NULL;
3974 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
3975 if (!s2var)
3977 dst_can_be_shared = false;
3978 return 1;
3981 dsm->src_onepart_cnt--;
3982 gcc_assert (s2var->var_part[0].loc_chain
3983 && s2var->onepart == onepart
3984 && s2var->n_var_parts == 1);
3986 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3987 if (dstslot)
3989 dvar = *dstslot;
3990 gcc_assert (dvar->refcount == 1
3991 && dvar->onepart == onepart
3992 && dvar->n_var_parts == 1);
3993 nodep = &dvar->var_part[0].loc_chain;
3995 else
3997 nodep = &node;
3998 node = NULL;
4001 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
4003 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
4004 dvhash, INSERT);
4005 *dstslot = dvar = s2var;
4006 dvar->refcount++;
4008 else
4010 dst_can_be_shared = false;
4012 intersect_loc_chains (val, nodep, dsm,
4013 s1var->var_part[0].loc_chain, s2var);
4015 if (!dstslot)
4017 if (node)
4019 dvar = (variable) pool_alloc (onepart_pool (onepart));
4020 dvar->dv = dv;
4021 dvar->refcount = 1;
4022 dvar->n_var_parts = 1;
4023 dvar->onepart = onepart;
4024 dvar->in_changed_variables = false;
4025 dvar->var_part[0].loc_chain = node;
4026 dvar->var_part[0].cur_loc = NULL;
4027 if (onepart)
4028 VAR_LOC_1PAUX (dvar) = NULL;
4029 else
4030 VAR_PART_OFFSET (dvar, 0) = 0;
4032 dstslot
4033 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
4034 INSERT);
4035 gcc_assert (!*dstslot);
4036 *dstslot = dvar;
4038 else
4039 return 1;
4043 nodep = &dvar->var_part[0].loc_chain;
4044 while ((node = *nodep))
4046 location_chain *nextp = &node->next;
4048 if (GET_CODE (node->loc) == REG)
4050 attrs list;
4052 for (list = dst->regs[REGNO (node->loc)]; list; list = list->next)
4053 if (GET_MODE (node->loc) == GET_MODE (list->loc)
4054 && dv_is_value_p (list->dv))
4055 break;
4057 if (!list)
4058 attrs_list_insert (&dst->regs[REGNO (node->loc)],
4059 dv, 0, node->loc);
4060 /* If this value became canonical for another value that had
4061 this register, we want to leave it alone. */
4062 else if (dv_as_value (list->dv) != val)
4064 dstslot = set_slot_part (dst, dv_as_value (list->dv),
4065 dstslot, dv, 0,
4066 node->init, NULL_RTX);
4067 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
4069 /* Since nextp points into the removed node, we can't
4070 use it. The pointer to the next node moved to nodep.
4071 However, if the variable we're walking is unshared
4072 during our walk, we'll keep walking the location list
4073 of the previously-shared variable, in which case the
4074 node won't have been removed, and we'll want to skip
4075 it. That's why we test *nodep here. */
4076 if (*nodep != node)
4077 nextp = nodep;
4080 else
4081 /* Canonicalization puts registers first, so we don't have to
4082 walk it all. */
4083 break;
4084 nodep = nextp;
4087 if (dvar != *dstslot)
4088 dvar = *dstslot;
4089 nodep = &dvar->var_part[0].loc_chain;
4091 if (val)
4093 /* Mark all referenced nodes for canonicalization, and make sure
4094 we have mutual equivalence links. */
4095 VALUE_RECURSED_INTO (val) = true;
4096 for (node = *nodep; node; node = node->next)
4097 if (GET_CODE (node->loc) == VALUE)
4099 VALUE_RECURSED_INTO (node->loc) = true;
4100 set_variable_part (dst, val, dv_from_value (node->loc), 0,
4101 node->init, NULL, INSERT);
4104 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4105 gcc_assert (*dstslot == dvar);
4106 canonicalize_values_star (dstslot, dst);
4107 gcc_checking_assert (dstslot
4108 == shared_hash_find_slot_noinsert_1 (dst->vars,
4109 dv, dvhash));
4110 dvar = *dstslot;
4112 else
4114 bool has_value = false, has_other = false;
4116 /* If we have one value and anything else, we're going to
4117 canonicalize this, so make sure all values have an entry in
4118 the table and are marked for canonicalization. */
4119 for (node = *nodep; node; node = node->next)
4121 if (GET_CODE (node->loc) == VALUE)
4123 /* If this was marked during register canonicalization,
4124 we know we have to canonicalize values. */
4125 if (has_value)
4126 has_other = true;
4127 has_value = true;
4128 if (has_other)
4129 break;
4131 else
4133 has_other = true;
4134 if (has_value)
4135 break;
4139 if (has_value && has_other)
4141 for (node = *nodep; node; node = node->next)
4143 if (GET_CODE (node->loc) == VALUE)
4145 decl_or_value dv = dv_from_value (node->loc);
4146 variable_def **slot = NULL;
4148 if (shared_hash_shared (dst->vars))
4149 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
4150 if (!slot)
4151 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
4152 INSERT);
4153 if (!*slot)
4155 variable var = (variable) pool_alloc (onepart_pool
4156 (ONEPART_VALUE));
4157 var->dv = dv;
4158 var->refcount = 1;
4159 var->n_var_parts = 1;
4160 var->onepart = ONEPART_VALUE;
4161 var->in_changed_variables = false;
4162 var->var_part[0].loc_chain = NULL;
4163 var->var_part[0].cur_loc = NULL;
4164 VAR_LOC_1PAUX (var) = NULL;
4165 *slot = var;
4168 VALUE_RECURSED_INTO (node->loc) = true;
4172 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4173 gcc_assert (*dstslot == dvar);
4174 canonicalize_values_star (dstslot, dst);
4175 gcc_checking_assert (dstslot
4176 == shared_hash_find_slot_noinsert_1 (dst->vars,
4177 dv, dvhash));
4178 dvar = *dstslot;
4182 if (!onepart_variable_different_p (dvar, s2var))
4184 variable_htab_free (dvar);
4185 *dstslot = dvar = s2var;
4186 dvar->refcount++;
4188 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
4190 variable_htab_free (dvar);
4191 *dstslot = dvar = s1var;
4192 dvar->refcount++;
4193 dst_can_be_shared = false;
4195 else
4196 dst_can_be_shared = false;
4198 return 1;
4201 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4202 multi-part variable. Unions of multi-part variables and
4203 intersections of one-part ones will be handled in
4204 variable_merge_over_cur(). */
4206 static int
4207 variable_merge_over_src (variable s2var, struct dfset_merge *dsm)
4209 dataflow_set *dst = dsm->dst;
4210 decl_or_value dv = s2var->dv;
4212 if (!s2var->onepart)
4214 variable_def **dstp = shared_hash_find_slot (dst->vars, dv);
4215 *dstp = s2var;
4216 s2var->refcount++;
4217 return 1;
4220 dsm->src_onepart_cnt++;
4221 return 1;
4224 /* Combine dataflow set information from SRC2 into DST, using PDST
4225 to carry over information across passes. */
4227 static void
4228 dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
4230 dataflow_set cur = *dst;
4231 dataflow_set *src1 = &cur;
4232 struct dfset_merge dsm;
4233 int i;
4234 size_t src1_elems, src2_elems;
4235 variable_iterator_type hi;
4236 variable var;
4238 src1_elems = shared_hash_htab (src1->vars)->elements ();
4239 src2_elems = shared_hash_htab (src2->vars)->elements ();
4240 dataflow_set_init (dst);
4241 dst->stack_adjust = cur.stack_adjust;
4242 shared_hash_destroy (dst->vars);
4243 dst->vars = (shared_hash) pool_alloc (shared_hash_pool);
4244 dst->vars->refcount = 1;
4245 dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems));
4247 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4248 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
4250 dsm.dst = dst;
4251 dsm.src = src2;
4252 dsm.cur = src1;
4253 dsm.src_onepart_cnt = 0;
4255 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars),
4256 var, variable, hi)
4257 variable_merge_over_src (var, &dsm);
4258 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars),
4259 var, variable, hi)
4260 variable_merge_over_cur (var, &dsm);
4262 if (dsm.src_onepart_cnt)
4263 dst_can_be_shared = false;
4265 dataflow_set_destroy (src1);
4268 /* Mark register equivalences. */
4270 static void
4271 dataflow_set_equiv_regs (dataflow_set *set)
4273 int i;
4274 attrs list, *listp;
4276 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4278 rtx canon[NUM_MACHINE_MODES];
4280 /* If the list is empty or one entry, no need to canonicalize
4281 anything. */
4282 if (set->regs[i] == NULL || set->regs[i]->next == NULL)
4283 continue;
4285 memset (canon, 0, sizeof (canon));
4287 for (list = set->regs[i]; list; list = list->next)
4288 if (list->offset == 0 && dv_is_value_p (list->dv))
4290 rtx val = dv_as_value (list->dv);
4291 rtx *cvalp = &canon[(int)GET_MODE (val)];
4292 rtx cval = *cvalp;
4294 if (canon_value_cmp (val, cval))
4295 *cvalp = val;
4298 for (list = set->regs[i]; list; list = list->next)
4299 if (list->offset == 0 && dv_onepart_p (list->dv))
4301 rtx cval = canon[(int)GET_MODE (list->loc)];
4303 if (!cval)
4304 continue;
4306 if (dv_is_value_p (list->dv))
4308 rtx val = dv_as_value (list->dv);
4310 if (val == cval)
4311 continue;
4313 VALUE_RECURSED_INTO (val) = true;
4314 set_variable_part (set, val, dv_from_value (cval), 0,
4315 VAR_INIT_STATUS_INITIALIZED,
4316 NULL, NO_INSERT);
4319 VALUE_RECURSED_INTO (cval) = true;
4320 set_variable_part (set, cval, list->dv, 0,
4321 VAR_INIT_STATUS_INITIALIZED, NULL, NO_INSERT);
4324 for (listp = &set->regs[i]; (list = *listp);
4325 listp = list ? &list->next : listp)
4326 if (list->offset == 0 && dv_onepart_p (list->dv))
4328 rtx cval = canon[(int)GET_MODE (list->loc)];
4329 variable_def **slot;
4331 if (!cval)
4332 continue;
4334 if (dv_is_value_p (list->dv))
4336 rtx val = dv_as_value (list->dv);
4337 if (!VALUE_RECURSED_INTO (val))
4338 continue;
4341 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
4342 canonicalize_values_star (slot, set);
4343 if (*listp != list)
4344 list = NULL;
4349 /* Remove any redundant values in the location list of VAR, which must
4350 be unshared and 1-part. */
4352 static void
4353 remove_duplicate_values (variable var)
4355 location_chain node, *nodep;
4357 gcc_assert (var->onepart);
4358 gcc_assert (var->n_var_parts == 1);
4359 gcc_assert (var->refcount == 1);
4361 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
4363 if (GET_CODE (node->loc) == VALUE)
4365 if (VALUE_RECURSED_INTO (node->loc))
4367 /* Remove duplicate value node. */
4368 *nodep = node->next;
4369 pool_free (loc_chain_pool, node);
4370 continue;
4372 else
4373 VALUE_RECURSED_INTO (node->loc) = true;
4375 nodep = &node->next;
4378 for (node = var->var_part[0].loc_chain; node; node = node->next)
4379 if (GET_CODE (node->loc) == VALUE)
4381 gcc_assert (VALUE_RECURSED_INTO (node->loc));
4382 VALUE_RECURSED_INTO (node->loc) = false;
4387 /* Hash table iteration argument passed to variable_post_merge. */
4388 struct dfset_post_merge
4390 /* The new input set for the current block. */
4391 dataflow_set *set;
4392 /* Pointer to the permanent input set for the current block, or
4393 NULL. */
4394 dataflow_set **permp;
4397 /* Create values for incoming expressions associated with one-part
4398 variables that don't have value numbers for them. */
4401 variable_post_merge_new_vals (variable_def **slot, dfset_post_merge *dfpm)
4403 dataflow_set *set = dfpm->set;
4404 variable var = *slot;
4405 location_chain node;
4407 if (!var->onepart || !var->n_var_parts)
4408 return 1;
4410 gcc_assert (var->n_var_parts == 1);
4412 if (dv_is_decl_p (var->dv))
4414 bool check_dupes = false;
4416 restart:
4417 for (node = var->var_part[0].loc_chain; node; node = node->next)
4419 if (GET_CODE (node->loc) == VALUE)
4420 gcc_assert (!VALUE_RECURSED_INTO (node->loc));
4421 else if (GET_CODE (node->loc) == REG)
4423 attrs att, *attp, *curp = NULL;
4425 if (var->refcount != 1)
4427 slot = unshare_variable (set, slot, var,
4428 VAR_INIT_STATUS_INITIALIZED);
4429 var = *slot;
4430 goto restart;
4433 for (attp = &set->regs[REGNO (node->loc)]; (att = *attp);
4434 attp = &att->next)
4435 if (att->offset == 0
4436 && GET_MODE (att->loc) == GET_MODE (node->loc))
4438 if (dv_is_value_p (att->dv))
4440 rtx cval = dv_as_value (att->dv);
4441 node->loc = cval;
4442 check_dupes = true;
4443 break;
4445 else if (dv_as_opaque (att->dv) == dv_as_opaque (var->dv))
4446 curp = attp;
4449 if (!curp)
4451 curp = attp;
4452 while (*curp)
4453 if ((*curp)->offset == 0
4454 && GET_MODE ((*curp)->loc) == GET_MODE (node->loc)
4455 && dv_as_opaque ((*curp)->dv) == dv_as_opaque (var->dv))
4456 break;
4457 else
4458 curp = &(*curp)->next;
4459 gcc_assert (*curp);
4462 if (!att)
4464 decl_or_value cdv;
4465 rtx cval;
4467 if (!*dfpm->permp)
4469 *dfpm->permp = XNEW (dataflow_set);
4470 dataflow_set_init (*dfpm->permp);
4473 for (att = (*dfpm->permp)->regs[REGNO (node->loc)];
4474 att; att = att->next)
4475 if (GET_MODE (att->loc) == GET_MODE (node->loc))
4477 gcc_assert (att->offset == 0
4478 && dv_is_value_p (att->dv));
4479 val_reset (set, att->dv);
4480 break;
4483 if (att)
4485 cdv = att->dv;
4486 cval = dv_as_value (cdv);
4488 else
4490 /* Create a unique value to hold this register,
4491 that ought to be found and reused in
4492 subsequent rounds. */
4493 cselib_val *v;
4494 gcc_assert (!cselib_lookup (node->loc,
4495 GET_MODE (node->loc), 0,
4496 VOIDmode));
4497 v = cselib_lookup (node->loc, GET_MODE (node->loc), 1,
4498 VOIDmode);
4499 cselib_preserve_value (v);
4500 cselib_invalidate_rtx (node->loc);
4501 cval = v->val_rtx;
4502 cdv = dv_from_value (cval);
4503 if (dump_file)
4504 fprintf (dump_file,
4505 "Created new value %u:%u for reg %i\n",
4506 v->uid, v->hash, REGNO (node->loc));
4509 var_reg_decl_set (*dfpm->permp, node->loc,
4510 VAR_INIT_STATUS_INITIALIZED,
4511 cdv, 0, NULL, INSERT);
4513 node->loc = cval;
4514 check_dupes = true;
4517 /* Remove attribute referring to the decl, which now
4518 uses the value for the register, already existing or
4519 to be added when we bring perm in. */
4520 att = *curp;
4521 *curp = att->next;
4522 pool_free (attrs_pool, att);
4526 if (check_dupes)
4527 remove_duplicate_values (var);
4530 return 1;
4533 /* Reset values in the permanent set that are not associated with the
4534 chosen expression. */
4537 variable_post_merge_perm_vals (variable_def **pslot, dfset_post_merge *dfpm)
4539 dataflow_set *set = dfpm->set;
4540 variable pvar = *pslot, var;
4541 location_chain pnode;
4542 decl_or_value dv;
4543 attrs att;
4545 gcc_assert (dv_is_value_p (pvar->dv)
4546 && pvar->n_var_parts == 1);
4547 pnode = pvar->var_part[0].loc_chain;
4548 gcc_assert (pnode
4549 && !pnode->next
4550 && REG_P (pnode->loc));
4552 dv = pvar->dv;
4554 var = shared_hash_find (set->vars, dv);
4555 if (var)
4557 /* Although variable_post_merge_new_vals may have made decls
4558 non-star-canonical, values that pre-existed in canonical form
4559 remain canonical, and newly-created values reference a single
4560 REG, so they are canonical as well. Since VAR has the
4561 location list for a VALUE, using find_loc_in_1pdv for it is
4562 fine, since VALUEs don't map back to DECLs. */
4563 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
4564 return 1;
4565 val_reset (set, dv);
4568 for (att = set->regs[REGNO (pnode->loc)]; att; att = att->next)
4569 if (att->offset == 0
4570 && GET_MODE (att->loc) == GET_MODE (pnode->loc)
4571 && dv_is_value_p (att->dv))
4572 break;
4574 /* If there is a value associated with this register already, create
4575 an equivalence. */
4576 if (att && dv_as_value (att->dv) != dv_as_value (dv))
4578 rtx cval = dv_as_value (att->dv);
4579 set_variable_part (set, cval, dv, 0, pnode->init, NULL, INSERT);
4580 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
4581 NULL, INSERT);
4583 else if (!att)
4585 attrs_list_insert (&set->regs[REGNO (pnode->loc)],
4586 dv, 0, pnode->loc);
4587 variable_union (pvar, set);
4590 return 1;
4593 /* Just checking stuff and registering register attributes for
4594 now. */
4596 static void
4597 dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
4599 struct dfset_post_merge dfpm;
4601 dfpm.set = set;
4602 dfpm.permp = permp;
4604 shared_hash_htab (set->vars)
4605 ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm);
4606 if (*permp)
4607 shared_hash_htab ((*permp)->vars)
4608 ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm);
4609 shared_hash_htab (set->vars)
4610 ->traverse <dataflow_set *, canonicalize_values_star> (set);
4611 shared_hash_htab (set->vars)
4612 ->traverse <dataflow_set *, canonicalize_vars_star> (set);
4615 /* Return a node whose loc is a MEM that refers to EXPR in the
4616 location list of a one-part variable or value VAR, or in that of
4617 any values recursively mentioned in the location lists. */
4619 static location_chain
4620 find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars)
4622 location_chain node;
4623 decl_or_value dv;
4624 variable var;
4625 location_chain where = NULL;
4627 if (!val)
4628 return NULL;
4630 gcc_assert (GET_CODE (val) == VALUE
4631 && !VALUE_RECURSED_INTO (val));
4633 dv = dv_from_value (val);
4634 var = vars->find_with_hash (dv, dv_htab_hash (dv));
4636 if (!var)
4637 return NULL;
4639 gcc_assert (var->onepart);
4641 if (!var->n_var_parts)
4642 return NULL;
4644 VALUE_RECURSED_INTO (val) = true;
4646 for (node = var->var_part[0].loc_chain; node; node = node->next)
4647 if (MEM_P (node->loc)
4648 && MEM_EXPR (node->loc) == expr
4649 && INT_MEM_OFFSET (node->loc) == 0)
4651 where = node;
4652 break;
4654 else if (GET_CODE (node->loc) == VALUE
4655 && !VALUE_RECURSED_INTO (node->loc)
4656 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
4657 break;
4659 VALUE_RECURSED_INTO (val) = false;
4661 return where;
4664 /* Return TRUE if the value of MEM may vary across a call. */
4666 static bool
4667 mem_dies_at_call (rtx mem)
4669 tree expr = MEM_EXPR (mem);
4670 tree decl;
4672 if (!expr)
4673 return true;
4675 decl = get_base_address (expr);
4677 if (!decl)
4678 return true;
4680 if (!DECL_P (decl))
4681 return true;
4683 return (may_be_aliased (decl)
4684 || (!TREE_READONLY (decl) && is_global_var (decl)));
4687 /* Remove all MEMs from the location list of a hash table entry for a
4688 one-part variable, except those whose MEM attributes map back to
4689 the variable itself, directly or within a VALUE. */
4692 dataflow_set_preserve_mem_locs (variable_def **slot, dataflow_set *set)
4694 variable var = *slot;
4696 if (var->onepart == ONEPART_VDECL || var->onepart == ONEPART_DEXPR)
4698 tree decl = dv_as_decl (var->dv);
4699 location_chain loc, *locp;
4700 bool changed = false;
4702 if (!var->n_var_parts)
4703 return 1;
4705 gcc_assert (var->n_var_parts == 1);
4707 if (shared_var_p (var, set->vars))
4709 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4711 /* We want to remove dying MEMs that doesn't refer to DECL. */
4712 if (GET_CODE (loc->loc) == MEM
4713 && (MEM_EXPR (loc->loc) != decl
4714 || INT_MEM_OFFSET (loc->loc) != 0)
4715 && !mem_dies_at_call (loc->loc))
4716 break;
4717 /* We want to move here MEMs that do refer to DECL. */
4718 else if (GET_CODE (loc->loc) == VALUE
4719 && find_mem_expr_in_1pdv (decl, loc->loc,
4720 shared_hash_htab (set->vars)))
4721 break;
4724 if (!loc)
4725 return 1;
4727 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4728 var = *slot;
4729 gcc_assert (var->n_var_parts == 1);
4732 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4733 loc; loc = *locp)
4735 rtx old_loc = loc->loc;
4736 if (GET_CODE (old_loc) == VALUE)
4738 location_chain mem_node
4739 = find_mem_expr_in_1pdv (decl, loc->loc,
4740 shared_hash_htab (set->vars));
4742 /* ??? This picks up only one out of multiple MEMs that
4743 refer to the same variable. Do we ever need to be
4744 concerned about dealing with more than one, or, given
4745 that they should all map to the same variable
4746 location, their addresses will have been merged and
4747 they will be regarded as equivalent? */
4748 if (mem_node)
4750 loc->loc = mem_node->loc;
4751 loc->set_src = mem_node->set_src;
4752 loc->init = MIN (loc->init, mem_node->init);
4756 if (GET_CODE (loc->loc) != MEM
4757 || (MEM_EXPR (loc->loc) == decl
4758 && INT_MEM_OFFSET (loc->loc) == 0)
4759 || !mem_dies_at_call (loc->loc))
4761 if (old_loc != loc->loc && emit_notes)
4763 if (old_loc == var->var_part[0].cur_loc)
4765 changed = true;
4766 var->var_part[0].cur_loc = NULL;
4769 locp = &loc->next;
4770 continue;
4773 if (emit_notes)
4775 if (old_loc == var->var_part[0].cur_loc)
4777 changed = true;
4778 var->var_part[0].cur_loc = NULL;
4781 *locp = loc->next;
4782 pool_free (loc_chain_pool, loc);
4785 if (!var->var_part[0].loc_chain)
4787 var->n_var_parts--;
4788 changed = true;
4790 if (changed)
4791 variable_was_changed (var, set);
4794 return 1;
4797 /* Remove all MEMs from the location list of a hash table entry for a
4798 value. */
4801 dataflow_set_remove_mem_locs (variable_def **slot, dataflow_set *set)
4803 variable var = *slot;
4805 if (var->onepart == ONEPART_VALUE)
4807 location_chain loc, *locp;
4808 bool changed = false;
4809 rtx cur_loc;
4811 gcc_assert (var->n_var_parts == 1);
4813 if (shared_var_p (var, set->vars))
4815 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4816 if (GET_CODE (loc->loc) == MEM
4817 && mem_dies_at_call (loc->loc))
4818 break;
4820 if (!loc)
4821 return 1;
4823 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4824 var = *slot;
4825 gcc_assert (var->n_var_parts == 1);
4828 if (VAR_LOC_1PAUX (var))
4829 cur_loc = VAR_LOC_FROM (var);
4830 else
4831 cur_loc = var->var_part[0].cur_loc;
4833 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4834 loc; loc = *locp)
4836 if (GET_CODE (loc->loc) != MEM
4837 || !mem_dies_at_call (loc->loc))
4839 locp = &loc->next;
4840 continue;
4843 *locp = loc->next;
4844 /* If we have deleted the location which was last emitted
4845 we have to emit new location so add the variable to set
4846 of changed variables. */
4847 if (cur_loc == loc->loc)
4849 changed = true;
4850 var->var_part[0].cur_loc = NULL;
4851 if (VAR_LOC_1PAUX (var))
4852 VAR_LOC_FROM (var) = NULL;
4854 pool_free (loc_chain_pool, loc);
4857 if (!var->var_part[0].loc_chain)
4859 var->n_var_parts--;
4860 changed = true;
4862 if (changed)
4863 variable_was_changed (var, set);
4866 return 1;
4869 /* Remove all variable-location information about call-clobbered
4870 registers, as well as associations between MEMs and VALUEs. */
4872 static void
4873 dataflow_set_clear_at_call (dataflow_set *set)
4875 unsigned int r;
4876 hard_reg_set_iterator hrsi;
4878 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, r, hrsi)
4879 var_regno_delete (set, r);
4881 if (MAY_HAVE_DEBUG_INSNS)
4883 set->traversed_vars = set->vars;
4884 shared_hash_htab (set->vars)
4885 ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
4886 set->traversed_vars = set->vars;
4887 shared_hash_htab (set->vars)
4888 ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set);
4889 set->traversed_vars = NULL;
4893 static bool
4894 variable_part_different_p (variable_part *vp1, variable_part *vp2)
4896 location_chain lc1, lc2;
4898 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4900 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4902 if (REG_P (lc1->loc) && REG_P (lc2->loc))
4904 if (REGNO (lc1->loc) == REGNO (lc2->loc))
4905 break;
4907 if (rtx_equal_p (lc1->loc, lc2->loc))
4908 break;
4910 if (!lc2)
4911 return true;
4913 return false;
4916 /* Return true if one-part variables VAR1 and VAR2 are different.
4917 They must be in canonical order. */
4919 static bool
4920 onepart_variable_different_p (variable var1, variable var2)
4922 location_chain lc1, lc2;
4924 if (var1 == var2)
4925 return false;
4927 gcc_assert (var1->n_var_parts == 1
4928 && var2->n_var_parts == 1);
4930 lc1 = var1->var_part[0].loc_chain;
4931 lc2 = var2->var_part[0].loc_chain;
4933 gcc_assert (lc1 && lc2);
4935 while (lc1 && lc2)
4937 if (loc_cmp (lc1->loc, lc2->loc))
4938 return true;
4939 lc1 = lc1->next;
4940 lc2 = lc2->next;
4943 return lc1 != lc2;
4946 /* Return true if variables VAR1 and VAR2 are different. */
4948 static bool
4949 variable_different_p (variable var1, variable var2)
4951 int i;
4953 if (var1 == var2)
4954 return false;
4956 if (var1->onepart != var2->onepart)
4957 return true;
4959 if (var1->n_var_parts != var2->n_var_parts)
4960 return true;
4962 if (var1->onepart && var1->n_var_parts)
4964 gcc_checking_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv)
4965 && var1->n_var_parts == 1);
4966 /* One-part values have locations in a canonical order. */
4967 return onepart_variable_different_p (var1, var2);
4970 for (i = 0; i < var1->n_var_parts; i++)
4972 if (VAR_PART_OFFSET (var1, i) != VAR_PART_OFFSET (var2, i))
4973 return true;
4974 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
4975 return true;
4976 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
4977 return true;
4979 return false;
4982 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
4984 static bool
4985 dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
4987 variable_iterator_type hi;
4988 variable var1;
4990 if (old_set->vars == new_set->vars)
4991 return false;
4993 if (shared_hash_htab (old_set->vars)->elements ()
4994 != shared_hash_htab (new_set->vars)->elements ())
4995 return true;
4997 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars),
4998 var1, variable, hi)
5000 variable_table_type *htab = shared_hash_htab (new_set->vars);
5001 variable var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5002 if (!var2)
5004 if (dump_file && (dump_flags & TDF_DETAILS))
5006 fprintf (dump_file, "dataflow difference found: removal of:\n");
5007 dump_var (var1);
5009 return true;
5012 if (variable_different_p (var1, var2))
5014 if (dump_file && (dump_flags & TDF_DETAILS))
5016 fprintf (dump_file, "dataflow difference found: "
5017 "old and new follow:\n");
5018 dump_var (var1);
5019 dump_var (var2);
5021 return true;
5025 /* No need to traverse the second hashtab, if both have the same number
5026 of elements and the second one had all entries found in the first one,
5027 then it can't have any extra entries. */
5028 return false;
5031 /* Free the contents of dataflow set SET. */
5033 static void
5034 dataflow_set_destroy (dataflow_set *set)
5036 int i;
5038 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5039 attrs_list_clear (&set->regs[i]);
5041 shared_hash_destroy (set->vars);
5042 set->vars = NULL;
5045 /* Return true if RTL X contains a SYMBOL_REF. */
5047 static bool
5048 contains_symbol_ref (rtx x)
5050 const char *fmt;
5051 RTX_CODE code;
5052 int i;
5054 if (!x)
5055 return false;
5057 code = GET_CODE (x);
5058 if (code == SYMBOL_REF)
5059 return true;
5061 fmt = GET_RTX_FORMAT (code);
5062 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5064 if (fmt[i] == 'e')
5066 if (contains_symbol_ref (XEXP (x, i)))
5067 return true;
5069 else if (fmt[i] == 'E')
5071 int j;
5072 for (j = 0; j < XVECLEN (x, i); j++)
5073 if (contains_symbol_ref (XVECEXP (x, i, j)))
5074 return true;
5078 return false;
5081 /* Shall EXPR be tracked? */
5083 static bool
5084 track_expr_p (tree expr, bool need_rtl)
5086 rtx decl_rtl;
5087 tree realdecl;
5089 if (TREE_CODE (expr) == DEBUG_EXPR_DECL)
5090 return DECL_RTL_SET_P (expr);
5092 /* If EXPR is not a parameter or a variable do not track it. */
5093 if (TREE_CODE (expr) != VAR_DECL && TREE_CODE (expr) != PARM_DECL)
5094 return 0;
5096 /* It also must have a name... */
5097 if (!DECL_NAME (expr) && need_rtl)
5098 return 0;
5100 /* ... and a RTL assigned to it. */
5101 decl_rtl = DECL_RTL_IF_SET (expr);
5102 if (!decl_rtl && need_rtl)
5103 return 0;
5105 /* If this expression is really a debug alias of some other declaration, we
5106 don't need to track this expression if the ultimate declaration is
5107 ignored. */
5108 realdecl = expr;
5109 if (TREE_CODE (realdecl) == VAR_DECL && DECL_HAS_DEBUG_EXPR_P (realdecl))
5111 realdecl = DECL_DEBUG_EXPR (realdecl);
5112 if (!DECL_P (realdecl))
5114 if (handled_component_p (realdecl)
5115 || (TREE_CODE (realdecl) == MEM_REF
5116 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5118 HOST_WIDE_INT bitsize, bitpos, maxsize;
5119 tree innerdecl
5120 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize,
5121 &maxsize);
5122 if (!DECL_P (innerdecl)
5123 || DECL_IGNORED_P (innerdecl)
5124 /* Do not track declarations for parts of tracked parameters
5125 since we want to track them as a whole instead. */
5126 || (TREE_CODE (innerdecl) == PARM_DECL
5127 && DECL_MODE (innerdecl) != BLKmode
5128 && TREE_CODE (TREE_TYPE (innerdecl)) != UNION_TYPE)
5129 || TREE_STATIC (innerdecl)
5130 || bitsize <= 0
5131 || bitpos + bitsize > 256
5132 || bitsize != maxsize)
5133 return 0;
5134 else
5135 realdecl = expr;
5137 else
5138 return 0;
5142 /* Do not track EXPR if REALDECL it should be ignored for debugging
5143 purposes. */
5144 if (DECL_IGNORED_P (realdecl))
5145 return 0;
5147 /* Do not track global variables until we are able to emit correct location
5148 list for them. */
5149 if (TREE_STATIC (realdecl))
5150 return 0;
5152 /* When the EXPR is a DECL for alias of some variable (see example)
5153 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5154 DECL_RTL contains SYMBOL_REF.
5156 Example:
5157 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5158 char **_dl_argv;
5160 if (decl_rtl && MEM_P (decl_rtl)
5161 && contains_symbol_ref (XEXP (decl_rtl, 0)))
5162 return 0;
5164 /* If RTX is a memory it should not be very large (because it would be
5165 an array or struct). */
5166 if (decl_rtl && MEM_P (decl_rtl))
5168 /* Do not track structures and arrays. */
5169 if (GET_MODE (decl_rtl) == BLKmode
5170 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
5171 return 0;
5172 if (MEM_SIZE_KNOWN_P (decl_rtl)
5173 && MEM_SIZE (decl_rtl) > MAX_VAR_PARTS)
5174 return 0;
5177 DECL_CHANGED (expr) = 0;
5178 DECL_CHANGED (realdecl) = 0;
5179 return 1;
5182 /* Determine whether a given LOC refers to the same variable part as
5183 EXPR+OFFSET. */
5185 static bool
5186 same_variable_part_p (rtx loc, tree expr, HOST_WIDE_INT offset)
5188 tree expr2;
5189 HOST_WIDE_INT offset2;
5191 if (! DECL_P (expr))
5192 return false;
5194 if (REG_P (loc))
5196 expr2 = REG_EXPR (loc);
5197 offset2 = REG_OFFSET (loc);
5199 else if (MEM_P (loc))
5201 expr2 = MEM_EXPR (loc);
5202 offset2 = INT_MEM_OFFSET (loc);
5204 else
5205 return false;
5207 if (! expr2 || ! DECL_P (expr2))
5208 return false;
5210 expr = var_debug_decl (expr);
5211 expr2 = var_debug_decl (expr2);
5213 return (expr == expr2 && offset == offset2);
5216 /* LOC is a REG or MEM that we would like to track if possible.
5217 If EXPR is null, we don't know what expression LOC refers to,
5218 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5219 LOC is an lvalue register.
5221 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5222 is something we can track. When returning true, store the mode of
5223 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5224 from EXPR in *OFFSET_OUT (if nonnull). */
5226 static bool
5227 track_loc_p (rtx loc, tree expr, HOST_WIDE_INT offset, bool store_reg_p,
5228 machine_mode *mode_out, HOST_WIDE_INT *offset_out)
5230 machine_mode mode;
5232 if (expr == NULL || !track_expr_p (expr, true))
5233 return false;
5235 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5236 whole subreg, but only the old inner part is really relevant. */
5237 mode = GET_MODE (loc);
5238 if (REG_P (loc) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc)))
5240 machine_mode pseudo_mode;
5242 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc));
5243 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (pseudo_mode))
5245 offset += byte_lowpart_offset (pseudo_mode, mode);
5246 mode = pseudo_mode;
5250 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5251 Do the same if we are storing to a register and EXPR occupies
5252 the whole of register LOC; in that case, the whole of EXPR is
5253 being changed. We exclude complex modes from the second case
5254 because the real and imaginary parts are represented as separate
5255 pseudo registers, even if the whole complex value fits into one
5256 hard register. */
5257 if ((GET_MODE_SIZE (mode) > GET_MODE_SIZE (DECL_MODE (expr))
5258 || (store_reg_p
5259 && !COMPLEX_MODE_P (DECL_MODE (expr))
5260 && hard_regno_nregs[REGNO (loc)][DECL_MODE (expr)] == 1))
5261 && offset + byte_lowpart_offset (DECL_MODE (expr), mode) == 0)
5263 mode = DECL_MODE (expr);
5264 offset = 0;
5267 if (offset < 0 || offset >= MAX_VAR_PARTS)
5268 return false;
5270 if (mode_out)
5271 *mode_out = mode;
5272 if (offset_out)
5273 *offset_out = offset;
5274 return true;
5277 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5278 want to track. When returning nonnull, make sure that the attributes
5279 on the returned value are updated. */
5281 static rtx
5282 var_lowpart (machine_mode mode, rtx loc)
5284 unsigned int offset, reg_offset, regno;
5286 if (GET_MODE (loc) == mode)
5287 return loc;
5289 if (!REG_P (loc) && !MEM_P (loc))
5290 return NULL;
5292 offset = byte_lowpart_offset (mode, GET_MODE (loc));
5294 if (MEM_P (loc))
5295 return adjust_address_nv (loc, mode, offset);
5297 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
5298 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
5299 reg_offset, mode);
5300 return gen_rtx_REG_offset (loc, mode, regno, offset);
5303 /* Carry information about uses and stores while walking rtx. */
5305 struct count_use_info
5307 /* The insn where the RTX is. */
5308 rtx_insn *insn;
5310 /* The basic block where insn is. */
5311 basic_block bb;
5313 /* The array of n_sets sets in the insn, as determined by cselib. */
5314 struct cselib_set *sets;
5315 int n_sets;
5317 /* True if we're counting stores, false otherwise. */
5318 bool store_p;
5321 /* Find a VALUE corresponding to X. */
5323 static inline cselib_val *
5324 find_use_val (rtx x, machine_mode mode, struct count_use_info *cui)
5326 int i;
5328 if (cui->sets)
5330 /* This is called after uses are set up and before stores are
5331 processed by cselib, so it's safe to look up srcs, but not
5332 dsts. So we look up expressions that appear in srcs or in
5333 dest expressions, but we search the sets array for dests of
5334 stores. */
5335 if (cui->store_p)
5337 /* Some targets represent memset and memcpy patterns
5338 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5339 (set (mem:BLK ...) (const_int ...)) or
5340 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5341 in that case, otherwise we end up with mode mismatches. */
5342 if (mode == BLKmode && MEM_P (x))
5343 return NULL;
5344 for (i = 0; i < cui->n_sets; i++)
5345 if (cui->sets[i].dest == x)
5346 return cui->sets[i].src_elt;
5348 else
5349 return cselib_lookup (x, mode, 0, VOIDmode);
5352 return NULL;
5355 /* Replace all registers and addresses in an expression with VALUE
5356 expressions that map back to them, unless the expression is a
5357 register. If no mapping is or can be performed, returns NULL. */
5359 static rtx
5360 replace_expr_with_values (rtx loc)
5362 if (REG_P (loc) || GET_CODE (loc) == ENTRY_VALUE)
5363 return NULL;
5364 else if (MEM_P (loc))
5366 cselib_val *addr = cselib_lookup (XEXP (loc, 0),
5367 get_address_mode (loc), 0,
5368 GET_MODE (loc));
5369 if (addr)
5370 return replace_equiv_address_nv (loc, addr->val_rtx);
5371 else
5372 return NULL;
5374 else
5375 return cselib_subst_to_values (loc, VOIDmode);
5378 /* Return true if X contains a DEBUG_EXPR. */
5380 static bool
5381 rtx_debug_expr_p (const_rtx x)
5383 subrtx_iterator::array_type array;
5384 FOR_EACH_SUBRTX (iter, array, x, ALL)
5385 if (GET_CODE (*iter) == DEBUG_EXPR)
5386 return true;
5387 return false;
5390 /* Determine what kind of micro operation to choose for a USE. Return
5391 MO_CLOBBER if no micro operation is to be generated. */
5393 static enum micro_operation_type
5394 use_type (rtx loc, struct count_use_info *cui, machine_mode *modep)
5396 tree expr;
5398 if (cui && cui->sets)
5400 if (GET_CODE (loc) == VAR_LOCATION)
5402 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc), false))
5404 rtx ploc = PAT_VAR_LOCATION_LOC (loc);
5405 if (! VAR_LOC_UNKNOWN_P (ploc))
5407 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc), 1,
5408 VOIDmode);
5410 /* ??? flag_float_store and volatile mems are never
5411 given values, but we could in theory use them for
5412 locations. */
5413 gcc_assert (val || 1);
5415 return MO_VAL_LOC;
5417 else
5418 return MO_CLOBBER;
5421 if (REG_P (loc) || MEM_P (loc))
5423 if (modep)
5424 *modep = GET_MODE (loc);
5425 if (cui->store_p)
5427 if (REG_P (loc)
5428 || (find_use_val (loc, GET_MODE (loc), cui)
5429 && cselib_lookup (XEXP (loc, 0),
5430 get_address_mode (loc), 0,
5431 GET_MODE (loc))))
5432 return MO_VAL_SET;
5434 else
5436 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5438 if (val && !cselib_preserved_value_p (val))
5439 return MO_VAL_USE;
5444 if (REG_P (loc))
5446 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER);
5448 if (loc == cfa_base_rtx)
5449 return MO_CLOBBER;
5450 expr = REG_EXPR (loc);
5452 if (!expr)
5453 return MO_USE_NO_VAR;
5454 else if (target_for_debug_bind (var_debug_decl (expr)))
5455 return MO_CLOBBER;
5456 else if (track_loc_p (loc, expr, REG_OFFSET (loc),
5457 false, modep, NULL))
5458 return MO_USE;
5459 else
5460 return MO_USE_NO_VAR;
5462 else if (MEM_P (loc))
5464 expr = MEM_EXPR (loc);
5466 if (!expr)
5467 return MO_CLOBBER;
5468 else if (target_for_debug_bind (var_debug_decl (expr)))
5469 return MO_CLOBBER;
5470 else if (track_loc_p (loc, expr, INT_MEM_OFFSET (loc),
5471 false, modep, NULL)
5472 /* Multi-part variables shouldn't refer to one-part
5473 variable names such as VALUEs (never happens) or
5474 DEBUG_EXPRs (only happens in the presence of debug
5475 insns). */
5476 && (!MAY_HAVE_DEBUG_INSNS
5477 || !rtx_debug_expr_p (XEXP (loc, 0))))
5478 return MO_USE;
5479 else
5480 return MO_CLOBBER;
5483 return MO_CLOBBER;
5486 /* Log to OUT information about micro-operation MOPT involving X in
5487 INSN of BB. */
5489 static inline void
5490 log_op_type (rtx x, basic_block bb, rtx_insn *insn,
5491 enum micro_operation_type mopt, FILE *out)
5493 fprintf (out, "bb %i op %i insn %i %s ",
5494 bb->index, VTI (bb)->mos.length (),
5495 INSN_UID (insn), micro_operation_type_name[mopt]);
5496 print_inline_rtx (out, x, 2);
5497 fputc ('\n', out);
5500 /* Tell whether the CONCAT used to holds a VALUE and its location
5501 needs value resolution, i.e., an attempt of mapping the location
5502 back to other incoming values. */
5503 #define VAL_NEEDS_RESOLUTION(x) \
5504 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5505 /* Whether the location in the CONCAT is a tracked expression, that
5506 should also be handled like a MO_USE. */
5507 #define VAL_HOLDS_TRACK_EXPR(x) \
5508 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5509 /* Whether the location in the CONCAT should be handled like a MO_COPY
5510 as well. */
5511 #define VAL_EXPR_IS_COPIED(x) \
5512 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5513 /* Whether the location in the CONCAT should be handled like a
5514 MO_CLOBBER as well. */
5515 #define VAL_EXPR_IS_CLOBBERED(x) \
5516 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5518 /* All preserved VALUEs. */
5519 static vec<rtx> preserved_values;
5521 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5523 static void
5524 preserve_value (cselib_val *val)
5526 cselib_preserve_value (val);
5527 preserved_values.safe_push (val->val_rtx);
5530 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5531 any rtxes not suitable for CONST use not replaced by VALUEs
5532 are discovered. */
5534 static bool
5535 non_suitable_const (const_rtx x)
5537 subrtx_iterator::array_type array;
5538 FOR_EACH_SUBRTX (iter, array, x, ALL)
5540 const_rtx x = *iter;
5541 switch (GET_CODE (x))
5543 case REG:
5544 case DEBUG_EXPR:
5545 case PC:
5546 case SCRATCH:
5547 case CC0:
5548 case ASM_INPUT:
5549 case ASM_OPERANDS:
5550 return true;
5551 case MEM:
5552 if (!MEM_READONLY_P (x))
5553 return true;
5554 break;
5555 default:
5556 break;
5559 return false;
5562 /* Add uses (register and memory references) LOC which will be tracked
5563 to VTI (bb)->mos. */
5565 static void
5566 add_uses (rtx loc, struct count_use_info *cui)
5568 machine_mode mode = VOIDmode;
5569 enum micro_operation_type type = use_type (loc, cui, &mode);
5571 if (type != MO_CLOBBER)
5573 basic_block bb = cui->bb;
5574 micro_operation mo;
5576 mo.type = type;
5577 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
5578 mo.insn = cui->insn;
5580 if (type == MO_VAL_LOC)
5582 rtx oloc = loc;
5583 rtx vloc = PAT_VAR_LOCATION_LOC (oloc);
5584 cselib_val *val;
5586 gcc_assert (cui->sets);
5588 if (MEM_P (vloc)
5589 && !REG_P (XEXP (vloc, 0))
5590 && !MEM_P (XEXP (vloc, 0)))
5592 rtx mloc = vloc;
5593 machine_mode address_mode = get_address_mode (mloc);
5594 cselib_val *val
5595 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5596 GET_MODE (mloc));
5598 if (val && !cselib_preserved_value_p (val))
5599 preserve_value (val);
5602 if (CONSTANT_P (vloc)
5603 && (GET_CODE (vloc) != CONST || non_suitable_const (vloc)))
5604 /* For constants don't look up any value. */;
5605 else if (!VAR_LOC_UNKNOWN_P (vloc) && !unsuitable_loc (vloc)
5606 && (val = find_use_val (vloc, GET_MODE (oloc), cui)))
5608 machine_mode mode2;
5609 enum micro_operation_type type2;
5610 rtx nloc = NULL;
5611 bool resolvable = REG_P (vloc) || MEM_P (vloc);
5613 if (resolvable)
5614 nloc = replace_expr_with_values (vloc);
5616 if (nloc)
5618 oloc = shallow_copy_rtx (oloc);
5619 PAT_VAR_LOCATION_LOC (oloc) = nloc;
5622 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc);
5624 type2 = use_type (vloc, 0, &mode2);
5626 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5627 || type2 == MO_CLOBBER);
5629 if (type2 == MO_CLOBBER
5630 && !cselib_preserved_value_p (val))
5632 VAL_NEEDS_RESOLUTION (oloc) = resolvable;
5633 preserve_value (val);
5636 else if (!VAR_LOC_UNKNOWN_P (vloc))
5638 oloc = shallow_copy_rtx (oloc);
5639 PAT_VAR_LOCATION_LOC (oloc) = gen_rtx_UNKNOWN_VAR_LOC ();
5642 mo.u.loc = oloc;
5644 else if (type == MO_VAL_USE)
5646 machine_mode mode2 = VOIDmode;
5647 enum micro_operation_type type2;
5648 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
5649 rtx vloc, oloc = loc, nloc;
5651 gcc_assert (cui->sets);
5653 if (MEM_P (oloc)
5654 && !REG_P (XEXP (oloc, 0))
5655 && !MEM_P (XEXP (oloc, 0)))
5657 rtx mloc = oloc;
5658 machine_mode address_mode = get_address_mode (mloc);
5659 cselib_val *val
5660 = cselib_lookup (XEXP (mloc, 0), address_mode, 0,
5661 GET_MODE (mloc));
5663 if (val && !cselib_preserved_value_p (val))
5664 preserve_value (val);
5667 type2 = use_type (loc, 0, &mode2);
5669 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
5670 || type2 == MO_CLOBBER);
5672 if (type2 == MO_USE)
5673 vloc = var_lowpart (mode2, loc);
5674 else
5675 vloc = oloc;
5677 /* The loc of a MO_VAL_USE may have two forms:
5679 (concat val src): val is at src, a value-based
5680 representation.
5682 (concat (concat val use) src): same as above, with use as
5683 the MO_USE tracked value, if it differs from src.
5687 gcc_checking_assert (REG_P (loc) || MEM_P (loc));
5688 nloc = replace_expr_with_values (loc);
5689 if (!nloc)
5690 nloc = oloc;
5692 if (vloc != nloc)
5693 oloc = gen_rtx_CONCAT (mode2, val->val_rtx, vloc);
5694 else
5695 oloc = val->val_rtx;
5697 mo.u.loc = gen_rtx_CONCAT (mode, oloc, nloc);
5699 if (type2 == MO_USE)
5700 VAL_HOLDS_TRACK_EXPR (mo.u.loc) = 1;
5701 if (!cselib_preserved_value_p (val))
5703 VAL_NEEDS_RESOLUTION (mo.u.loc) = 1;
5704 preserve_value (val);
5707 else
5708 gcc_assert (type == MO_USE || type == MO_USE_NO_VAR);
5710 if (dump_file && (dump_flags & TDF_DETAILS))
5711 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
5712 VTI (bb)->mos.safe_push (mo);
5716 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5718 static void
5719 add_uses_1 (rtx *x, void *cui)
5721 subrtx_var_iterator::array_type array;
5722 FOR_EACH_SUBRTX_VAR (iter, array, *x, NONCONST)
5723 add_uses (*iter, (struct count_use_info *) cui);
5726 /* This is the value used during expansion of locations. We want it
5727 to be unbounded, so that variables expanded deep in a recursion
5728 nest are fully evaluated, so that their values are cached
5729 correctly. We avoid recursion cycles through other means, and we
5730 don't unshare RTL, so excess complexity is not a problem. */
5731 #define EXPR_DEPTH (INT_MAX)
5732 /* We use this to keep too-complex expressions from being emitted as
5733 location notes, and then to debug information. Users can trade
5734 compile time for ridiculously complex expressions, although they're
5735 seldom useful, and they may often have to be discarded as not
5736 representable anyway. */
5737 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5739 /* Attempt to reverse the EXPR operation in the debug info and record
5740 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5741 no longer live we can express its value as VAL - 6. */
5743 static void
5744 reverse_op (rtx val, const_rtx expr, rtx_insn *insn)
5746 rtx src, arg, ret;
5747 cselib_val *v;
5748 struct elt_loc_list *l;
5749 enum rtx_code code;
5750 int count;
5752 if (GET_CODE (expr) != SET)
5753 return;
5755 if (!REG_P (SET_DEST (expr)) || GET_MODE (val) != GET_MODE (SET_DEST (expr)))
5756 return;
5758 src = SET_SRC (expr);
5759 switch (GET_CODE (src))
5761 case PLUS:
5762 case MINUS:
5763 case XOR:
5764 case NOT:
5765 case NEG:
5766 if (!REG_P (XEXP (src, 0)))
5767 return;
5768 break;
5769 case SIGN_EXTEND:
5770 case ZERO_EXTEND:
5771 if (!REG_P (XEXP (src, 0)) && !MEM_P (XEXP (src, 0)))
5772 return;
5773 break;
5774 default:
5775 return;
5778 if (!SCALAR_INT_MODE_P (GET_MODE (src)) || XEXP (src, 0) == cfa_base_rtx)
5779 return;
5781 v = cselib_lookup (XEXP (src, 0), GET_MODE (XEXP (src, 0)), 0, VOIDmode);
5782 if (!v || !cselib_preserved_value_p (v))
5783 return;
5785 /* Use canonical V to avoid creating multiple redundant expressions
5786 for different VALUES equivalent to V. */
5787 v = canonical_cselib_val (v);
5789 /* Adding a reverse op isn't useful if V already has an always valid
5790 location. Ignore ENTRY_VALUE, while it is always constant, we should
5791 prefer non-ENTRY_VALUE locations whenever possible. */
5792 for (l = v->locs, count = 0; l; l = l->next, count++)
5793 if (CONSTANT_P (l->loc)
5794 && (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
5795 return;
5796 /* Avoid creating too large locs lists. */
5797 else if (count == PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE))
5798 return;
5800 switch (GET_CODE (src))
5802 case NOT:
5803 case NEG:
5804 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5805 return;
5806 ret = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (val), val);
5807 break;
5808 case SIGN_EXTEND:
5809 case ZERO_EXTEND:
5810 ret = gen_lowpart_SUBREG (GET_MODE (v->val_rtx), val);
5811 break;
5812 case XOR:
5813 code = XOR;
5814 goto binary;
5815 case PLUS:
5816 code = MINUS;
5817 goto binary;
5818 case MINUS:
5819 code = PLUS;
5820 goto binary;
5821 binary:
5822 if (GET_MODE (v->val_rtx) != GET_MODE (val))
5823 return;
5824 arg = XEXP (src, 1);
5825 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5827 arg = cselib_expand_value_rtx (arg, scratch_regs, 5);
5828 if (arg == NULL_RTX)
5829 return;
5830 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
5831 return;
5833 ret = simplify_gen_binary (code, GET_MODE (val), val, arg);
5834 if (ret == val)
5835 /* Ensure ret isn't VALUE itself (which can happen e.g. for
5836 (plus (reg1) (reg2)) when reg2 is known to be 0), as that
5837 breaks a lot of routines during var-tracking. */
5838 ret = gen_rtx_fmt_ee (PLUS, GET_MODE (val), val, const0_rtx);
5839 break;
5840 default:
5841 gcc_unreachable ();
5844 cselib_add_permanent_equiv (v, ret, insn);
5847 /* Add stores (register and memory references) LOC which will be tracked
5848 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5849 CUIP->insn is instruction which the LOC is part of. */
5851 static void
5852 add_stores (rtx loc, const_rtx expr, void *cuip)
5854 machine_mode mode = VOIDmode, mode2;
5855 struct count_use_info *cui = (struct count_use_info *)cuip;
5856 basic_block bb = cui->bb;
5857 micro_operation mo;
5858 rtx oloc = loc, nloc, src = NULL;
5859 enum micro_operation_type type = use_type (loc, cui, &mode);
5860 bool track_p = false;
5861 cselib_val *v;
5862 bool resolve, preserve;
5864 if (type == MO_CLOBBER)
5865 return;
5867 mode2 = mode;
5869 if (REG_P (loc))
5871 gcc_assert (loc != cfa_base_rtx);
5872 if ((GET_CODE (expr) == CLOBBER && type != MO_VAL_SET)
5873 || !(track_p = use_type (loc, NULL, &mode2) == MO_USE)
5874 || GET_CODE (expr) == CLOBBER)
5876 mo.type = MO_CLOBBER;
5877 mo.u.loc = loc;
5878 if (GET_CODE (expr) == SET
5879 && SET_DEST (expr) == loc
5880 && !unsuitable_loc (SET_SRC (expr))
5881 && find_use_val (loc, mode, cui))
5883 gcc_checking_assert (type == MO_VAL_SET);
5884 mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
5887 else
5889 if (GET_CODE (expr) == SET
5890 && SET_DEST (expr) == loc
5891 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
5892 src = var_lowpart (mode2, SET_SRC (expr));
5893 loc = var_lowpart (mode2, loc);
5895 if (src == NULL)
5897 mo.type = MO_SET;
5898 mo.u.loc = loc;
5900 else
5902 rtx xexpr = gen_rtx_SET (loc, src);
5903 if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
5905 /* If this is an instruction copying (part of) a parameter
5906 passed by invisible reference to its register location,
5907 pretend it's a SET so that the initial memory location
5908 is discarded, as the parameter register can be reused
5909 for other purposes and we do not track locations based
5910 on generic registers. */
5911 if (MEM_P (src)
5912 && REG_EXPR (loc)
5913 && TREE_CODE (REG_EXPR (loc)) == PARM_DECL
5914 && DECL_MODE (REG_EXPR (loc)) != BLKmode
5915 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc)))
5916 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc)), 0)
5917 != arg_pointer_rtx)
5918 mo.type = MO_SET;
5919 else
5920 mo.type = MO_COPY;
5922 else
5923 mo.type = MO_SET;
5924 mo.u.loc = xexpr;
5927 mo.insn = cui->insn;
5929 else if (MEM_P (loc)
5930 && ((track_p = use_type (loc, NULL, &mode2) == MO_USE)
5931 || cui->sets))
5933 if (MEM_P (loc) && type == MO_VAL_SET
5934 && !REG_P (XEXP (loc, 0))
5935 && !MEM_P (XEXP (loc, 0)))
5937 rtx mloc = loc;
5938 machine_mode address_mode = get_address_mode (mloc);
5939 cselib_val *val = cselib_lookup (XEXP (mloc, 0),
5940 address_mode, 0,
5941 GET_MODE (mloc));
5943 if (val && !cselib_preserved_value_p (val))
5944 preserve_value (val);
5947 if (GET_CODE (expr) == CLOBBER || !track_p)
5949 mo.type = MO_CLOBBER;
5950 mo.u.loc = track_p ? var_lowpart (mode2, loc) : loc;
5952 else
5954 if (GET_CODE (expr) == SET
5955 && SET_DEST (expr) == loc
5956 && GET_CODE (SET_SRC (expr)) != ASM_OPERANDS)
5957 src = var_lowpart (mode2, SET_SRC (expr));
5958 loc = var_lowpart (mode2, loc);
5960 if (src == NULL)
5962 mo.type = MO_SET;
5963 mo.u.loc = loc;
5965 else
5967 rtx xexpr = gen_rtx_SET (loc, src);
5968 if (same_variable_part_p (SET_SRC (xexpr),
5969 MEM_EXPR (loc),
5970 INT_MEM_OFFSET (loc)))
5971 mo.type = MO_COPY;
5972 else
5973 mo.type = MO_SET;
5974 mo.u.loc = xexpr;
5977 mo.insn = cui->insn;
5979 else
5980 return;
5982 if (type != MO_VAL_SET)
5983 goto log_and_return;
5985 v = find_use_val (oloc, mode, cui);
5987 if (!v)
5988 goto log_and_return;
5990 resolve = preserve = !cselib_preserved_value_p (v);
5992 /* We cannot track values for multiple-part variables, so we track only
5993 locations for tracked parameters passed either by invisible reference
5994 or directly in multiple locations. */
5995 if (track_p
5996 && REG_P (loc)
5997 && REG_EXPR (loc)
5998 && TREE_CODE (REG_EXPR (loc)) == PARM_DECL
5999 && DECL_MODE (REG_EXPR (loc)) != BLKmode
6000 && TREE_CODE (TREE_TYPE (REG_EXPR (loc))) != UNION_TYPE
6001 && ((MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc)))
6002 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc)), 0) != arg_pointer_rtx)
6003 || (GET_CODE (DECL_INCOMING_RTL (REG_EXPR (loc))) == PARALLEL
6004 && XVECLEN (DECL_INCOMING_RTL (REG_EXPR (loc)), 0) > 1)))
6006 /* Although we don't use the value here, it could be used later by the
6007 mere virtue of its existence as the operand of the reverse operation
6008 that gave rise to it (typically extension/truncation). Make sure it
6009 is preserved as required by vt_expand_var_loc_chain. */
6010 if (preserve)
6011 preserve_value (v);
6012 goto log_and_return;
6015 if (loc == stack_pointer_rtx
6016 && hard_frame_pointer_adjustment != -1
6017 && preserve)
6018 cselib_set_value_sp_based (v);
6020 nloc = replace_expr_with_values (oloc);
6021 if (nloc)
6022 oloc = nloc;
6024 if (GET_CODE (PATTERN (cui->insn)) == COND_EXEC)
6026 cselib_val *oval = cselib_lookup (oloc, GET_MODE (oloc), 0, VOIDmode);
6028 if (oval == v)
6029 return;
6030 gcc_assert (REG_P (oloc) || MEM_P (oloc));
6032 if (oval && !cselib_preserved_value_p (oval))
6034 micro_operation moa;
6036 preserve_value (oval);
6038 moa.type = MO_VAL_USE;
6039 moa.u.loc = gen_rtx_CONCAT (mode, oval->val_rtx, oloc);
6040 VAL_NEEDS_RESOLUTION (moa.u.loc) = 1;
6041 moa.insn = cui->insn;
6043 if (dump_file && (dump_flags & TDF_DETAILS))
6044 log_op_type (moa.u.loc, cui->bb, cui->insn,
6045 moa.type, dump_file);
6046 VTI (bb)->mos.safe_push (moa);
6049 resolve = false;
6051 else if (resolve && GET_CODE (mo.u.loc) == SET)
6053 if (REG_P (SET_SRC (expr)) || MEM_P (SET_SRC (expr)))
6054 nloc = replace_expr_with_values (SET_SRC (expr));
6055 else
6056 nloc = NULL_RTX;
6058 /* Avoid the mode mismatch between oexpr and expr. */
6059 if (!nloc && mode != mode2)
6061 nloc = SET_SRC (expr);
6062 gcc_assert (oloc == SET_DEST (expr));
6065 if (nloc && nloc != SET_SRC (mo.u.loc))
6066 oloc = gen_rtx_SET (oloc, nloc);
6067 else
6069 if (oloc == SET_DEST (mo.u.loc))
6070 /* No point in duplicating. */
6071 oloc = mo.u.loc;
6072 if (!REG_P (SET_SRC (mo.u.loc)))
6073 resolve = false;
6076 else if (!resolve)
6078 if (GET_CODE (mo.u.loc) == SET
6079 && oloc == SET_DEST (mo.u.loc))
6080 /* No point in duplicating. */
6081 oloc = mo.u.loc;
6083 else
6084 resolve = false;
6086 loc = gen_rtx_CONCAT (mode, v->val_rtx, oloc);
6088 if (mo.u.loc != oloc)
6089 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, mo.u.loc);
6091 /* The loc of a MO_VAL_SET may have various forms:
6093 (concat val dst): dst now holds val
6095 (concat val (set dst src)): dst now holds val, copied from src
6097 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6098 after replacing mems and non-top-level regs with values.
6100 (concat (concat val dstv) (set dst src)): dst now holds val,
6101 copied from src. dstv is a value-based representation of dst, if
6102 it differs from dst. If resolution is needed, src is a REG, and
6103 its mode is the same as that of val.
6105 (concat (concat val (set dstv srcv)) (set dst src)): src
6106 copied to dst, holding val. dstv and srcv are value-based
6107 representations of dst and src, respectively.
6111 if (GET_CODE (PATTERN (cui->insn)) != COND_EXEC)
6112 reverse_op (v->val_rtx, expr, cui->insn);
6114 mo.u.loc = loc;
6116 if (track_p)
6117 VAL_HOLDS_TRACK_EXPR (loc) = 1;
6118 if (preserve)
6120 VAL_NEEDS_RESOLUTION (loc) = resolve;
6121 preserve_value (v);
6123 if (mo.type == MO_CLOBBER)
6124 VAL_EXPR_IS_CLOBBERED (loc) = 1;
6125 if (mo.type == MO_COPY)
6126 VAL_EXPR_IS_COPIED (loc) = 1;
6128 mo.type = MO_VAL_SET;
6130 log_and_return:
6131 if (dump_file && (dump_flags & TDF_DETAILS))
6132 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
6133 VTI (bb)->mos.safe_push (mo);
6136 /* Arguments to the call. */
6137 static rtx call_arguments;
6139 /* Compute call_arguments. */
6141 static void
6142 prepare_call_arguments (basic_block bb, rtx_insn *insn)
6144 rtx link, x, call;
6145 rtx prev, cur, next;
6146 rtx this_arg = NULL_RTX;
6147 tree type = NULL_TREE, t, fndecl = NULL_TREE;
6148 tree obj_type_ref = NULL_TREE;
6149 CUMULATIVE_ARGS args_so_far_v;
6150 cumulative_args_t args_so_far;
6152 memset (&args_so_far_v, 0, sizeof (args_so_far_v));
6153 args_so_far = pack_cumulative_args (&args_so_far_v);
6154 call = get_call_rtx_from (insn);
6155 if (call)
6157 if (GET_CODE (XEXP (XEXP (call, 0), 0)) == SYMBOL_REF)
6159 rtx symbol = XEXP (XEXP (call, 0), 0);
6160 if (SYMBOL_REF_DECL (symbol))
6161 fndecl = SYMBOL_REF_DECL (symbol);
6163 if (fndecl == NULL_TREE)
6164 fndecl = MEM_EXPR (XEXP (call, 0));
6165 if (fndecl
6166 && TREE_CODE (TREE_TYPE (fndecl)) != FUNCTION_TYPE
6167 && TREE_CODE (TREE_TYPE (fndecl)) != METHOD_TYPE)
6168 fndecl = NULL_TREE;
6169 if (fndecl && TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6170 type = TREE_TYPE (fndecl);
6171 if (fndecl && TREE_CODE (fndecl) != FUNCTION_DECL)
6173 if (TREE_CODE (fndecl) == INDIRECT_REF
6174 && TREE_CODE (TREE_OPERAND (fndecl, 0)) == OBJ_TYPE_REF)
6175 obj_type_ref = TREE_OPERAND (fndecl, 0);
6176 fndecl = NULL_TREE;
6178 if (type)
6180 for (t = TYPE_ARG_TYPES (type); t && t != void_list_node;
6181 t = TREE_CHAIN (t))
6182 if (TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
6183 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t))))
6184 break;
6185 if ((t == NULL || t == void_list_node) && obj_type_ref == NULL_TREE)
6186 type = NULL;
6187 else
6189 int nargs ATTRIBUTE_UNUSED = list_length (TYPE_ARG_TYPES (type));
6190 link = CALL_INSN_FUNCTION_USAGE (insn);
6191 #ifndef PCC_STATIC_STRUCT_RETURN
6192 if (aggregate_value_p (TREE_TYPE (type), type)
6193 && targetm.calls.struct_value_rtx (type, 0) == 0)
6195 tree struct_addr = build_pointer_type (TREE_TYPE (type));
6196 machine_mode mode = TYPE_MODE (struct_addr);
6197 rtx reg;
6198 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6199 nargs + 1);
6200 reg = targetm.calls.function_arg (args_so_far, mode,
6201 struct_addr, true);
6202 targetm.calls.function_arg_advance (args_so_far, mode,
6203 struct_addr, true);
6204 if (reg == NULL_RTX)
6206 for (; link; link = XEXP (link, 1))
6207 if (GET_CODE (XEXP (link, 0)) == USE
6208 && MEM_P (XEXP (XEXP (link, 0), 0)))
6210 link = XEXP (link, 1);
6211 break;
6215 else
6216 #endif
6217 INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
6218 nargs);
6219 if (obj_type_ref && TYPE_ARG_TYPES (type) != void_list_node)
6221 machine_mode mode;
6222 t = TYPE_ARG_TYPES (type);
6223 mode = TYPE_MODE (TREE_VALUE (t));
6224 this_arg = targetm.calls.function_arg (args_so_far, mode,
6225 TREE_VALUE (t), true);
6226 if (this_arg && !REG_P (this_arg))
6227 this_arg = NULL_RTX;
6228 else if (this_arg == NULL_RTX)
6230 for (; link; link = XEXP (link, 1))
6231 if (GET_CODE (XEXP (link, 0)) == USE
6232 && MEM_P (XEXP (XEXP (link, 0), 0)))
6234 this_arg = XEXP (XEXP (link, 0), 0);
6235 break;
6242 t = type ? TYPE_ARG_TYPES (type) : NULL_TREE;
6244 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6245 if (GET_CODE (XEXP (link, 0)) == USE)
6247 rtx item = NULL_RTX;
6248 x = XEXP (XEXP (link, 0), 0);
6249 if (GET_MODE (link) == VOIDmode
6250 || GET_MODE (link) == BLKmode
6251 || (GET_MODE (link) != GET_MODE (x)
6252 && ((GET_MODE_CLASS (GET_MODE (link)) != MODE_INT
6253 && GET_MODE_CLASS (GET_MODE (link)) != MODE_PARTIAL_INT)
6254 || (GET_MODE_CLASS (GET_MODE (x)) != MODE_INT
6255 && GET_MODE_CLASS (GET_MODE (x)) != MODE_PARTIAL_INT))))
6256 /* Can't do anything for these, if the original type mode
6257 isn't known or can't be converted. */;
6258 else if (REG_P (x))
6260 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6261 if (val && cselib_preserved_value_p (val))
6262 item = val->val_rtx;
6263 else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
6264 || GET_MODE_CLASS (GET_MODE (x)) == MODE_PARTIAL_INT)
6266 machine_mode mode = GET_MODE (x);
6268 while ((mode = GET_MODE_WIDER_MODE (mode)) != VOIDmode
6269 && GET_MODE_BITSIZE (mode) <= BITS_PER_WORD)
6271 rtx reg = simplify_subreg (mode, x, GET_MODE (x), 0);
6273 if (reg == NULL_RTX || !REG_P (reg))
6274 continue;
6275 val = cselib_lookup (reg, mode, 0, VOIDmode);
6276 if (val && cselib_preserved_value_p (val))
6278 item = val->val_rtx;
6279 break;
6284 else if (MEM_P (x))
6286 rtx mem = x;
6287 cselib_val *val;
6289 if (!frame_pointer_needed)
6291 struct adjust_mem_data amd;
6292 amd.mem_mode = VOIDmode;
6293 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
6294 amd.side_effects = NULL;
6295 amd.store = true;
6296 mem = simplify_replace_fn_rtx (mem, NULL_RTX, adjust_mems,
6297 &amd);
6298 gcc_assert (amd.side_effects == NULL_RTX);
6300 val = cselib_lookup (mem, GET_MODE (mem), 0, VOIDmode);
6301 if (val && cselib_preserved_value_p (val))
6302 item = val->val_rtx;
6303 else if (GET_MODE_CLASS (GET_MODE (mem)) != MODE_INT
6304 && GET_MODE_CLASS (GET_MODE (mem)) != MODE_PARTIAL_INT)
6306 /* For non-integer stack argument see also if they weren't
6307 initialized by integers. */
6308 machine_mode imode = int_mode_for_mode (GET_MODE (mem));
6309 if (imode != GET_MODE (mem) && imode != BLKmode)
6311 val = cselib_lookup (adjust_address_nv (mem, imode, 0),
6312 imode, 0, VOIDmode);
6313 if (val && cselib_preserved_value_p (val))
6314 item = lowpart_subreg (GET_MODE (x), val->val_rtx,
6315 imode);
6319 if (item)
6321 rtx x2 = x;
6322 if (GET_MODE (item) != GET_MODE (link))
6323 item = lowpart_subreg (GET_MODE (link), item, GET_MODE (item));
6324 if (GET_MODE (x2) != GET_MODE (link))
6325 x2 = lowpart_subreg (GET_MODE (link), x2, GET_MODE (x2));
6326 item = gen_rtx_CONCAT (GET_MODE (link), x2, item);
6327 call_arguments
6328 = gen_rtx_EXPR_LIST (VOIDmode, item, call_arguments);
6330 if (t && t != void_list_node)
6332 tree argtype = TREE_VALUE (t);
6333 machine_mode mode = TYPE_MODE (argtype);
6334 rtx reg;
6335 if (pass_by_reference (&args_so_far_v, mode, argtype, true))
6337 argtype = build_pointer_type (argtype);
6338 mode = TYPE_MODE (argtype);
6340 reg = targetm.calls.function_arg (args_so_far, mode,
6341 argtype, true);
6342 if (TREE_CODE (argtype) == REFERENCE_TYPE
6343 && INTEGRAL_TYPE_P (TREE_TYPE (argtype))
6344 && reg
6345 && REG_P (reg)
6346 && GET_MODE (reg) == mode
6347 && (GET_MODE_CLASS (mode) == MODE_INT
6348 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
6349 && REG_P (x)
6350 && REGNO (x) == REGNO (reg)
6351 && GET_MODE (x) == mode
6352 && item)
6354 machine_mode indmode
6355 = TYPE_MODE (TREE_TYPE (argtype));
6356 rtx mem = gen_rtx_MEM (indmode, x);
6357 cselib_val *val = cselib_lookup (mem, indmode, 0, VOIDmode);
6358 if (val && cselib_preserved_value_p (val))
6360 item = gen_rtx_CONCAT (indmode, mem, val->val_rtx);
6361 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6362 call_arguments);
6364 else
6366 struct elt_loc_list *l;
6367 tree initial;
6369 /* Try harder, when passing address of a constant
6370 pool integer it can be easily read back. */
6371 item = XEXP (item, 1);
6372 if (GET_CODE (item) == SUBREG)
6373 item = SUBREG_REG (item);
6374 gcc_assert (GET_CODE (item) == VALUE);
6375 val = CSELIB_VAL_PTR (item);
6376 for (l = val->locs; l; l = l->next)
6377 if (GET_CODE (l->loc) == SYMBOL_REF
6378 && TREE_CONSTANT_POOL_ADDRESS_P (l->loc)
6379 && SYMBOL_REF_DECL (l->loc)
6380 && DECL_INITIAL (SYMBOL_REF_DECL (l->loc)))
6382 initial = DECL_INITIAL (SYMBOL_REF_DECL (l->loc));
6383 if (tree_fits_shwi_p (initial))
6385 item = GEN_INT (tree_to_shwi (initial));
6386 item = gen_rtx_CONCAT (indmode, mem, item);
6387 call_arguments
6388 = gen_rtx_EXPR_LIST (VOIDmode, item,
6389 call_arguments);
6391 break;
6395 targetm.calls.function_arg_advance (args_so_far, mode,
6396 argtype, true);
6397 t = TREE_CHAIN (t);
6401 /* Add debug arguments. */
6402 if (fndecl
6403 && TREE_CODE (fndecl) == FUNCTION_DECL
6404 && DECL_HAS_DEBUG_ARGS_P (fndecl))
6406 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (fndecl);
6407 if (debug_args)
6409 unsigned int ix;
6410 tree param;
6411 for (ix = 0; vec_safe_iterate (*debug_args, ix, &param); ix += 2)
6413 rtx item;
6414 tree dtemp = (**debug_args)[ix + 1];
6415 machine_mode mode = DECL_MODE (dtemp);
6416 item = gen_rtx_DEBUG_PARAMETER_REF (mode, param);
6417 item = gen_rtx_CONCAT (mode, item, DECL_RTL_KNOWN_SET (dtemp));
6418 call_arguments = gen_rtx_EXPR_LIST (VOIDmode, item,
6419 call_arguments);
6424 /* Reverse call_arguments chain. */
6425 prev = NULL_RTX;
6426 for (cur = call_arguments; cur; cur = next)
6428 next = XEXP (cur, 1);
6429 XEXP (cur, 1) = prev;
6430 prev = cur;
6432 call_arguments = prev;
6434 x = get_call_rtx_from (insn);
6435 if (x)
6437 x = XEXP (XEXP (x, 0), 0);
6438 if (GET_CODE (x) == SYMBOL_REF)
6439 /* Don't record anything. */;
6440 else if (CONSTANT_P (x))
6442 x = gen_rtx_CONCAT (GET_MODE (x) == VOIDmode ? Pmode : GET_MODE (x),
6443 pc_rtx, x);
6444 call_arguments
6445 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6447 else
6449 cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
6450 if (val && cselib_preserved_value_p (val))
6452 x = gen_rtx_CONCAT (GET_MODE (x), pc_rtx, val->val_rtx);
6453 call_arguments
6454 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6458 if (this_arg)
6460 machine_mode mode
6461 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref)));
6462 rtx clobbered = gen_rtx_MEM (mode, this_arg);
6463 HOST_WIDE_INT token
6464 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref));
6465 if (token)
6466 clobbered = plus_constant (mode, clobbered,
6467 token * GET_MODE_SIZE (mode));
6468 clobbered = gen_rtx_MEM (mode, clobbered);
6469 x = gen_rtx_CONCAT (mode, gen_rtx_CLOBBER (VOIDmode, pc_rtx), clobbered);
6470 call_arguments
6471 = gen_rtx_EXPR_LIST (VOIDmode, x, call_arguments);
6475 /* Callback for cselib_record_sets_hook, that records as micro
6476 operations uses and stores in an insn after cselib_record_sets has
6477 analyzed the sets in an insn, but before it modifies the stored
6478 values in the internal tables, unless cselib_record_sets doesn't
6479 call it directly (perhaps because we're not doing cselib in the
6480 first place, in which case sets and n_sets will be 0). */
6482 static void
6483 add_with_sets (rtx_insn *insn, struct cselib_set *sets, int n_sets)
6485 basic_block bb = BLOCK_FOR_INSN (insn);
6486 int n1, n2;
6487 struct count_use_info cui;
6488 micro_operation *mos;
6490 cselib_hook_called = true;
6492 cui.insn = insn;
6493 cui.bb = bb;
6494 cui.sets = sets;
6495 cui.n_sets = n_sets;
6497 n1 = VTI (bb)->mos.length ();
6498 cui.store_p = false;
6499 note_uses (&PATTERN (insn), add_uses_1, &cui);
6500 n2 = VTI (bb)->mos.length () - 1;
6501 mos = VTI (bb)->mos.address ();
6503 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6504 MO_VAL_LOC last. */
6505 while (n1 < n2)
6507 while (n1 < n2 && mos[n1].type == MO_USE)
6508 n1++;
6509 while (n1 < n2 && mos[n2].type != MO_USE)
6510 n2--;
6511 if (n1 < n2)
6513 micro_operation sw;
6515 sw = mos[n1];
6516 mos[n1] = mos[n2];
6517 mos[n2] = sw;
6521 n2 = VTI (bb)->mos.length () - 1;
6522 while (n1 < n2)
6524 while (n1 < n2 && mos[n1].type != MO_VAL_LOC)
6525 n1++;
6526 while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
6527 n2--;
6528 if (n1 < n2)
6530 micro_operation sw;
6532 sw = mos[n1];
6533 mos[n1] = mos[n2];
6534 mos[n2] = sw;
6538 if (CALL_P (insn))
6540 micro_operation mo;
6542 mo.type = MO_CALL;
6543 mo.insn = insn;
6544 mo.u.loc = call_arguments;
6545 call_arguments = NULL_RTX;
6547 if (dump_file && (dump_flags & TDF_DETAILS))
6548 log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
6549 VTI (bb)->mos.safe_push (mo);
6552 n1 = VTI (bb)->mos.length ();
6553 /* This will record NEXT_INSN (insn), such that we can
6554 insert notes before it without worrying about any
6555 notes that MO_USEs might emit after the insn. */
6556 cui.store_p = true;
6557 note_stores (PATTERN (insn), add_stores, &cui);
6558 n2 = VTI (bb)->mos.length () - 1;
6559 mos = VTI (bb)->mos.address ();
6561 /* Order the MO_VAL_USEs first (note_stores does nothing
6562 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6563 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6564 while (n1 < n2)
6566 while (n1 < n2 && mos[n1].type == MO_VAL_USE)
6567 n1++;
6568 while (n1 < n2 && mos[n2].type != MO_VAL_USE)
6569 n2--;
6570 if (n1 < n2)
6572 micro_operation sw;
6574 sw = mos[n1];
6575 mos[n1] = mos[n2];
6576 mos[n2] = sw;
6580 n2 = VTI (bb)->mos.length () - 1;
6581 while (n1 < n2)
6583 while (n1 < n2 && mos[n1].type == MO_CLOBBER)
6584 n1++;
6585 while (n1 < n2 && mos[n2].type != MO_CLOBBER)
6586 n2--;
6587 if (n1 < n2)
6589 micro_operation sw;
6591 sw = mos[n1];
6592 mos[n1] = mos[n2];
6593 mos[n2] = sw;
6598 static enum var_init_status
6599 find_src_status (dataflow_set *in, rtx src)
6601 tree decl = NULL_TREE;
6602 enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED;
6604 if (! flag_var_tracking_uninit)
6605 status = VAR_INIT_STATUS_INITIALIZED;
6607 if (src && REG_P (src))
6608 decl = var_debug_decl (REG_EXPR (src));
6609 else if (src && MEM_P (src))
6610 decl = var_debug_decl (MEM_EXPR (src));
6612 if (src && decl)
6613 status = get_init_value (in, src, dv_from_decl (decl));
6615 return status;
6618 /* SRC is the source of an assignment. Use SET to try to find what
6619 was ultimately assigned to SRC. Return that value if known,
6620 otherwise return SRC itself. */
6622 static rtx
6623 find_src_set_src (dataflow_set *set, rtx src)
6625 tree decl = NULL_TREE; /* The variable being copied around. */
6626 rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */
6627 variable var;
6628 location_chain nextp;
6629 int i;
6630 bool found;
6632 if (src && REG_P (src))
6633 decl = var_debug_decl (REG_EXPR (src));
6634 else if (src && MEM_P (src))
6635 decl = var_debug_decl (MEM_EXPR (src));
6637 if (src && decl)
6639 decl_or_value dv = dv_from_decl (decl);
6641 var = shared_hash_find (set->vars, dv);
6642 if (var)
6644 found = false;
6645 for (i = 0; i < var->n_var_parts && !found; i++)
6646 for (nextp = var->var_part[i].loc_chain; nextp && !found;
6647 nextp = nextp->next)
6648 if (rtx_equal_p (nextp->loc, src))
6650 set_src = nextp->set_src;
6651 found = true;
6657 return set_src;
6660 /* Compute the changes of variable locations in the basic block BB. */
6662 static bool
6663 compute_bb_dataflow (basic_block bb)
6665 unsigned int i;
6666 micro_operation *mo;
6667 bool changed;
6668 dataflow_set old_out;
6669 dataflow_set *in = &VTI (bb)->in;
6670 dataflow_set *out = &VTI (bb)->out;
6672 dataflow_set_init (&old_out);
6673 dataflow_set_copy (&old_out, out);
6674 dataflow_set_copy (out, in);
6676 if (MAY_HAVE_DEBUG_INSNS)
6677 local_get_addr_cache = new hash_map<rtx, rtx>;
6679 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
6681 rtx_insn *insn = mo->insn;
6683 switch (mo->type)
6685 case MO_CALL:
6686 dataflow_set_clear_at_call (out);
6687 break;
6689 case MO_USE:
6691 rtx loc = mo->u.loc;
6693 if (REG_P (loc))
6694 var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6695 else if (MEM_P (loc))
6696 var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
6698 break;
6700 case MO_VAL_LOC:
6702 rtx loc = mo->u.loc;
6703 rtx val, vloc;
6704 tree var;
6706 if (GET_CODE (loc) == CONCAT)
6708 val = XEXP (loc, 0);
6709 vloc = XEXP (loc, 1);
6711 else
6713 val = NULL_RTX;
6714 vloc = loc;
6717 var = PAT_VAR_LOCATION_DECL (vloc);
6719 clobber_variable_part (out, NULL_RTX,
6720 dv_from_decl (var), 0, NULL_RTX);
6721 if (val)
6723 if (VAL_NEEDS_RESOLUTION (loc))
6724 val_resolve (out, val, PAT_VAR_LOCATION_LOC (vloc), insn);
6725 set_variable_part (out, val, dv_from_decl (var), 0,
6726 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6727 INSERT);
6729 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
6730 set_variable_part (out, PAT_VAR_LOCATION_LOC (vloc),
6731 dv_from_decl (var), 0,
6732 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
6733 INSERT);
6735 break;
6737 case MO_VAL_USE:
6739 rtx loc = mo->u.loc;
6740 rtx val, vloc, uloc;
6742 vloc = uloc = XEXP (loc, 1);
6743 val = XEXP (loc, 0);
6745 if (GET_CODE (val) == CONCAT)
6747 uloc = XEXP (val, 1);
6748 val = XEXP (val, 0);
6751 if (VAL_NEEDS_RESOLUTION (loc))
6752 val_resolve (out, val, vloc, insn);
6753 else
6754 val_store (out, val, uloc, insn, false);
6756 if (VAL_HOLDS_TRACK_EXPR (loc))
6758 if (GET_CODE (uloc) == REG)
6759 var_reg_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6760 NULL);
6761 else if (GET_CODE (uloc) == MEM)
6762 var_mem_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
6763 NULL);
6766 break;
6768 case MO_VAL_SET:
6770 rtx loc = mo->u.loc;
6771 rtx val, vloc, uloc;
6772 rtx dstv, srcv;
6774 vloc = loc;
6775 uloc = XEXP (vloc, 1);
6776 val = XEXP (vloc, 0);
6777 vloc = uloc;
6779 if (GET_CODE (uloc) == SET)
6781 dstv = SET_DEST (uloc);
6782 srcv = SET_SRC (uloc);
6784 else
6786 dstv = uloc;
6787 srcv = NULL;
6790 if (GET_CODE (val) == CONCAT)
6792 dstv = vloc = XEXP (val, 1);
6793 val = XEXP (val, 0);
6796 if (GET_CODE (vloc) == SET)
6798 srcv = SET_SRC (vloc);
6800 gcc_assert (val != srcv);
6801 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
6803 dstv = vloc = SET_DEST (vloc);
6805 if (VAL_NEEDS_RESOLUTION (loc))
6806 val_resolve (out, val, srcv, insn);
6808 else if (VAL_NEEDS_RESOLUTION (loc))
6810 gcc_assert (GET_CODE (uloc) == SET
6811 && GET_CODE (SET_SRC (uloc)) == REG);
6812 val_resolve (out, val, SET_SRC (uloc), insn);
6815 if (VAL_HOLDS_TRACK_EXPR (loc))
6817 if (VAL_EXPR_IS_CLOBBERED (loc))
6819 if (REG_P (uloc))
6820 var_reg_delete (out, uloc, true);
6821 else if (MEM_P (uloc))
6823 gcc_assert (MEM_P (dstv));
6824 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
6825 var_mem_delete (out, dstv, true);
6828 else
6830 bool copied_p = VAL_EXPR_IS_COPIED (loc);
6831 rtx src = NULL, dst = uloc;
6832 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
6834 if (GET_CODE (uloc) == SET)
6836 src = SET_SRC (uloc);
6837 dst = SET_DEST (uloc);
6840 if (copied_p)
6842 if (flag_var_tracking_uninit)
6844 status = find_src_status (in, src);
6846 if (status == VAR_INIT_STATUS_UNKNOWN)
6847 status = find_src_status (out, src);
6850 src = find_src_set_src (in, src);
6853 if (REG_P (dst))
6854 var_reg_delete_and_set (out, dst, !copied_p,
6855 status, srcv);
6856 else if (MEM_P (dst))
6858 gcc_assert (MEM_P (dstv));
6859 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
6860 var_mem_delete_and_set (out, dstv, !copied_p,
6861 status, srcv);
6865 else if (REG_P (uloc))
6866 var_regno_delete (out, REGNO (uloc));
6867 else if (MEM_P (uloc))
6869 gcc_checking_assert (GET_CODE (vloc) == MEM);
6870 gcc_checking_assert (dstv == vloc);
6871 if (dstv != vloc)
6872 clobber_overlapping_mems (out, vloc);
6875 val_store (out, val, dstv, insn, true);
6877 break;
6879 case MO_SET:
6881 rtx loc = mo->u.loc;
6882 rtx set_src = NULL;
6884 if (GET_CODE (loc) == SET)
6886 set_src = SET_SRC (loc);
6887 loc = SET_DEST (loc);
6890 if (REG_P (loc))
6891 var_reg_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6892 set_src);
6893 else if (MEM_P (loc))
6894 var_mem_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
6895 set_src);
6897 break;
6899 case MO_COPY:
6901 rtx loc = mo->u.loc;
6902 enum var_init_status src_status;
6903 rtx set_src = NULL;
6905 if (GET_CODE (loc) == SET)
6907 set_src = SET_SRC (loc);
6908 loc = SET_DEST (loc);
6911 if (! flag_var_tracking_uninit)
6912 src_status = VAR_INIT_STATUS_INITIALIZED;
6913 else
6915 src_status = find_src_status (in, set_src);
6917 if (src_status == VAR_INIT_STATUS_UNKNOWN)
6918 src_status = find_src_status (out, set_src);
6921 set_src = find_src_set_src (in, set_src);
6923 if (REG_P (loc))
6924 var_reg_delete_and_set (out, loc, false, src_status, set_src);
6925 else if (MEM_P (loc))
6926 var_mem_delete_and_set (out, loc, false, src_status, set_src);
6928 break;
6930 case MO_USE_NO_VAR:
6932 rtx loc = mo->u.loc;
6934 if (REG_P (loc))
6935 var_reg_delete (out, loc, false);
6936 else if (MEM_P (loc))
6937 var_mem_delete (out, loc, false);
6939 break;
6941 case MO_CLOBBER:
6943 rtx loc = mo->u.loc;
6945 if (REG_P (loc))
6946 var_reg_delete (out, loc, true);
6947 else if (MEM_P (loc))
6948 var_mem_delete (out, loc, true);
6950 break;
6952 case MO_ADJUST:
6953 out->stack_adjust += mo->u.adjust;
6954 break;
6958 if (MAY_HAVE_DEBUG_INSNS)
6960 delete local_get_addr_cache;
6961 local_get_addr_cache = NULL;
6963 dataflow_set_equiv_regs (out);
6964 shared_hash_htab (out->vars)
6965 ->traverse <dataflow_set *, canonicalize_values_mark> (out);
6966 shared_hash_htab (out->vars)
6967 ->traverse <dataflow_set *, canonicalize_values_star> (out);
6968 #if ENABLE_CHECKING
6969 shared_hash_htab (out->vars)
6970 ->traverse <dataflow_set *, canonicalize_loc_order_check> (out);
6971 #endif
6973 changed = dataflow_set_different (&old_out, out);
6974 dataflow_set_destroy (&old_out);
6975 return changed;
6978 /* Find the locations of variables in the whole function. */
6980 static bool
6981 vt_find_locations (void)
6983 bb_heap_t *worklist = new bb_heap_t (LONG_MIN);
6984 bb_heap_t *pending = new bb_heap_t (LONG_MIN);
6985 bb_heap_t *fibheap_swap = NULL;
6986 sbitmap visited, in_worklist, in_pending, sbitmap_swap;
6987 basic_block bb;
6988 edge e;
6989 int *bb_order;
6990 int *rc_order;
6991 int i;
6992 int htabsz = 0;
6993 int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
6994 bool success = true;
6996 timevar_push (TV_VAR_TRACKING_DATAFLOW);
6997 /* Compute reverse completion order of depth first search of the CFG
6998 so that the data-flow runs faster. */
6999 rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS);
7000 bb_order = XNEWVEC (int, last_basic_block_for_fn (cfun));
7001 pre_and_rev_post_order_compute (NULL, rc_order, false);
7002 for (i = 0; i < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; i++)
7003 bb_order[rc_order[i]] = i;
7004 free (rc_order);
7006 visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
7007 in_worklist = sbitmap_alloc (last_basic_block_for_fn (cfun));
7008 in_pending = sbitmap_alloc (last_basic_block_for_fn (cfun));
7009 bitmap_clear (in_worklist);
7011 FOR_EACH_BB_FN (bb, cfun)
7012 pending->insert (bb_order[bb->index], bb);
7013 bitmap_ones (in_pending);
7015 while (success && !pending->empty ())
7017 fibheap_swap = pending;
7018 pending = worklist;
7019 worklist = fibheap_swap;
7020 sbitmap_swap = in_pending;
7021 in_pending = in_worklist;
7022 in_worklist = sbitmap_swap;
7024 bitmap_clear (visited);
7026 while (!worklist->empty ())
7028 bb = worklist->extract_min ();
7029 bitmap_clear_bit (in_worklist, bb->index);
7030 gcc_assert (!bitmap_bit_p (visited, bb->index));
7031 if (!bitmap_bit_p (visited, bb->index))
7033 bool changed;
7034 edge_iterator ei;
7035 int oldinsz, oldoutsz;
7037 bitmap_set_bit (visited, bb->index);
7039 if (VTI (bb)->in.vars)
7041 htabsz
7042 -= shared_hash_htab (VTI (bb)->in.vars)->size ()
7043 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7044 oldinsz = shared_hash_htab (VTI (bb)->in.vars)->elements ();
7045 oldoutsz
7046 = shared_hash_htab (VTI (bb)->out.vars)->elements ();
7048 else
7049 oldinsz = oldoutsz = 0;
7051 if (MAY_HAVE_DEBUG_INSNS)
7053 dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
7054 bool first = true, adjust = false;
7056 /* Calculate the IN set as the intersection of
7057 predecessor OUT sets. */
7059 dataflow_set_clear (in);
7060 dst_can_be_shared = true;
7062 FOR_EACH_EDGE (e, ei, bb->preds)
7063 if (!VTI (e->src)->flooded)
7064 gcc_assert (bb_order[bb->index]
7065 <= bb_order[e->src->index]);
7066 else if (first)
7068 dataflow_set_copy (in, &VTI (e->src)->out);
7069 first_out = &VTI (e->src)->out;
7070 first = false;
7072 else
7074 dataflow_set_merge (in, &VTI (e->src)->out);
7075 adjust = true;
7078 if (adjust)
7080 dataflow_post_merge_adjust (in, &VTI (bb)->permp);
7081 #if ENABLE_CHECKING
7082 /* Merge and merge_adjust should keep entries in
7083 canonical order. */
7084 shared_hash_htab (in->vars)
7085 ->traverse <dataflow_set *,
7086 canonicalize_loc_order_check> (in);
7087 #endif
7088 if (dst_can_be_shared)
7090 shared_hash_destroy (in->vars);
7091 in->vars = shared_hash_copy (first_out->vars);
7095 VTI (bb)->flooded = true;
7097 else
7099 /* Calculate the IN set as union of predecessor OUT sets. */
7100 dataflow_set_clear (&VTI (bb)->in);
7101 FOR_EACH_EDGE (e, ei, bb->preds)
7102 dataflow_set_union (&VTI (bb)->in, &VTI (e->src)->out);
7105 changed = compute_bb_dataflow (bb);
7106 htabsz += shared_hash_htab (VTI (bb)->in.vars)->size ()
7107 + shared_hash_htab (VTI (bb)->out.vars)->size ();
7109 if (htabmax && htabsz > htabmax)
7111 if (MAY_HAVE_DEBUG_INSNS)
7112 inform (DECL_SOURCE_LOCATION (cfun->decl),
7113 "variable tracking size limit exceeded with "
7114 "-fvar-tracking-assignments, retrying without");
7115 else
7116 inform (DECL_SOURCE_LOCATION (cfun->decl),
7117 "variable tracking size limit exceeded");
7118 success = false;
7119 break;
7122 if (changed)
7124 FOR_EACH_EDGE (e, ei, bb->succs)
7126 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
7127 continue;
7129 if (bitmap_bit_p (visited, e->dest->index))
7131 if (!bitmap_bit_p (in_pending, e->dest->index))
7133 /* Send E->DEST to next round. */
7134 bitmap_set_bit (in_pending, e->dest->index);
7135 pending->insert (bb_order[e->dest->index],
7136 e->dest);
7139 else if (!bitmap_bit_p (in_worklist, e->dest->index))
7141 /* Add E->DEST to current round. */
7142 bitmap_set_bit (in_worklist, e->dest->index);
7143 worklist->insert (bb_order[e->dest->index],
7144 e->dest);
7149 if (dump_file)
7150 fprintf (dump_file,
7151 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7152 bb->index,
7153 (int)shared_hash_htab (VTI (bb)->in.vars)->size (),
7154 oldinsz,
7155 (int)shared_hash_htab (VTI (bb)->out.vars)->size (),
7156 oldoutsz,
7157 (int)worklist->nodes (), (int)pending->nodes (),
7158 htabsz);
7160 if (dump_file && (dump_flags & TDF_DETAILS))
7162 fprintf (dump_file, "BB %i IN:\n", bb->index);
7163 dump_dataflow_set (&VTI (bb)->in);
7164 fprintf (dump_file, "BB %i OUT:\n", bb->index);
7165 dump_dataflow_set (&VTI (bb)->out);
7171 if (success && MAY_HAVE_DEBUG_INSNS)
7172 FOR_EACH_BB_FN (bb, cfun)
7173 gcc_assert (VTI (bb)->flooded);
7175 free (bb_order);
7176 delete worklist;
7177 delete pending;
7178 sbitmap_free (visited);
7179 sbitmap_free (in_worklist);
7180 sbitmap_free (in_pending);
7182 timevar_pop (TV_VAR_TRACKING_DATAFLOW);
7183 return success;
7186 /* Print the content of the LIST to dump file. */
7188 static void
7189 dump_attrs_list (attrs list)
7191 for (; list; list = list->next)
7193 if (dv_is_decl_p (list->dv))
7194 print_mem_expr (dump_file, dv_as_decl (list->dv));
7195 else
7196 print_rtl_single (dump_file, dv_as_value (list->dv));
7197 fprintf (dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset);
7199 fprintf (dump_file, "\n");
7202 /* Print the information about variable *SLOT to dump file. */
7205 dump_var_tracking_slot (variable_def **slot, void *data ATTRIBUTE_UNUSED)
7207 variable var = *slot;
7209 dump_var (var);
7211 /* Continue traversing the hash table. */
7212 return 1;
7215 /* Print the information about variable VAR to dump file. */
7217 static void
7218 dump_var (variable var)
7220 int i;
7221 location_chain node;
7223 if (dv_is_decl_p (var->dv))
7225 const_tree decl = dv_as_decl (var->dv);
7227 if (DECL_NAME (decl))
7229 fprintf (dump_file, " name: %s",
7230 IDENTIFIER_POINTER (DECL_NAME (decl)));
7231 if (dump_flags & TDF_UID)
7232 fprintf (dump_file, "D.%u", DECL_UID (decl));
7234 else if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
7235 fprintf (dump_file, " name: D#%u", DEBUG_TEMP_UID (decl));
7236 else
7237 fprintf (dump_file, " name: D.%u", DECL_UID (decl));
7238 fprintf (dump_file, "\n");
7240 else
7242 fputc (' ', dump_file);
7243 print_rtl_single (dump_file, dv_as_value (var->dv));
7246 for (i = 0; i < var->n_var_parts; i++)
7248 fprintf (dump_file, " offset %ld\n",
7249 (long)(var->onepart ? 0 : VAR_PART_OFFSET (var, i)));
7250 for (node = var->var_part[i].loc_chain; node; node = node->next)
7252 fprintf (dump_file, " ");
7253 if (node->init == VAR_INIT_STATUS_UNINITIALIZED)
7254 fprintf (dump_file, "[uninit]");
7255 print_rtl_single (dump_file, node->loc);
7260 /* Print the information about variables from hash table VARS to dump file. */
7262 static void
7263 dump_vars (variable_table_type *vars)
7265 if (vars->elements () > 0)
7267 fprintf (dump_file, "Variables:\n");
7268 vars->traverse <void *, dump_var_tracking_slot> (NULL);
7272 /* Print the dataflow set SET to dump file. */
7274 static void
7275 dump_dataflow_set (dataflow_set *set)
7277 int i;
7279 fprintf (dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n",
7280 set->stack_adjust);
7281 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
7283 if (set->regs[i])
7285 fprintf (dump_file, "Reg %d:", i);
7286 dump_attrs_list (set->regs[i]);
7289 dump_vars (shared_hash_htab (set->vars));
7290 fprintf (dump_file, "\n");
7293 /* Print the IN and OUT sets for each basic block to dump file. */
7295 static void
7296 dump_dataflow_sets (void)
7298 basic_block bb;
7300 FOR_EACH_BB_FN (bb, cfun)
7302 fprintf (dump_file, "\nBasic block %d:\n", bb->index);
7303 fprintf (dump_file, "IN:\n");
7304 dump_dataflow_set (&VTI (bb)->in);
7305 fprintf (dump_file, "OUT:\n");
7306 dump_dataflow_set (&VTI (bb)->out);
7310 /* Return the variable for DV in dropped_values, inserting one if
7311 requested with INSERT. */
7313 static inline variable
7314 variable_from_dropped (decl_or_value dv, enum insert_option insert)
7316 variable_def **slot;
7317 variable empty_var;
7318 onepart_enum_t onepart;
7320 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), insert);
7322 if (!slot)
7323 return NULL;
7325 if (*slot)
7326 return *slot;
7328 gcc_checking_assert (insert == INSERT);
7330 onepart = dv_onepart_p (dv);
7332 gcc_checking_assert (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR);
7334 empty_var = (variable) pool_alloc (onepart_pool (onepart));
7335 empty_var->dv = dv;
7336 empty_var->refcount = 1;
7337 empty_var->n_var_parts = 0;
7338 empty_var->onepart = onepart;
7339 empty_var->in_changed_variables = false;
7340 empty_var->var_part[0].loc_chain = NULL;
7341 empty_var->var_part[0].cur_loc = NULL;
7342 VAR_LOC_1PAUX (empty_var) = NULL;
7343 set_dv_changed (dv, true);
7345 *slot = empty_var;
7347 return empty_var;
7350 /* Recover the one-part aux from dropped_values. */
7352 static struct onepart_aux *
7353 recover_dropped_1paux (variable var)
7355 variable dvar;
7357 gcc_checking_assert (var->onepart);
7359 if (VAR_LOC_1PAUX (var))
7360 return VAR_LOC_1PAUX (var);
7362 if (var->onepart == ONEPART_VDECL)
7363 return NULL;
7365 dvar = variable_from_dropped (var->dv, NO_INSERT);
7367 if (!dvar)
7368 return NULL;
7370 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (dvar);
7371 VAR_LOC_1PAUX (dvar) = NULL;
7373 return VAR_LOC_1PAUX (var);
7376 /* Add variable VAR to the hash table of changed variables and
7377 if it has no locations delete it from SET's hash table. */
7379 static void
7380 variable_was_changed (variable var, dataflow_set *set)
7382 hashval_t hash = dv_htab_hash (var->dv);
7384 if (emit_notes)
7386 variable_def **slot;
7388 /* Remember this decl or VALUE has been added to changed_variables. */
7389 set_dv_changed (var->dv, true);
7391 slot = changed_variables->find_slot_with_hash (var->dv, hash, INSERT);
7393 if (*slot)
7395 variable old_var = *slot;
7396 gcc_assert (old_var->in_changed_variables);
7397 old_var->in_changed_variables = false;
7398 if (var != old_var && var->onepart)
7400 /* Restore the auxiliary info from an empty variable
7401 previously created for changed_variables, so it is
7402 not lost. */
7403 gcc_checking_assert (!VAR_LOC_1PAUX (var));
7404 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (old_var);
7405 VAR_LOC_1PAUX (old_var) = NULL;
7407 variable_htab_free (*slot);
7410 if (set && var->n_var_parts == 0)
7412 onepart_enum_t onepart = var->onepart;
7413 variable empty_var = NULL;
7414 variable_def **dslot = NULL;
7416 if (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR)
7418 dslot = dropped_values->find_slot_with_hash (var->dv,
7419 dv_htab_hash (var->dv),
7420 INSERT);
7421 empty_var = *dslot;
7423 if (empty_var)
7425 gcc_checking_assert (!empty_var->in_changed_variables);
7426 if (!VAR_LOC_1PAUX (var))
7428 VAR_LOC_1PAUX (var) = VAR_LOC_1PAUX (empty_var);
7429 VAR_LOC_1PAUX (empty_var) = NULL;
7431 else
7432 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
7436 if (!empty_var)
7438 empty_var = (variable) pool_alloc (onepart_pool (onepart));
7439 empty_var->dv = var->dv;
7440 empty_var->refcount = 1;
7441 empty_var->n_var_parts = 0;
7442 empty_var->onepart = onepart;
7443 if (dslot)
7445 empty_var->refcount++;
7446 *dslot = empty_var;
7449 else
7450 empty_var->refcount++;
7451 empty_var->in_changed_variables = true;
7452 *slot = empty_var;
7453 if (onepart)
7455 empty_var->var_part[0].loc_chain = NULL;
7456 empty_var->var_part[0].cur_loc = NULL;
7457 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (var);
7458 VAR_LOC_1PAUX (var) = NULL;
7460 goto drop_var;
7462 else
7464 if (var->onepart && !VAR_LOC_1PAUX (var))
7465 recover_dropped_1paux (var);
7466 var->refcount++;
7467 var->in_changed_variables = true;
7468 *slot = var;
7471 else
7473 gcc_assert (set);
7474 if (var->n_var_parts == 0)
7476 variable_def **slot;
7478 drop_var:
7479 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
7480 if (slot)
7482 if (shared_hash_shared (set->vars))
7483 slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
7484 NO_INSERT);
7485 shared_hash_htab (set->vars)->clear_slot (slot);
7491 /* Look for the index in VAR->var_part corresponding to OFFSET.
7492 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7493 referenced int will be set to the index that the part has or should
7494 have, if it should be inserted. */
7496 static inline int
7497 find_variable_location_part (variable var, HOST_WIDE_INT offset,
7498 int *insertion_point)
7500 int pos, low, high;
7502 if (var->onepart)
7504 if (offset != 0)
7505 return -1;
7507 if (insertion_point)
7508 *insertion_point = 0;
7510 return var->n_var_parts - 1;
7513 /* Find the location part. */
7514 low = 0;
7515 high = var->n_var_parts;
7516 while (low != high)
7518 pos = (low + high) / 2;
7519 if (VAR_PART_OFFSET (var, pos) < offset)
7520 low = pos + 1;
7521 else
7522 high = pos;
7524 pos = low;
7526 if (insertion_point)
7527 *insertion_point = pos;
7529 if (pos < var->n_var_parts && VAR_PART_OFFSET (var, pos) == offset)
7530 return pos;
7532 return -1;
7535 static variable_def **
7536 set_slot_part (dataflow_set *set, rtx loc, variable_def **slot,
7537 decl_or_value dv, HOST_WIDE_INT offset,
7538 enum var_init_status initialized, rtx set_src)
7540 int pos;
7541 location_chain node, next;
7542 location_chain *nextp;
7543 variable var;
7544 onepart_enum_t onepart;
7546 var = *slot;
7548 if (var)
7549 onepart = var->onepart;
7550 else
7551 onepart = dv_onepart_p (dv);
7553 gcc_checking_assert (offset == 0 || !onepart);
7554 gcc_checking_assert (loc != dv_as_opaque (dv));
7556 if (! flag_var_tracking_uninit)
7557 initialized = VAR_INIT_STATUS_INITIALIZED;
7559 if (!var)
7561 /* Create new variable information. */
7562 var = (variable) pool_alloc (onepart_pool (onepart));
7563 var->dv = dv;
7564 var->refcount = 1;
7565 var->n_var_parts = 1;
7566 var->onepart = onepart;
7567 var->in_changed_variables = false;
7568 if (var->onepart)
7569 VAR_LOC_1PAUX (var) = NULL;
7570 else
7571 VAR_PART_OFFSET (var, 0) = offset;
7572 var->var_part[0].loc_chain = NULL;
7573 var->var_part[0].cur_loc = NULL;
7574 *slot = var;
7575 pos = 0;
7576 nextp = &var->var_part[0].loc_chain;
7578 else if (onepart)
7580 int r = -1, c = 0;
7582 gcc_assert (dv_as_opaque (var->dv) == dv_as_opaque (dv));
7584 pos = 0;
7586 if (GET_CODE (loc) == VALUE)
7588 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7589 nextp = &node->next)
7590 if (GET_CODE (node->loc) == VALUE)
7592 if (node->loc == loc)
7594 r = 0;
7595 break;
7597 if (canon_value_cmp (node->loc, loc))
7598 c++;
7599 else
7601 r = 1;
7602 break;
7605 else if (REG_P (node->loc) || MEM_P (node->loc))
7606 c++;
7607 else
7609 r = 1;
7610 break;
7613 else if (REG_P (loc))
7615 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7616 nextp = &node->next)
7617 if (REG_P (node->loc))
7619 if (REGNO (node->loc) < REGNO (loc))
7620 c++;
7621 else
7623 if (REGNO (node->loc) == REGNO (loc))
7624 r = 0;
7625 else
7626 r = 1;
7627 break;
7630 else
7632 r = 1;
7633 break;
7636 else if (MEM_P (loc))
7638 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7639 nextp = &node->next)
7640 if (REG_P (node->loc))
7641 c++;
7642 else if (MEM_P (node->loc))
7644 if ((r = loc_cmp (XEXP (node->loc, 0), XEXP (loc, 0))) >= 0)
7645 break;
7646 else
7647 c++;
7649 else
7651 r = 1;
7652 break;
7655 else
7656 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
7657 nextp = &node->next)
7658 if ((r = loc_cmp (node->loc, loc)) >= 0)
7659 break;
7660 else
7661 c++;
7663 if (r == 0)
7664 return slot;
7666 if (shared_var_p (var, set->vars))
7668 slot = unshare_variable (set, slot, var, initialized);
7669 var = *slot;
7670 for (nextp = &var->var_part[0].loc_chain; c;
7671 nextp = &(*nextp)->next)
7672 c--;
7673 gcc_assert ((!node && !*nextp) || node->loc == (*nextp)->loc);
7676 else
7678 int inspos = 0;
7680 gcc_assert (dv_as_decl (var->dv) == dv_as_decl (dv));
7682 pos = find_variable_location_part (var, offset, &inspos);
7684 if (pos >= 0)
7686 node = var->var_part[pos].loc_chain;
7688 if (node
7689 && ((REG_P (node->loc) && REG_P (loc)
7690 && REGNO (node->loc) == REGNO (loc))
7691 || rtx_equal_p (node->loc, loc)))
7693 /* LOC is in the beginning of the chain so we have nothing
7694 to do. */
7695 if (node->init < initialized)
7696 node->init = initialized;
7697 if (set_src != NULL)
7698 node->set_src = set_src;
7700 return slot;
7702 else
7704 /* We have to make a copy of a shared variable. */
7705 if (shared_var_p (var, set->vars))
7707 slot = unshare_variable (set, slot, var, initialized);
7708 var = *slot;
7712 else
7714 /* We have not found the location part, new one will be created. */
7716 /* We have to make a copy of the shared variable. */
7717 if (shared_var_p (var, set->vars))
7719 slot = unshare_variable (set, slot, var, initialized);
7720 var = *slot;
7723 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7724 thus there are at most MAX_VAR_PARTS different offsets. */
7725 gcc_assert (var->n_var_parts < MAX_VAR_PARTS
7726 && (!var->n_var_parts || !onepart));
7728 /* We have to move the elements of array starting at index
7729 inspos to the next position. */
7730 for (pos = var->n_var_parts; pos > inspos; pos--)
7731 var->var_part[pos] = var->var_part[pos - 1];
7733 var->n_var_parts++;
7734 gcc_checking_assert (!onepart);
7735 VAR_PART_OFFSET (var, pos) = offset;
7736 var->var_part[pos].loc_chain = NULL;
7737 var->var_part[pos].cur_loc = NULL;
7740 /* Delete the location from the list. */
7741 nextp = &var->var_part[pos].loc_chain;
7742 for (node = var->var_part[pos].loc_chain; node; node = next)
7744 next = node->next;
7745 if ((REG_P (node->loc) && REG_P (loc)
7746 && REGNO (node->loc) == REGNO (loc))
7747 || rtx_equal_p (node->loc, loc))
7749 /* Save these values, to assign to the new node, before
7750 deleting this one. */
7751 if (node->init > initialized)
7752 initialized = node->init;
7753 if (node->set_src != NULL && set_src == NULL)
7754 set_src = node->set_src;
7755 if (var->var_part[pos].cur_loc == node->loc)
7756 var->var_part[pos].cur_loc = NULL;
7757 pool_free (loc_chain_pool, node);
7758 *nextp = next;
7759 break;
7761 else
7762 nextp = &node->next;
7765 nextp = &var->var_part[pos].loc_chain;
7768 /* Add the location to the beginning. */
7769 node = (location_chain) pool_alloc (loc_chain_pool);
7770 node->loc = loc;
7771 node->init = initialized;
7772 node->set_src = set_src;
7773 node->next = *nextp;
7774 *nextp = node;
7776 /* If no location was emitted do so. */
7777 if (var->var_part[pos].cur_loc == NULL)
7778 variable_was_changed (var, set);
7780 return slot;
7783 /* Set the part of variable's location in the dataflow set SET. The
7784 variable part is specified by variable's declaration in DV and
7785 offset OFFSET and the part's location by LOC. IOPT should be
7786 NO_INSERT if the variable is known to be in SET already and the
7787 variable hash table must not be resized, and INSERT otherwise. */
7789 static void
7790 set_variable_part (dataflow_set *set, rtx loc,
7791 decl_or_value dv, HOST_WIDE_INT offset,
7792 enum var_init_status initialized, rtx set_src,
7793 enum insert_option iopt)
7795 variable_def **slot;
7797 if (iopt == NO_INSERT)
7798 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7799 else
7801 slot = shared_hash_find_slot (set->vars, dv);
7802 if (!slot)
7803 slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
7805 set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
7808 /* Remove all recorded register locations for the given variable part
7809 from dataflow set SET, except for those that are identical to loc.
7810 The variable part is specified by variable's declaration or value
7811 DV and offset OFFSET. */
7813 static variable_def **
7814 clobber_slot_part (dataflow_set *set, rtx loc, variable_def **slot,
7815 HOST_WIDE_INT offset, rtx set_src)
7817 variable var = *slot;
7818 int pos = find_variable_location_part (var, offset, NULL);
7820 if (pos >= 0)
7822 location_chain node, next;
7824 /* Remove the register locations from the dataflow set. */
7825 next = var->var_part[pos].loc_chain;
7826 for (node = next; node; node = next)
7828 next = node->next;
7829 if (node->loc != loc
7830 && (!flag_var_tracking_uninit
7831 || !set_src
7832 || MEM_P (set_src)
7833 || !rtx_equal_p (set_src, node->set_src)))
7835 if (REG_P (node->loc))
7837 attrs anode, anext;
7838 attrs *anextp;
7840 /* Remove the variable part from the register's
7841 list, but preserve any other variable parts
7842 that might be regarded as live in that same
7843 register. */
7844 anextp = &set->regs[REGNO (node->loc)];
7845 for (anode = *anextp; anode; anode = anext)
7847 anext = anode->next;
7848 if (dv_as_opaque (anode->dv) == dv_as_opaque (var->dv)
7849 && anode->offset == offset)
7851 pool_free (attrs_pool, anode);
7852 *anextp = anext;
7854 else
7855 anextp = &anode->next;
7859 slot = delete_slot_part (set, node->loc, slot, offset);
7864 return slot;
7867 /* Remove all recorded register locations for the given variable part
7868 from dataflow set SET, except for those that are identical to loc.
7869 The variable part is specified by variable's declaration or value
7870 DV and offset OFFSET. */
7872 static void
7873 clobber_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
7874 HOST_WIDE_INT offset, rtx set_src)
7876 variable_def **slot;
7878 if (!dv_as_opaque (dv)
7879 || (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
7880 return;
7882 slot = shared_hash_find_slot_noinsert (set->vars, dv);
7883 if (!slot)
7884 return;
7886 clobber_slot_part (set, loc, slot, offset, set_src);
7889 /* Delete the part of variable's location from dataflow set SET. The
7890 variable part is specified by its SET->vars slot SLOT and offset
7891 OFFSET and the part's location by LOC. */
7893 static variable_def **
7894 delete_slot_part (dataflow_set *set, rtx loc, variable_def **slot,
7895 HOST_WIDE_INT offset)
7897 variable var = *slot;
7898 int pos = find_variable_location_part (var, offset, NULL);
7900 if (pos >= 0)
7902 location_chain node, next;
7903 location_chain *nextp;
7904 bool changed;
7905 rtx cur_loc;
7907 if (shared_var_p (var, set->vars))
7909 /* If the variable contains the location part we have to
7910 make a copy of the variable. */
7911 for (node = var->var_part[pos].loc_chain; node;
7912 node = node->next)
7914 if ((REG_P (node->loc) && REG_P (loc)
7915 && REGNO (node->loc) == REGNO (loc))
7916 || rtx_equal_p (node->loc, loc))
7918 slot = unshare_variable (set, slot, var,
7919 VAR_INIT_STATUS_UNKNOWN);
7920 var = *slot;
7921 break;
7926 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
7927 cur_loc = VAR_LOC_FROM (var);
7928 else
7929 cur_loc = var->var_part[pos].cur_loc;
7931 /* Delete the location part. */
7932 changed = false;
7933 nextp = &var->var_part[pos].loc_chain;
7934 for (node = *nextp; node; node = next)
7936 next = node->next;
7937 if ((REG_P (node->loc) && REG_P (loc)
7938 && REGNO (node->loc) == REGNO (loc))
7939 || rtx_equal_p (node->loc, loc))
7941 /* If we have deleted the location which was last emitted
7942 we have to emit new location so add the variable to set
7943 of changed variables. */
7944 if (cur_loc == node->loc)
7946 changed = true;
7947 var->var_part[pos].cur_loc = NULL;
7948 if (pos == 0 && var->onepart && VAR_LOC_1PAUX (var))
7949 VAR_LOC_FROM (var) = NULL;
7951 pool_free (loc_chain_pool, node);
7952 *nextp = next;
7953 break;
7955 else
7956 nextp = &node->next;
7959 if (var->var_part[pos].loc_chain == NULL)
7961 changed = true;
7962 var->n_var_parts--;
7963 while (pos < var->n_var_parts)
7965 var->var_part[pos] = var->var_part[pos + 1];
7966 pos++;
7969 if (changed)
7970 variable_was_changed (var, set);
7973 return slot;
7976 /* Delete the part of variable's location from dataflow set SET. The
7977 variable part is specified by variable's declaration or value DV
7978 and offset OFFSET and the part's location by LOC. */
7980 static void
7981 delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
7982 HOST_WIDE_INT offset)
7984 variable_def **slot = shared_hash_find_slot_noinsert (set->vars, dv);
7985 if (!slot)
7986 return;
7988 delete_slot_part (set, loc, slot, offset);
7992 /* Structure for passing some other parameters to function
7993 vt_expand_loc_callback. */
7994 struct expand_loc_callback_data
7996 /* The variables and values active at this point. */
7997 variable_table_type *vars;
7999 /* Stack of values and debug_exprs under expansion, and their
8000 children. */
8001 auto_vec<rtx, 4> expanding;
8003 /* Stack of values and debug_exprs whose expansion hit recursion
8004 cycles. They will have VALUE_RECURSED_INTO marked when added to
8005 this list. This flag will be cleared if any of its dependencies
8006 resolves to a valid location. So, if the flag remains set at the
8007 end of the search, we know no valid location for this one can
8008 possibly exist. */
8009 auto_vec<rtx, 4> pending;
8011 /* The maximum depth among the sub-expressions under expansion.
8012 Zero indicates no expansion so far. */
8013 expand_depth depth;
8016 /* Allocate the one-part auxiliary data structure for VAR, with enough
8017 room for COUNT dependencies. */
8019 static void
8020 loc_exp_dep_alloc (variable var, int count)
8022 size_t allocsize;
8024 gcc_checking_assert (var->onepart);
8026 /* We can be called with COUNT == 0 to allocate the data structure
8027 without any dependencies, e.g. for the backlinks only. However,
8028 if we are specifying a COUNT, then the dependency list must have
8029 been emptied before. It would be possible to adjust pointers or
8030 force it empty here, but this is better done at an earlier point
8031 in the algorithm, so we instead leave an assertion to catch
8032 errors. */
8033 gcc_checking_assert (!count
8034 || VAR_LOC_DEP_VEC (var) == NULL
8035 || VAR_LOC_DEP_VEC (var)->is_empty ());
8037 if (VAR_LOC_1PAUX (var) && VAR_LOC_DEP_VEC (var)->space (count))
8038 return;
8040 allocsize = offsetof (struct onepart_aux, deps)
8041 + vec<loc_exp_dep, va_heap, vl_embed>::embedded_size (count);
8043 if (VAR_LOC_1PAUX (var))
8045 VAR_LOC_1PAUX (var) = XRESIZEVAR (struct onepart_aux,
8046 VAR_LOC_1PAUX (var), allocsize);
8047 /* If the reallocation moves the onepaux structure, the
8048 back-pointer to BACKLINKS in the first list member will still
8049 point to its old location. Adjust it. */
8050 if (VAR_LOC_DEP_LST (var))
8051 VAR_LOC_DEP_LST (var)->pprev = VAR_LOC_DEP_LSTP (var);
8053 else
8055 VAR_LOC_1PAUX (var) = XNEWVAR (struct onepart_aux, allocsize);
8056 *VAR_LOC_DEP_LSTP (var) = NULL;
8057 VAR_LOC_FROM (var) = NULL;
8058 VAR_LOC_DEPTH (var).complexity = 0;
8059 VAR_LOC_DEPTH (var).entryvals = 0;
8061 VAR_LOC_DEP_VEC (var)->embedded_init (count);
8064 /* Remove all entries from the vector of active dependencies of VAR,
8065 removing them from the back-links lists too. */
8067 static void
8068 loc_exp_dep_clear (variable var)
8070 while (VAR_LOC_DEP_VEC (var) && !VAR_LOC_DEP_VEC (var)->is_empty ())
8072 loc_exp_dep *led = &VAR_LOC_DEP_VEC (var)->last ();
8073 if (led->next)
8074 led->next->pprev = led->pprev;
8075 if (led->pprev)
8076 *led->pprev = led->next;
8077 VAR_LOC_DEP_VEC (var)->pop ();
8081 /* Insert an active dependency from VAR on X to the vector of
8082 dependencies, and add the corresponding back-link to X's list of
8083 back-links in VARS. */
8085 static void
8086 loc_exp_insert_dep (variable var, rtx x, variable_table_type *vars)
8088 decl_or_value dv;
8089 variable xvar;
8090 loc_exp_dep *led;
8092 dv = dv_from_rtx (x);
8094 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8095 an additional look up? */
8096 xvar = vars->find_with_hash (dv, dv_htab_hash (dv));
8098 if (!xvar)
8100 xvar = variable_from_dropped (dv, NO_INSERT);
8101 gcc_checking_assert (xvar);
8104 /* No point in adding the same backlink more than once. This may
8105 arise if say the same value appears in two complex expressions in
8106 the same loc_list, or even more than once in a single
8107 expression. */
8108 if (VAR_LOC_DEP_LST (xvar) && VAR_LOC_DEP_LST (xvar)->dv == var->dv)
8109 return;
8111 if (var->onepart == NOT_ONEPART)
8112 led = (loc_exp_dep *) pool_alloc (loc_exp_dep_pool);
8113 else
8115 loc_exp_dep empty;
8116 memset (&empty, 0, sizeof (empty));
8117 VAR_LOC_DEP_VEC (var)->quick_push (empty);
8118 led = &VAR_LOC_DEP_VEC (var)->last ();
8120 led->dv = var->dv;
8121 led->value = x;
8123 loc_exp_dep_alloc (xvar, 0);
8124 led->pprev = VAR_LOC_DEP_LSTP (xvar);
8125 led->next = *led->pprev;
8126 if (led->next)
8127 led->next->pprev = &led->next;
8128 *led->pprev = led;
8131 /* Create active dependencies of VAR on COUNT values starting at
8132 VALUE, and corresponding back-links to the entries in VARS. Return
8133 true if we found any pending-recursion results. */
8135 static bool
8136 loc_exp_dep_set (variable var, rtx result, rtx *value, int count,
8137 variable_table_type *vars)
8139 bool pending_recursion = false;
8141 gcc_checking_assert (VAR_LOC_DEP_VEC (var) == NULL
8142 || VAR_LOC_DEP_VEC (var)->is_empty ());
8144 /* Set up all dependencies from last_child (as set up at the end of
8145 the loop above) to the end. */
8146 loc_exp_dep_alloc (var, count);
8148 while (count--)
8150 rtx x = *value++;
8152 if (!pending_recursion)
8153 pending_recursion = !result && VALUE_RECURSED_INTO (x);
8155 loc_exp_insert_dep (var, x, vars);
8158 return pending_recursion;
8161 /* Notify the back-links of IVAR that are pending recursion that we
8162 have found a non-NIL value for it, so they are cleared for another
8163 attempt to compute a current location. */
8165 static void
8166 notify_dependents_of_resolved_value (variable ivar, variable_table_type *vars)
8168 loc_exp_dep *led, *next;
8170 for (led = VAR_LOC_DEP_LST (ivar); led; led = next)
8172 decl_or_value dv = led->dv;
8173 variable var;
8175 next = led->next;
8177 if (dv_is_value_p (dv))
8179 rtx value = dv_as_value (dv);
8181 /* If we have already resolved it, leave it alone. */
8182 if (!VALUE_RECURSED_INTO (value))
8183 continue;
8185 /* Check that VALUE_RECURSED_INTO, true from the test above,
8186 implies NO_LOC_P. */
8187 gcc_checking_assert (NO_LOC_P (value));
8189 /* We won't notify variables that are being expanded,
8190 because their dependency list is cleared before
8191 recursing. */
8192 NO_LOC_P (value) = false;
8193 VALUE_RECURSED_INTO (value) = false;
8195 gcc_checking_assert (dv_changed_p (dv));
8197 else
8199 gcc_checking_assert (dv_onepart_p (dv) != NOT_ONEPART);
8200 if (!dv_changed_p (dv))
8201 continue;
8204 var = vars->find_with_hash (dv, dv_htab_hash (dv));
8206 if (!var)
8207 var = variable_from_dropped (dv, NO_INSERT);
8209 if (var)
8210 notify_dependents_of_resolved_value (var, vars);
8212 if (next)
8213 next->pprev = led->pprev;
8214 if (led->pprev)
8215 *led->pprev = next;
8216 led->next = NULL;
8217 led->pprev = NULL;
8221 static rtx vt_expand_loc_callback (rtx x, bitmap regs,
8222 int max_depth, void *data);
8224 /* Return the combined depth, when one sub-expression evaluated to
8225 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8227 static inline expand_depth
8228 update_depth (expand_depth saved_depth, expand_depth best_depth)
8230 /* If we didn't find anything, stick with what we had. */
8231 if (!best_depth.complexity)
8232 return saved_depth;
8234 /* If we found hadn't found anything, use the depth of the current
8235 expression. Do NOT add one extra level, we want to compute the
8236 maximum depth among sub-expressions. We'll increment it later,
8237 if appropriate. */
8238 if (!saved_depth.complexity)
8239 return best_depth;
8241 /* Combine the entryval count so that regardless of which one we
8242 return, the entryval count is accurate. */
8243 best_depth.entryvals = saved_depth.entryvals
8244 = best_depth.entryvals + saved_depth.entryvals;
8246 if (saved_depth.complexity < best_depth.complexity)
8247 return best_depth;
8248 else
8249 return saved_depth;
8252 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8253 DATA for cselib expand callback. If PENDRECP is given, indicate in
8254 it whether any sub-expression couldn't be fully evaluated because
8255 it is pending recursion resolution. */
8257 static inline rtx
8258 vt_expand_var_loc_chain (variable var, bitmap regs, void *data, bool *pendrecp)
8260 struct expand_loc_callback_data *elcd
8261 = (struct expand_loc_callback_data *) data;
8262 location_chain loc, next;
8263 rtx result = NULL;
8264 int first_child, result_first_child, last_child;
8265 bool pending_recursion;
8266 rtx loc_from = NULL;
8267 struct elt_loc_list *cloc = NULL;
8268 expand_depth depth = { 0, 0 }, saved_depth = elcd->depth;
8269 int wanted_entryvals, found_entryvals = 0;
8271 /* Clear all backlinks pointing at this, so that we're not notified
8272 while we're active. */
8273 loc_exp_dep_clear (var);
8275 retry:
8276 if (var->onepart == ONEPART_VALUE)
8278 cselib_val *val = CSELIB_VAL_PTR (dv_as_value (var->dv));
8280 gcc_checking_assert (cselib_preserved_value_p (val));
8282 cloc = val->locs;
8285 first_child = result_first_child = last_child
8286 = elcd->expanding.length ();
8288 wanted_entryvals = found_entryvals;
8290 /* Attempt to expand each available location in turn. */
8291 for (next = loc = var->n_var_parts ? var->var_part[0].loc_chain : NULL;
8292 loc || cloc; loc = next)
8294 result_first_child = last_child;
8296 if (!loc)
8298 loc_from = cloc->loc;
8299 next = loc;
8300 cloc = cloc->next;
8301 if (unsuitable_loc (loc_from))
8302 continue;
8304 else
8306 loc_from = loc->loc;
8307 next = loc->next;
8310 gcc_checking_assert (!unsuitable_loc (loc_from));
8312 elcd->depth.complexity = elcd->depth.entryvals = 0;
8313 result = cselib_expand_value_rtx_cb (loc_from, regs, EXPR_DEPTH,
8314 vt_expand_loc_callback, data);
8315 last_child = elcd->expanding.length ();
8317 if (result)
8319 depth = elcd->depth;
8321 gcc_checking_assert (depth.complexity
8322 || result_first_child == last_child);
8324 if (last_child - result_first_child != 1)
8326 if (!depth.complexity && GET_CODE (result) == ENTRY_VALUE)
8327 depth.entryvals++;
8328 depth.complexity++;
8331 if (depth.complexity <= EXPR_USE_DEPTH)
8333 if (depth.entryvals <= wanted_entryvals)
8334 break;
8335 else if (!found_entryvals || depth.entryvals < found_entryvals)
8336 found_entryvals = depth.entryvals;
8339 result = NULL;
8342 /* Set it up in case we leave the loop. */
8343 depth.complexity = depth.entryvals = 0;
8344 loc_from = NULL;
8345 result_first_child = first_child;
8348 if (!loc_from && wanted_entryvals < found_entryvals)
8350 /* We found entries with ENTRY_VALUEs and skipped them. Since
8351 we could not find any expansions without ENTRY_VALUEs, but we
8352 found at least one with them, go back and get an entry with
8353 the minimum number ENTRY_VALUE count that we found. We could
8354 avoid looping, but since each sub-loc is already resolved,
8355 the re-expansion should be trivial. ??? Should we record all
8356 attempted locs as dependencies, so that we retry the
8357 expansion should any of them change, in the hope it can give
8358 us a new entry without an ENTRY_VALUE? */
8359 elcd->expanding.truncate (first_child);
8360 goto retry;
8363 /* Register all encountered dependencies as active. */
8364 pending_recursion = loc_exp_dep_set
8365 (var, result, elcd->expanding.address () + result_first_child,
8366 last_child - result_first_child, elcd->vars);
8368 elcd->expanding.truncate (first_child);
8370 /* Record where the expansion came from. */
8371 gcc_checking_assert (!result || !pending_recursion);
8372 VAR_LOC_FROM (var) = loc_from;
8373 VAR_LOC_DEPTH (var) = depth;
8375 gcc_checking_assert (!depth.complexity == !result);
8377 elcd->depth = update_depth (saved_depth, depth);
8379 /* Indicate whether any of the dependencies are pending recursion
8380 resolution. */
8381 if (pendrecp)
8382 *pendrecp = pending_recursion;
8384 if (!pendrecp || !pending_recursion)
8385 var->var_part[0].cur_loc = result;
8387 return result;
8390 /* Callback for cselib_expand_value, that looks for expressions
8391 holding the value in the var-tracking hash tables. Return X for
8392 standard processing, anything else is to be used as-is. */
8394 static rtx
8395 vt_expand_loc_callback (rtx x, bitmap regs,
8396 int max_depth ATTRIBUTE_UNUSED,
8397 void *data)
8399 struct expand_loc_callback_data *elcd
8400 = (struct expand_loc_callback_data *) data;
8401 decl_or_value dv;
8402 variable var;
8403 rtx result, subreg;
8404 bool pending_recursion = false;
8405 bool from_empty = false;
8407 switch (GET_CODE (x))
8409 case SUBREG:
8410 subreg = cselib_expand_value_rtx_cb (SUBREG_REG (x), regs,
8411 EXPR_DEPTH,
8412 vt_expand_loc_callback, data);
8414 if (!subreg)
8415 return NULL;
8417 result = simplify_gen_subreg (GET_MODE (x), subreg,
8418 GET_MODE (SUBREG_REG (x)),
8419 SUBREG_BYTE (x));
8421 /* Invalid SUBREGs are ok in debug info. ??? We could try
8422 alternate expansions for the VALUE as well. */
8423 if (!result)
8424 result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
8426 return result;
8428 case DEBUG_EXPR:
8429 case VALUE:
8430 dv = dv_from_rtx (x);
8431 break;
8433 default:
8434 return x;
8437 elcd->expanding.safe_push (x);
8439 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8440 gcc_checking_assert (!VALUE_RECURSED_INTO (x) || NO_LOC_P (x));
8442 if (NO_LOC_P (x))
8444 gcc_checking_assert (VALUE_RECURSED_INTO (x) || !dv_changed_p (dv));
8445 return NULL;
8448 var = elcd->vars->find_with_hash (dv, dv_htab_hash (dv));
8450 if (!var)
8452 from_empty = true;
8453 var = variable_from_dropped (dv, INSERT);
8456 gcc_checking_assert (var);
8458 if (!dv_changed_p (dv))
8460 gcc_checking_assert (!NO_LOC_P (x));
8461 gcc_checking_assert (var->var_part[0].cur_loc);
8462 gcc_checking_assert (VAR_LOC_1PAUX (var));
8463 gcc_checking_assert (VAR_LOC_1PAUX (var)->depth.complexity);
8465 elcd->depth = update_depth (elcd->depth, VAR_LOC_1PAUX (var)->depth);
8467 return var->var_part[0].cur_loc;
8470 VALUE_RECURSED_INTO (x) = true;
8471 /* This is tentative, but it makes some tests simpler. */
8472 NO_LOC_P (x) = true;
8474 gcc_checking_assert (var->n_var_parts == 1 || from_empty);
8476 result = vt_expand_var_loc_chain (var, regs, data, &pending_recursion);
8478 if (pending_recursion)
8480 gcc_checking_assert (!result);
8481 elcd->pending.safe_push (x);
8483 else
8485 NO_LOC_P (x) = !result;
8486 VALUE_RECURSED_INTO (x) = false;
8487 set_dv_changed (dv, false);
8489 if (result)
8490 notify_dependents_of_resolved_value (var, elcd->vars);
8493 return result;
8496 /* While expanding variables, we may encounter recursion cycles
8497 because of mutual (possibly indirect) dependencies between two
8498 particular variables (or values), say A and B. If we're trying to
8499 expand A when we get to B, which in turn attempts to expand A, if
8500 we can't find any other expansion for B, we'll add B to this
8501 pending-recursion stack, and tentatively return NULL for its
8502 location. This tentative value will be used for any other
8503 occurrences of B, unless A gets some other location, in which case
8504 it will notify B that it is worth another try at computing a
8505 location for it, and it will use the location computed for A then.
8506 At the end of the expansion, the tentative NULL locations become
8507 final for all members of PENDING that didn't get a notification.
8508 This function performs this finalization of NULL locations. */
8510 static void
8511 resolve_expansions_pending_recursion (vec<rtx, va_heap> *pending)
8513 while (!pending->is_empty ())
8515 rtx x = pending->pop ();
8516 decl_or_value dv;
8518 if (!VALUE_RECURSED_INTO (x))
8519 continue;
8521 gcc_checking_assert (NO_LOC_P (x));
8522 VALUE_RECURSED_INTO (x) = false;
8523 dv = dv_from_rtx (x);
8524 gcc_checking_assert (dv_changed_p (dv));
8525 set_dv_changed (dv, false);
8529 /* Initialize expand_loc_callback_data D with variable hash table V.
8530 It must be a macro because of alloca (vec stack). */
8531 #define INIT_ELCD(d, v) \
8532 do \
8534 (d).vars = (v); \
8535 (d).depth.complexity = (d).depth.entryvals = 0; \
8537 while (0)
8538 /* Finalize expand_loc_callback_data D, resolved to location L. */
8539 #define FINI_ELCD(d, l) \
8540 do \
8542 resolve_expansions_pending_recursion (&(d).pending); \
8543 (d).pending.release (); \
8544 (d).expanding.release (); \
8546 if ((l) && MEM_P (l)) \
8547 (l) = targetm.delegitimize_address (l); \
8549 while (0)
8551 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8552 equivalences in VARS, updating their CUR_LOCs in the process. */
8554 static rtx
8555 vt_expand_loc (rtx loc, variable_table_type *vars)
8557 struct expand_loc_callback_data data;
8558 rtx result;
8560 if (!MAY_HAVE_DEBUG_INSNS)
8561 return loc;
8563 INIT_ELCD (data, vars);
8565 result = cselib_expand_value_rtx_cb (loc, scratch_regs, EXPR_DEPTH,
8566 vt_expand_loc_callback, &data);
8568 FINI_ELCD (data, result);
8570 return result;
8573 /* Expand the one-part VARiable to a location, using the equivalences
8574 in VARS, updating their CUR_LOCs in the process. */
8576 static rtx
8577 vt_expand_1pvar (variable var, variable_table_type *vars)
8579 struct expand_loc_callback_data data;
8580 rtx loc;
8582 gcc_checking_assert (var->onepart && var->n_var_parts == 1);
8584 if (!dv_changed_p (var->dv))
8585 return var->var_part[0].cur_loc;
8587 INIT_ELCD (data, vars);
8589 loc = vt_expand_var_loc_chain (var, scratch_regs, &data, NULL);
8591 gcc_checking_assert (data.expanding.is_empty ());
8593 FINI_ELCD (data, loc);
8595 return loc;
8598 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8599 additional parameters: WHERE specifies whether the note shall be emitted
8600 before or after instruction INSN. */
8603 emit_note_insn_var_location (variable_def **varp, emit_note_data *data)
8605 variable var = *varp;
8606 rtx_insn *insn = data->insn;
8607 enum emit_note_where where = data->where;
8608 variable_table_type *vars = data->vars;
8609 rtx_note *note;
8610 rtx note_vl;
8611 int i, j, n_var_parts;
8612 bool complete;
8613 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
8614 HOST_WIDE_INT last_limit;
8615 tree type_size_unit;
8616 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
8617 rtx loc[MAX_VAR_PARTS];
8618 tree decl;
8619 location_chain lc;
8621 gcc_checking_assert (var->onepart == NOT_ONEPART
8622 || var->onepart == ONEPART_VDECL);
8624 decl = dv_as_decl (var->dv);
8626 complete = true;
8627 last_limit = 0;
8628 n_var_parts = 0;
8629 if (!var->onepart)
8630 for (i = 0; i < var->n_var_parts; i++)
8631 if (var->var_part[i].cur_loc == NULL && var->var_part[i].loc_chain)
8632 var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
8633 for (i = 0; i < var->n_var_parts; i++)
8635 machine_mode mode, wider_mode;
8636 rtx loc2;
8637 HOST_WIDE_INT offset;
8639 if (i == 0 && var->onepart)
8641 gcc_checking_assert (var->n_var_parts == 1);
8642 offset = 0;
8643 initialized = VAR_INIT_STATUS_INITIALIZED;
8644 loc2 = vt_expand_1pvar (var, vars);
8646 else
8648 if (last_limit < VAR_PART_OFFSET (var, i))
8650 complete = false;
8651 break;
8653 else if (last_limit > VAR_PART_OFFSET (var, i))
8654 continue;
8655 offset = VAR_PART_OFFSET (var, i);
8656 loc2 = var->var_part[i].cur_loc;
8657 if (loc2 && GET_CODE (loc2) == MEM
8658 && GET_CODE (XEXP (loc2, 0)) == VALUE)
8660 rtx depval = XEXP (loc2, 0);
8662 loc2 = vt_expand_loc (loc2, vars);
8664 if (loc2)
8665 loc_exp_insert_dep (var, depval, vars);
8667 if (!loc2)
8669 complete = false;
8670 continue;
8672 gcc_checking_assert (GET_CODE (loc2) != VALUE);
8673 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
8674 if (var->var_part[i].cur_loc == lc->loc)
8676 initialized = lc->init;
8677 break;
8679 gcc_assert (lc);
8682 offsets[n_var_parts] = offset;
8683 if (!loc2)
8685 complete = false;
8686 continue;
8688 loc[n_var_parts] = loc2;
8689 mode = GET_MODE (var->var_part[i].cur_loc);
8690 if (mode == VOIDmode && var->onepart)
8691 mode = DECL_MODE (decl);
8692 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
8694 /* Attempt to merge adjacent registers or memory. */
8695 wider_mode = GET_MODE_WIDER_MODE (mode);
8696 for (j = i + 1; j < var->n_var_parts; j++)
8697 if (last_limit <= VAR_PART_OFFSET (var, j))
8698 break;
8699 if (j < var->n_var_parts
8700 && wider_mode != VOIDmode
8701 && var->var_part[j].cur_loc
8702 && mode == GET_MODE (var->var_part[j].cur_loc)
8703 && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
8704 && last_limit == (var->onepart ? 0 : VAR_PART_OFFSET (var, j))
8705 && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
8706 && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
8708 rtx new_loc = NULL;
8710 if (REG_P (loc[n_var_parts])
8711 && hard_regno_nregs[REGNO (loc[n_var_parts])][mode] * 2
8712 == hard_regno_nregs[REGNO (loc[n_var_parts])][wider_mode]
8713 && end_hard_regno (mode, REGNO (loc[n_var_parts]))
8714 == REGNO (loc2))
8716 if (! WORDS_BIG_ENDIAN && ! BYTES_BIG_ENDIAN)
8717 new_loc = simplify_subreg (wider_mode, loc[n_var_parts],
8718 mode, 0);
8719 else if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
8720 new_loc = simplify_subreg (wider_mode, loc2, mode, 0);
8721 if (new_loc)
8723 if (!REG_P (new_loc)
8724 || REGNO (new_loc) != REGNO (loc[n_var_parts]))
8725 new_loc = NULL;
8726 else
8727 REG_ATTRS (new_loc) = REG_ATTRS (loc[n_var_parts]);
8730 else if (MEM_P (loc[n_var_parts])
8731 && GET_CODE (XEXP (loc2, 0)) == PLUS
8732 && REG_P (XEXP (XEXP (loc2, 0), 0))
8733 && CONST_INT_P (XEXP (XEXP (loc2, 0), 1)))
8735 if ((REG_P (XEXP (loc[n_var_parts], 0))
8736 && rtx_equal_p (XEXP (loc[n_var_parts], 0),
8737 XEXP (XEXP (loc2, 0), 0))
8738 && INTVAL (XEXP (XEXP (loc2, 0), 1))
8739 == GET_MODE_SIZE (mode))
8740 || (GET_CODE (XEXP (loc[n_var_parts], 0)) == PLUS
8741 && CONST_INT_P (XEXP (XEXP (loc[n_var_parts], 0), 1))
8742 && rtx_equal_p (XEXP (XEXP (loc[n_var_parts], 0), 0),
8743 XEXP (XEXP (loc2, 0), 0))
8744 && INTVAL (XEXP (XEXP (loc[n_var_parts], 0), 1))
8745 + GET_MODE_SIZE (mode)
8746 == INTVAL (XEXP (XEXP (loc2, 0), 1))))
8747 new_loc = adjust_address_nv (loc[n_var_parts],
8748 wider_mode, 0);
8751 if (new_loc)
8753 loc[n_var_parts] = new_loc;
8754 mode = wider_mode;
8755 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
8756 i = j;
8759 ++n_var_parts;
8761 type_size_unit = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8762 if ((unsigned HOST_WIDE_INT) last_limit < TREE_INT_CST_LOW (type_size_unit))
8763 complete = false;
8765 if (! flag_var_tracking_uninit)
8766 initialized = VAR_INIT_STATUS_INITIALIZED;
8768 note_vl = NULL_RTX;
8769 if (!complete)
8770 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, NULL_RTX, initialized);
8771 else if (n_var_parts == 1)
8773 rtx expr_list;
8775 if (offsets[0] || GET_CODE (loc[0]) == PARALLEL)
8776 expr_list = gen_rtx_EXPR_LIST (VOIDmode, loc[0], GEN_INT (offsets[0]));
8777 else
8778 expr_list = loc[0];
8780 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, expr_list, initialized);
8782 else if (n_var_parts)
8784 rtx parallel;
8786 for (i = 0; i < n_var_parts; i++)
8787 loc[i]
8788 = gen_rtx_EXPR_LIST (VOIDmode, loc[i], GEN_INT (offsets[i]));
8790 parallel = gen_rtx_PARALLEL (VOIDmode,
8791 gen_rtvec_v (n_var_parts, loc));
8792 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl,
8793 parallel, initialized);
8796 if (where != EMIT_NOTE_BEFORE_INSN)
8798 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8799 if (where == EMIT_NOTE_AFTER_CALL_INSN)
8800 NOTE_DURING_CALL_P (note) = true;
8802 else
8804 /* Make sure that the call related notes come first. */
8805 while (NEXT_INSN (insn)
8806 && NOTE_P (insn)
8807 && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8808 && NOTE_DURING_CALL_P (insn))
8809 || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
8810 insn = NEXT_INSN (insn);
8811 if (NOTE_P (insn)
8812 && ((NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
8813 && NOTE_DURING_CALL_P (insn))
8814 || NOTE_KIND (insn) == NOTE_INSN_CALL_ARG_LOCATION))
8815 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
8816 else
8817 note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
8819 NOTE_VAR_LOCATION (note) = note_vl;
8821 set_dv_changed (var->dv, false);
8822 gcc_assert (var->in_changed_variables);
8823 var->in_changed_variables = false;
8824 changed_variables->clear_slot (varp);
8826 /* Continue traversing the hash table. */
8827 return 1;
8830 /* While traversing changed_variables, push onto DATA (a stack of RTX
8831 values) entries that aren't user variables. */
8834 var_track_values_to_stack (variable_def **slot,
8835 vec<rtx, va_heap> *changed_values_stack)
8837 variable var = *slot;
8839 if (var->onepart == ONEPART_VALUE)
8840 changed_values_stack->safe_push (dv_as_value (var->dv));
8841 else if (var->onepart == ONEPART_DEXPR)
8842 changed_values_stack->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var->dv)));
8844 return 1;
8847 /* Remove from changed_variables the entry whose DV corresponds to
8848 value or debug_expr VAL. */
8849 static void
8850 remove_value_from_changed_variables (rtx val)
8852 decl_or_value dv = dv_from_rtx (val);
8853 variable_def **slot;
8854 variable var;
8856 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8857 NO_INSERT);
8858 var = *slot;
8859 var->in_changed_variables = false;
8860 changed_variables->clear_slot (slot);
8863 /* If VAL (a value or debug_expr) has backlinks to variables actively
8864 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8865 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8866 have dependencies of their own to notify. */
8868 static void
8869 notify_dependents_of_changed_value (rtx val, variable_table_type *htab,
8870 vec<rtx, va_heap> *changed_values_stack)
8872 variable_def **slot;
8873 variable var;
8874 loc_exp_dep *led;
8875 decl_or_value dv = dv_from_rtx (val);
8877 slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv),
8878 NO_INSERT);
8879 if (!slot)
8880 slot = htab->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT);
8881 if (!slot)
8882 slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv),
8883 NO_INSERT);
8884 var = *slot;
8886 while ((led = VAR_LOC_DEP_LST (var)))
8888 decl_or_value ldv = led->dv;
8889 variable ivar;
8891 /* Deactivate and remove the backlink, as it was “used up”. It
8892 makes no sense to attempt to notify the same entity again:
8893 either it will be recomputed and re-register an active
8894 dependency, or it will still have the changed mark. */
8895 if (led->next)
8896 led->next->pprev = led->pprev;
8897 if (led->pprev)
8898 *led->pprev = led->next;
8899 led->next = NULL;
8900 led->pprev = NULL;
8902 if (dv_changed_p (ldv))
8903 continue;
8905 switch (dv_onepart_p (ldv))
8907 case ONEPART_VALUE:
8908 case ONEPART_DEXPR:
8909 set_dv_changed (ldv, true);
8910 changed_values_stack->safe_push (dv_as_rtx (ldv));
8911 break;
8913 case ONEPART_VDECL:
8914 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8915 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar));
8916 variable_was_changed (ivar, NULL);
8917 break;
8919 case NOT_ONEPART:
8920 pool_free (loc_exp_dep_pool, led);
8921 ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv));
8922 if (ivar)
8924 int i = ivar->n_var_parts;
8925 while (i--)
8927 rtx loc = ivar->var_part[i].cur_loc;
8929 if (loc && GET_CODE (loc) == MEM
8930 && XEXP (loc, 0) == val)
8932 variable_was_changed (ivar, NULL);
8933 break;
8937 break;
8939 default:
8940 gcc_unreachable ();
8945 /* Take out of changed_variables any entries that don't refer to use
8946 variables. Back-propagate change notifications from values and
8947 debug_exprs to their active dependencies in HTAB or in
8948 CHANGED_VARIABLES. */
8950 static void
8951 process_changed_values (variable_table_type *htab)
8953 int i, n;
8954 rtx val;
8955 auto_vec<rtx, 20> changed_values_stack;
8957 /* Move values from changed_variables to changed_values_stack. */
8958 changed_variables
8959 ->traverse <vec<rtx, va_heap>*, var_track_values_to_stack>
8960 (&changed_values_stack);
8962 /* Back-propagate change notifications in values while popping
8963 them from the stack. */
8964 for (n = i = changed_values_stack.length ();
8965 i > 0; i = changed_values_stack.length ())
8967 val = changed_values_stack.pop ();
8968 notify_dependents_of_changed_value (val, htab, &changed_values_stack);
8970 /* This condition will hold when visiting each of the entries
8971 originally in changed_variables. We can't remove them
8972 earlier because this could drop the backlinks before we got a
8973 chance to use them. */
8974 if (i == n)
8976 remove_value_from_changed_variables (val);
8977 n--;
8982 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
8983 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
8984 the notes shall be emitted before of after instruction INSN. */
8986 static void
8987 emit_notes_for_changes (rtx_insn *insn, enum emit_note_where where,
8988 shared_hash vars)
8990 emit_note_data data;
8991 variable_table_type *htab = shared_hash_htab (vars);
8993 if (!changed_variables->elements ())
8994 return;
8996 if (MAY_HAVE_DEBUG_INSNS)
8997 process_changed_values (htab);
8999 data.insn = insn;
9000 data.where = where;
9001 data.vars = htab;
9003 changed_variables
9004 ->traverse <emit_note_data*, emit_note_insn_var_location> (&data);
9007 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9008 same variable in hash table DATA or is not there at all. */
9011 emit_notes_for_differences_1 (variable_def **slot, variable_table_type *new_vars)
9013 variable old_var, new_var;
9015 old_var = *slot;
9016 new_var = new_vars->find_with_hash (old_var->dv, dv_htab_hash (old_var->dv));
9018 if (!new_var)
9020 /* Variable has disappeared. */
9021 variable empty_var = NULL;
9023 if (old_var->onepart == ONEPART_VALUE
9024 || old_var->onepart == ONEPART_DEXPR)
9026 empty_var = variable_from_dropped (old_var->dv, NO_INSERT);
9027 if (empty_var)
9029 gcc_checking_assert (!empty_var->in_changed_variables);
9030 if (!VAR_LOC_1PAUX (old_var))
9032 VAR_LOC_1PAUX (old_var) = VAR_LOC_1PAUX (empty_var);
9033 VAR_LOC_1PAUX (empty_var) = NULL;
9035 else
9036 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var));
9040 if (!empty_var)
9042 empty_var = (variable) pool_alloc (onepart_pool (old_var->onepart));
9043 empty_var->dv = old_var->dv;
9044 empty_var->refcount = 0;
9045 empty_var->n_var_parts = 0;
9046 empty_var->onepart = old_var->onepart;
9047 empty_var->in_changed_variables = false;
9050 if (empty_var->onepart)
9052 /* Propagate the auxiliary data to (ultimately)
9053 changed_variables. */
9054 empty_var->var_part[0].loc_chain = NULL;
9055 empty_var->var_part[0].cur_loc = NULL;
9056 VAR_LOC_1PAUX (empty_var) = VAR_LOC_1PAUX (old_var);
9057 VAR_LOC_1PAUX (old_var) = NULL;
9059 variable_was_changed (empty_var, NULL);
9060 /* Continue traversing the hash table. */
9061 return 1;
9063 /* Update cur_loc and one-part auxiliary data, before new_var goes
9064 through variable_was_changed. */
9065 if (old_var != new_var && new_var->onepart)
9067 gcc_checking_assert (VAR_LOC_1PAUX (new_var) == NULL);
9068 VAR_LOC_1PAUX (new_var) = VAR_LOC_1PAUX (old_var);
9069 VAR_LOC_1PAUX (old_var) = NULL;
9070 new_var->var_part[0].cur_loc = old_var->var_part[0].cur_loc;
9072 if (variable_different_p (old_var, new_var))
9073 variable_was_changed (new_var, NULL);
9075 /* Continue traversing the hash table. */
9076 return 1;
9079 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9080 table DATA. */
9083 emit_notes_for_differences_2 (variable_def **slot, variable_table_type *old_vars)
9085 variable old_var, new_var;
9087 new_var = *slot;
9088 old_var = old_vars->find_with_hash (new_var->dv, dv_htab_hash (new_var->dv));
9089 if (!old_var)
9091 int i;
9092 for (i = 0; i < new_var->n_var_parts; i++)
9093 new_var->var_part[i].cur_loc = NULL;
9094 variable_was_changed (new_var, NULL);
9097 /* Continue traversing the hash table. */
9098 return 1;
9101 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9102 NEW_SET. */
9104 static void
9105 emit_notes_for_differences (rtx_insn *insn, dataflow_set *old_set,
9106 dataflow_set *new_set)
9108 shared_hash_htab (old_set->vars)
9109 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9110 (shared_hash_htab (new_set->vars));
9111 shared_hash_htab (new_set->vars)
9112 ->traverse <variable_table_type *, emit_notes_for_differences_2>
9113 (shared_hash_htab (old_set->vars));
9114 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
9117 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9119 static rtx_insn *
9120 next_non_note_insn_var_location (rtx_insn *insn)
9122 while (insn)
9124 insn = NEXT_INSN (insn);
9125 if (insn == 0
9126 || !NOTE_P (insn)
9127 || NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION)
9128 break;
9131 return insn;
9134 /* Emit the notes for changes of location parts in the basic block BB. */
9136 static void
9137 emit_notes_in_bb (basic_block bb, dataflow_set *set)
9139 unsigned int i;
9140 micro_operation *mo;
9142 dataflow_set_clear (set);
9143 dataflow_set_copy (set, &VTI (bb)->in);
9145 FOR_EACH_VEC_ELT (VTI (bb)->mos, i, mo)
9147 rtx_insn *insn = mo->insn;
9148 rtx_insn *next_insn = next_non_note_insn_var_location (insn);
9150 switch (mo->type)
9152 case MO_CALL:
9153 dataflow_set_clear_at_call (set);
9154 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
9156 rtx arguments = mo->u.loc, *p = &arguments;
9157 rtx_note *note;
9158 while (*p)
9160 XEXP (XEXP (*p, 0), 1)
9161 = vt_expand_loc (XEXP (XEXP (*p, 0), 1),
9162 shared_hash_htab (set->vars));
9163 /* If expansion is successful, keep it in the list. */
9164 if (XEXP (XEXP (*p, 0), 1))
9165 p = &XEXP (*p, 1);
9166 /* Otherwise, if the following item is data_value for it,
9167 drop it too too. */
9168 else if (XEXP (*p, 1)
9169 && REG_P (XEXP (XEXP (*p, 0), 0))
9170 && MEM_P (XEXP (XEXP (XEXP (*p, 1), 0), 0))
9171 && REG_P (XEXP (XEXP (XEXP (XEXP (*p, 1), 0), 0),
9173 && REGNO (XEXP (XEXP (*p, 0), 0))
9174 == REGNO (XEXP (XEXP (XEXP (XEXP (*p, 1), 0),
9175 0), 0)))
9176 *p = XEXP (XEXP (*p, 1), 1);
9177 /* Just drop this item. */
9178 else
9179 *p = XEXP (*p, 1);
9181 note = emit_note_after (NOTE_INSN_CALL_ARG_LOCATION, insn);
9182 NOTE_VAR_LOCATION (note) = arguments;
9184 break;
9186 case MO_USE:
9188 rtx loc = mo->u.loc;
9190 if (REG_P (loc))
9191 var_reg_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9192 else
9193 var_mem_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
9195 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9197 break;
9199 case MO_VAL_LOC:
9201 rtx loc = mo->u.loc;
9202 rtx val, vloc;
9203 tree var;
9205 if (GET_CODE (loc) == CONCAT)
9207 val = XEXP (loc, 0);
9208 vloc = XEXP (loc, 1);
9210 else
9212 val = NULL_RTX;
9213 vloc = loc;
9216 var = PAT_VAR_LOCATION_DECL (vloc);
9218 clobber_variable_part (set, NULL_RTX,
9219 dv_from_decl (var), 0, NULL_RTX);
9220 if (val)
9222 if (VAL_NEEDS_RESOLUTION (loc))
9223 val_resolve (set, val, PAT_VAR_LOCATION_LOC (vloc), insn);
9224 set_variable_part (set, val, dv_from_decl (var), 0,
9225 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9226 INSERT);
9228 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc)))
9229 set_variable_part (set, PAT_VAR_LOCATION_LOC (vloc),
9230 dv_from_decl (var), 0,
9231 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
9232 INSERT);
9234 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9236 break;
9238 case MO_VAL_USE:
9240 rtx loc = mo->u.loc;
9241 rtx val, vloc, uloc;
9243 vloc = uloc = XEXP (loc, 1);
9244 val = XEXP (loc, 0);
9246 if (GET_CODE (val) == CONCAT)
9248 uloc = XEXP (val, 1);
9249 val = XEXP (val, 0);
9252 if (VAL_NEEDS_RESOLUTION (loc))
9253 val_resolve (set, val, vloc, insn);
9254 else
9255 val_store (set, val, uloc, insn, false);
9257 if (VAL_HOLDS_TRACK_EXPR (loc))
9259 if (GET_CODE (uloc) == REG)
9260 var_reg_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9261 NULL);
9262 else if (GET_CODE (uloc) == MEM)
9263 var_mem_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
9264 NULL);
9267 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
9269 break;
9271 case MO_VAL_SET:
9273 rtx loc = mo->u.loc;
9274 rtx val, vloc, uloc;
9275 rtx dstv, srcv;
9277 vloc = loc;
9278 uloc = XEXP (vloc, 1);
9279 val = XEXP (vloc, 0);
9280 vloc = uloc;
9282 if (GET_CODE (uloc) == SET)
9284 dstv = SET_DEST (uloc);
9285 srcv = SET_SRC (uloc);
9287 else
9289 dstv = uloc;
9290 srcv = NULL;
9293 if (GET_CODE (val) == CONCAT)
9295 dstv = vloc = XEXP (val, 1);
9296 val = XEXP (val, 0);
9299 if (GET_CODE (vloc) == SET)
9301 srcv = SET_SRC (vloc);
9303 gcc_assert (val != srcv);
9304 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
9306 dstv = vloc = SET_DEST (vloc);
9308 if (VAL_NEEDS_RESOLUTION (loc))
9309 val_resolve (set, val, srcv, insn);
9311 else if (VAL_NEEDS_RESOLUTION (loc))
9313 gcc_assert (GET_CODE (uloc) == SET
9314 && GET_CODE (SET_SRC (uloc)) == REG);
9315 val_resolve (set, val, SET_SRC (uloc), insn);
9318 if (VAL_HOLDS_TRACK_EXPR (loc))
9320 if (VAL_EXPR_IS_CLOBBERED (loc))
9322 if (REG_P (uloc))
9323 var_reg_delete (set, uloc, true);
9324 else if (MEM_P (uloc))
9326 gcc_assert (MEM_P (dstv));
9327 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (uloc));
9328 var_mem_delete (set, dstv, true);
9331 else
9333 bool copied_p = VAL_EXPR_IS_COPIED (loc);
9334 rtx src = NULL, dst = uloc;
9335 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
9337 if (GET_CODE (uloc) == SET)
9339 src = SET_SRC (uloc);
9340 dst = SET_DEST (uloc);
9343 if (copied_p)
9345 status = find_src_status (set, src);
9347 src = find_src_set_src (set, src);
9350 if (REG_P (dst))
9351 var_reg_delete_and_set (set, dst, !copied_p,
9352 status, srcv);
9353 else if (MEM_P (dst))
9355 gcc_assert (MEM_P (dstv));
9356 gcc_assert (MEM_ATTRS (dstv) == MEM_ATTRS (dst));
9357 var_mem_delete_and_set (set, dstv, !copied_p,
9358 status, srcv);
9362 else if (REG_P (uloc))
9363 var_regno_delete (set, REGNO (uloc));
9364 else if (MEM_P (uloc))
9366 gcc_checking_assert (GET_CODE (vloc) == MEM);
9367 gcc_checking_assert (vloc == dstv);
9368 if (vloc != dstv)
9369 clobber_overlapping_mems (set, vloc);
9372 val_store (set, val, dstv, insn, true);
9374 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9375 set->vars);
9377 break;
9379 case MO_SET:
9381 rtx loc = mo->u.loc;
9382 rtx set_src = NULL;
9384 if (GET_CODE (loc) == SET)
9386 set_src = SET_SRC (loc);
9387 loc = SET_DEST (loc);
9390 if (REG_P (loc))
9391 var_reg_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9392 set_src);
9393 else
9394 var_mem_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
9395 set_src);
9397 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9398 set->vars);
9400 break;
9402 case MO_COPY:
9404 rtx loc = mo->u.loc;
9405 enum var_init_status src_status;
9406 rtx set_src = NULL;
9408 if (GET_CODE (loc) == SET)
9410 set_src = SET_SRC (loc);
9411 loc = SET_DEST (loc);
9414 src_status = find_src_status (set, set_src);
9415 set_src = find_src_set_src (set, set_src);
9417 if (REG_P (loc))
9418 var_reg_delete_and_set (set, loc, false, src_status, set_src);
9419 else
9420 var_mem_delete_and_set (set, loc, false, src_status, set_src);
9422 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9423 set->vars);
9425 break;
9427 case MO_USE_NO_VAR:
9429 rtx loc = mo->u.loc;
9431 if (REG_P (loc))
9432 var_reg_delete (set, loc, false);
9433 else
9434 var_mem_delete (set, loc, false);
9436 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
9438 break;
9440 case MO_CLOBBER:
9442 rtx loc = mo->u.loc;
9444 if (REG_P (loc))
9445 var_reg_delete (set, loc, true);
9446 else
9447 var_mem_delete (set, loc, true);
9449 emit_notes_for_changes (next_insn, EMIT_NOTE_BEFORE_INSN,
9450 set->vars);
9452 break;
9454 case MO_ADJUST:
9455 set->stack_adjust += mo->u.adjust;
9456 break;
9461 /* Emit notes for the whole function. */
9463 static void
9464 vt_emit_notes (void)
9466 basic_block bb;
9467 dataflow_set cur;
9469 gcc_assert (!changed_variables->elements ());
9471 /* Free memory occupied by the out hash tables, as they aren't used
9472 anymore. */
9473 FOR_EACH_BB_FN (bb, cfun)
9474 dataflow_set_clear (&VTI (bb)->out);
9476 /* Enable emitting notes by functions (mainly by set_variable_part and
9477 delete_variable_part). */
9478 emit_notes = true;
9480 if (MAY_HAVE_DEBUG_INSNS)
9482 dropped_values = new variable_table_type (cselib_get_next_uid () * 2);
9483 loc_exp_dep_pool = create_alloc_pool ("loc_exp_dep pool",
9484 sizeof (loc_exp_dep), 64);
9487 dataflow_set_init (&cur);
9489 FOR_EACH_BB_FN (bb, cfun)
9491 /* Emit the notes for changes of variable locations between two
9492 subsequent basic blocks. */
9493 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
9495 if (MAY_HAVE_DEBUG_INSNS)
9496 local_get_addr_cache = new hash_map<rtx, rtx>;
9498 /* Emit the notes for the changes in the basic block itself. */
9499 emit_notes_in_bb (bb, &cur);
9501 if (MAY_HAVE_DEBUG_INSNS)
9502 delete local_get_addr_cache;
9503 local_get_addr_cache = NULL;
9505 /* Free memory occupied by the in hash table, we won't need it
9506 again. */
9507 dataflow_set_clear (&VTI (bb)->in);
9509 #ifdef ENABLE_CHECKING
9510 shared_hash_htab (cur.vars)
9511 ->traverse <variable_table_type *, emit_notes_for_differences_1>
9512 (shared_hash_htab (empty_shared_hash));
9513 #endif
9514 dataflow_set_destroy (&cur);
9516 if (MAY_HAVE_DEBUG_INSNS)
9517 delete dropped_values;
9518 dropped_values = NULL;
9520 emit_notes = false;
9523 /* If there is a declaration and offset associated with register/memory RTL
9524 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9526 static bool
9527 vt_get_decl_and_offset (rtx rtl, tree *declp, HOST_WIDE_INT *offsetp)
9529 if (REG_P (rtl))
9531 if (REG_ATTRS (rtl))
9533 *declp = REG_EXPR (rtl);
9534 *offsetp = REG_OFFSET (rtl);
9535 return true;
9538 else if (GET_CODE (rtl) == PARALLEL)
9540 tree decl = NULL_TREE;
9541 HOST_WIDE_INT offset = MAX_VAR_PARTS;
9542 int len = XVECLEN (rtl, 0), i;
9544 for (i = 0; i < len; i++)
9546 rtx reg = XEXP (XVECEXP (rtl, 0, i), 0);
9547 if (!REG_P (reg) || !REG_ATTRS (reg))
9548 break;
9549 if (!decl)
9550 decl = REG_EXPR (reg);
9551 if (REG_EXPR (reg) != decl)
9552 break;
9553 if (REG_OFFSET (reg) < offset)
9554 offset = REG_OFFSET (reg);
9557 if (i == len)
9559 *declp = decl;
9560 *offsetp = offset;
9561 return true;
9564 else if (MEM_P (rtl))
9566 if (MEM_ATTRS (rtl))
9568 *declp = MEM_EXPR (rtl);
9569 *offsetp = INT_MEM_OFFSET (rtl);
9570 return true;
9573 return false;
9576 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9577 of VAL. */
9579 static void
9580 record_entry_value (cselib_val *val, rtx rtl)
9582 rtx ev = gen_rtx_ENTRY_VALUE (GET_MODE (rtl));
9584 ENTRY_VALUE_EXP (ev) = rtl;
9586 cselib_add_permanent_equiv (val, ev, get_insns ());
9589 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9591 static void
9592 vt_add_function_parameter (tree parm)
9594 rtx decl_rtl = DECL_RTL_IF_SET (parm);
9595 rtx incoming = DECL_INCOMING_RTL (parm);
9596 tree decl;
9597 machine_mode mode;
9598 HOST_WIDE_INT offset;
9599 dataflow_set *out;
9600 decl_or_value dv;
9602 if (TREE_CODE (parm) != PARM_DECL)
9603 return;
9605 if (!decl_rtl || !incoming)
9606 return;
9608 if (GET_MODE (decl_rtl) == BLKmode || GET_MODE (incoming) == BLKmode)
9609 return;
9611 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9612 rewrite the incoming location of parameters passed on the stack
9613 into MEMs based on the argument pointer, so that incoming doesn't
9614 depend on a pseudo. */
9615 if (MEM_P (incoming)
9616 && (XEXP (incoming, 0) == crtl->args.internal_arg_pointer
9617 || (GET_CODE (XEXP (incoming, 0)) == PLUS
9618 && XEXP (XEXP (incoming, 0), 0)
9619 == crtl->args.internal_arg_pointer
9620 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
9622 HOST_WIDE_INT off = -FIRST_PARM_OFFSET (current_function_decl);
9623 if (GET_CODE (XEXP (incoming, 0)) == PLUS)
9624 off += INTVAL (XEXP (XEXP (incoming, 0), 1));
9625 incoming
9626 = replace_equiv_address_nv (incoming,
9627 plus_constant (Pmode,
9628 arg_pointer_rtx, off));
9631 #ifdef HAVE_window_save
9632 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9633 If the target machine has an explicit window save instruction, the
9634 actual entry value is the corresponding OUTGOING_REGNO instead. */
9635 if (HAVE_window_save && !crtl->uses_only_leaf_regs)
9637 if (REG_P (incoming)
9638 && HARD_REGISTER_P (incoming)
9639 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
9641 parm_reg_t p;
9642 p.incoming = incoming;
9643 incoming
9644 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
9645 OUTGOING_REGNO (REGNO (incoming)), 0);
9646 p.outgoing = incoming;
9647 vec_safe_push (windowed_parm_regs, p);
9649 else if (GET_CODE (incoming) == PARALLEL)
9651 rtx outgoing
9652 = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (XVECLEN (incoming, 0)));
9653 int i;
9655 for (i = 0; i < XVECLEN (incoming, 0); i++)
9657 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9658 parm_reg_t p;
9659 p.incoming = reg;
9660 reg = gen_rtx_REG_offset (reg, GET_MODE (reg),
9661 OUTGOING_REGNO (REGNO (reg)), 0);
9662 p.outgoing = reg;
9663 XVECEXP (outgoing, 0, i)
9664 = gen_rtx_EXPR_LIST (VOIDmode, reg,
9665 XEXP (XVECEXP (incoming, 0, i), 1));
9666 vec_safe_push (windowed_parm_regs, p);
9669 incoming = outgoing;
9671 else if (MEM_P (incoming)
9672 && REG_P (XEXP (incoming, 0))
9673 && HARD_REGISTER_P (XEXP (incoming, 0)))
9675 rtx reg = XEXP (incoming, 0);
9676 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
9678 parm_reg_t p;
9679 p.incoming = reg;
9680 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
9681 p.outgoing = reg;
9682 vec_safe_push (windowed_parm_regs, p);
9683 incoming = replace_equiv_address_nv (incoming, reg);
9687 #endif
9689 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
9691 if (MEM_P (incoming))
9693 /* This means argument is passed by invisible reference. */
9694 offset = 0;
9695 decl = parm;
9697 else
9699 if (!vt_get_decl_and_offset (decl_rtl, &decl, &offset))
9700 return;
9701 offset += byte_lowpart_offset (GET_MODE (incoming),
9702 GET_MODE (decl_rtl));
9706 if (!decl)
9707 return;
9709 if (parm != decl)
9711 /* If that DECL_RTL wasn't a pseudo that got spilled to
9712 memory, bail out. Otherwise, the spill slot sharing code
9713 will force the memory to reference spill_slot_decl (%sfp),
9714 so we don't match above. That's ok, the pseudo must have
9715 referenced the entire parameter, so just reset OFFSET. */
9716 if (decl != get_spill_slot_decl (false))
9717 return;
9718 offset = 0;
9721 if (!track_loc_p (incoming, parm, offset, false, &mode, &offset))
9722 return;
9724 out = &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->out;
9726 dv = dv_from_decl (parm);
9728 if (target_for_debug_bind (parm)
9729 /* We can't deal with these right now, because this kind of
9730 variable is single-part. ??? We could handle parallels
9731 that describe multiple locations for the same single
9732 value, but ATM we don't. */
9733 && GET_CODE (incoming) != PARALLEL)
9735 cselib_val *val;
9736 rtx lowpart;
9738 /* ??? We shouldn't ever hit this, but it may happen because
9739 arguments passed by invisible reference aren't dealt with
9740 above: incoming-rtl will have Pmode rather than the
9741 expected mode for the type. */
9742 if (offset)
9743 return;
9745 lowpart = var_lowpart (mode, incoming);
9746 if (!lowpart)
9747 return;
9749 val = cselib_lookup_from_insn (lowpart, mode, true,
9750 VOIDmode, get_insns ());
9752 /* ??? Float-typed values in memory are not handled by
9753 cselib. */
9754 if (val)
9756 preserve_value (val);
9757 set_variable_part (out, val->val_rtx, dv, offset,
9758 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9759 dv = dv_from_value (val->val_rtx);
9762 if (MEM_P (incoming))
9764 val = cselib_lookup_from_insn (XEXP (incoming, 0), mode, true,
9765 VOIDmode, get_insns ());
9766 if (val)
9768 preserve_value (val);
9769 incoming = replace_equiv_address_nv (incoming, val->val_rtx);
9774 if (REG_P (incoming))
9776 incoming = var_lowpart (mode, incoming);
9777 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
9778 attrs_list_insert (&out->regs[REGNO (incoming)], dv, offset,
9779 incoming);
9780 set_variable_part (out, incoming, dv, offset,
9781 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9782 if (dv_is_value_p (dv))
9784 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv)), incoming);
9785 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
9786 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm))))
9788 machine_mode indmode
9789 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm)));
9790 rtx mem = gen_rtx_MEM (indmode, incoming);
9791 cselib_val *val = cselib_lookup_from_insn (mem, indmode, true,
9792 VOIDmode,
9793 get_insns ());
9794 if (val)
9796 preserve_value (val);
9797 record_entry_value (val, mem);
9798 set_variable_part (out, mem, dv_from_value (val->val_rtx), 0,
9799 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9804 else if (GET_CODE (incoming) == PARALLEL && !dv_onepart_p (dv))
9806 int i;
9808 for (i = 0; i < XVECLEN (incoming, 0); i++)
9810 rtx reg = XEXP (XVECEXP (incoming, 0, i), 0);
9811 offset = REG_OFFSET (reg);
9812 gcc_assert (REGNO (reg) < FIRST_PSEUDO_REGISTER);
9813 attrs_list_insert (&out->regs[REGNO (reg)], dv, offset, reg);
9814 set_variable_part (out, reg, dv, offset,
9815 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9818 else if (MEM_P (incoming))
9820 incoming = var_lowpart (mode, incoming);
9821 set_variable_part (out, incoming, dv, offset,
9822 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
9826 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9828 static void
9829 vt_add_function_parameters (void)
9831 tree parm;
9833 for (parm = DECL_ARGUMENTS (current_function_decl);
9834 parm; parm = DECL_CHAIN (parm))
9835 if (!POINTER_BOUNDS_P (parm))
9836 vt_add_function_parameter (parm);
9838 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl)))
9840 tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
9842 if (TREE_CODE (vexpr) == INDIRECT_REF)
9843 vexpr = TREE_OPERAND (vexpr, 0);
9845 if (TREE_CODE (vexpr) == PARM_DECL
9846 && DECL_ARTIFICIAL (vexpr)
9847 && !DECL_IGNORED_P (vexpr)
9848 && DECL_NAMELESS (vexpr))
9849 vt_add_function_parameter (vexpr);
9853 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9854 ensure it isn't flushed during cselib_reset_table.
9855 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9856 has been eliminated. */
9858 static void
9859 vt_init_cfa_base (void)
9861 cselib_val *val;
9863 #ifdef FRAME_POINTER_CFA_OFFSET
9864 cfa_base_rtx = frame_pointer_rtx;
9865 cfa_base_offset = -FRAME_POINTER_CFA_OFFSET (current_function_decl);
9866 #else
9867 cfa_base_rtx = arg_pointer_rtx;
9868 cfa_base_offset = -ARG_POINTER_CFA_OFFSET (current_function_decl);
9869 #endif
9870 if (cfa_base_rtx == hard_frame_pointer_rtx
9871 || !fixed_regs[REGNO (cfa_base_rtx)])
9873 cfa_base_rtx = NULL_RTX;
9874 return;
9876 if (!MAY_HAVE_DEBUG_INSNS)
9877 return;
9879 /* Tell alias analysis that cfa_base_rtx should share
9880 find_base_term value with stack pointer or hard frame pointer. */
9881 if (!frame_pointer_needed)
9882 vt_equate_reg_base_value (cfa_base_rtx, stack_pointer_rtx);
9883 else if (!crtl->stack_realign_tried)
9884 vt_equate_reg_base_value (cfa_base_rtx, hard_frame_pointer_rtx);
9886 val = cselib_lookup_from_insn (cfa_base_rtx, GET_MODE (cfa_base_rtx), 1,
9887 VOIDmode, get_insns ());
9888 preserve_value (val);
9889 cselib_preserve_cfa_base_value (val, REGNO (cfa_base_rtx));
9892 /* Allocate and initialize the data structures for variable tracking
9893 and parse the RTL to get the micro operations. */
9895 static bool
9896 vt_initialize (void)
9898 basic_block bb;
9899 HOST_WIDE_INT fp_cfa_offset = -1;
9901 alloc_aux_for_blocks (sizeof (struct variable_tracking_info_def));
9903 attrs_pool = create_alloc_pool ("attrs_def pool",
9904 sizeof (struct attrs_def), 1024);
9905 var_pool = create_alloc_pool ("variable_def pool",
9906 sizeof (struct variable_def)
9907 + (MAX_VAR_PARTS - 1)
9908 * sizeof (((variable)NULL)->var_part[0]), 64);
9909 loc_chain_pool = create_alloc_pool ("location_chain_def pool",
9910 sizeof (struct location_chain_def),
9911 1024);
9912 shared_hash_pool = create_alloc_pool ("shared_hash_def pool",
9913 sizeof (struct shared_hash_def), 256);
9914 empty_shared_hash = (shared_hash) pool_alloc (shared_hash_pool);
9915 empty_shared_hash->refcount = 1;
9916 empty_shared_hash->htab = new variable_table_type (1);
9917 changed_variables = new variable_table_type (10);
9919 /* Init the IN and OUT sets. */
9920 FOR_ALL_BB_FN (bb, cfun)
9922 VTI (bb)->visited = false;
9923 VTI (bb)->flooded = false;
9924 dataflow_set_init (&VTI (bb)->in);
9925 dataflow_set_init (&VTI (bb)->out);
9926 VTI (bb)->permp = NULL;
9929 if (MAY_HAVE_DEBUG_INSNS)
9931 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
9932 scratch_regs = BITMAP_ALLOC (NULL);
9933 valvar_pool = create_alloc_pool ("small variable_def pool",
9934 sizeof (struct variable_def), 256);
9935 preserved_values.create (256);
9936 global_get_addr_cache = new hash_map<rtx, rtx>;
9938 else
9940 scratch_regs = NULL;
9941 valvar_pool = NULL;
9942 global_get_addr_cache = NULL;
9945 if (MAY_HAVE_DEBUG_INSNS)
9947 rtx reg, expr;
9948 int ofst;
9949 cselib_val *val;
9951 #ifdef FRAME_POINTER_CFA_OFFSET
9952 reg = frame_pointer_rtx;
9953 ofst = FRAME_POINTER_CFA_OFFSET (current_function_decl);
9954 #else
9955 reg = arg_pointer_rtx;
9956 ofst = ARG_POINTER_CFA_OFFSET (current_function_decl);
9957 #endif
9959 ofst -= INCOMING_FRAME_SP_OFFSET;
9961 val = cselib_lookup_from_insn (reg, GET_MODE (reg), 1,
9962 VOIDmode, get_insns ());
9963 preserve_value (val);
9964 if (reg != hard_frame_pointer_rtx && fixed_regs[REGNO (reg)])
9965 cselib_preserve_cfa_base_value (val, REGNO (reg));
9966 expr = plus_constant (GET_MODE (stack_pointer_rtx),
9967 stack_pointer_rtx, -ofst);
9968 cselib_add_permanent_equiv (val, expr, get_insns ());
9970 if (ofst)
9972 val = cselib_lookup_from_insn (stack_pointer_rtx,
9973 GET_MODE (stack_pointer_rtx), 1,
9974 VOIDmode, get_insns ());
9975 preserve_value (val);
9976 expr = plus_constant (GET_MODE (reg), reg, ofst);
9977 cselib_add_permanent_equiv (val, expr, get_insns ());
9981 /* In order to factor out the adjustments made to the stack pointer or to
9982 the hard frame pointer and thus be able to use DW_OP_fbreg operations
9983 instead of individual location lists, we're going to rewrite MEMs based
9984 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
9985 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
9986 resp. arg_pointer_rtx. We can do this either when there is no frame
9987 pointer in the function and stack adjustments are consistent for all
9988 basic blocks or when there is a frame pointer and no stack realignment.
9989 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
9990 has been eliminated. */
9991 if (!frame_pointer_needed)
9993 rtx reg, elim;
9995 if (!vt_stack_adjustments ())
9996 return false;
9998 #ifdef FRAME_POINTER_CFA_OFFSET
9999 reg = frame_pointer_rtx;
10000 #else
10001 reg = arg_pointer_rtx;
10002 #endif
10003 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10004 if (elim != reg)
10006 if (GET_CODE (elim) == PLUS)
10007 elim = XEXP (elim, 0);
10008 if (elim == stack_pointer_rtx)
10009 vt_init_cfa_base ();
10012 else if (!crtl->stack_realign_tried)
10014 rtx reg, elim;
10016 #ifdef FRAME_POINTER_CFA_OFFSET
10017 reg = frame_pointer_rtx;
10018 fp_cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10019 #else
10020 reg = arg_pointer_rtx;
10021 fp_cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10022 #endif
10023 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10024 if (elim != reg)
10026 if (GET_CODE (elim) == PLUS)
10028 fp_cfa_offset -= INTVAL (XEXP (elim, 1));
10029 elim = XEXP (elim, 0);
10031 if (elim != hard_frame_pointer_rtx)
10032 fp_cfa_offset = -1;
10034 else
10035 fp_cfa_offset = -1;
10038 /* If the stack is realigned and a DRAP register is used, we're going to
10039 rewrite MEMs based on it representing incoming locations of parameters
10040 passed on the stack into MEMs based on the argument pointer. Although
10041 we aren't going to rewrite other MEMs, we still need to initialize the
10042 virtual CFA pointer in order to ensure that the argument pointer will
10043 be seen as a constant throughout the function.
10045 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10046 else if (stack_realign_drap)
10048 rtx reg, elim;
10050 #ifdef FRAME_POINTER_CFA_OFFSET
10051 reg = frame_pointer_rtx;
10052 #else
10053 reg = arg_pointer_rtx;
10054 #endif
10055 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10056 if (elim != reg)
10058 if (GET_CODE (elim) == PLUS)
10059 elim = XEXP (elim, 0);
10060 if (elim == hard_frame_pointer_rtx)
10061 vt_init_cfa_base ();
10065 hard_frame_pointer_adjustment = -1;
10067 vt_add_function_parameters ();
10069 FOR_EACH_BB_FN (bb, cfun)
10071 rtx_insn *insn;
10072 HOST_WIDE_INT pre, post = 0;
10073 basic_block first_bb, last_bb;
10075 if (MAY_HAVE_DEBUG_INSNS)
10077 cselib_record_sets_hook = add_with_sets;
10078 if (dump_file && (dump_flags & TDF_DETAILS))
10079 fprintf (dump_file, "first value: %i\n",
10080 cselib_get_next_uid ());
10083 first_bb = bb;
10084 for (;;)
10086 edge e;
10087 if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
10088 || ! single_pred_p (bb->next_bb))
10089 break;
10090 e = find_edge (bb, bb->next_bb);
10091 if (! e || (e->flags & EDGE_FALLTHRU) == 0)
10092 break;
10093 bb = bb->next_bb;
10095 last_bb = bb;
10097 /* Add the micro-operations to the vector. */
10098 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
10100 HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
10101 VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
10102 for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb));
10103 insn = NEXT_INSN (insn))
10105 if (INSN_P (insn))
10107 if (!frame_pointer_needed)
10109 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
10110 if (pre)
10112 micro_operation mo;
10113 mo.type = MO_ADJUST;
10114 mo.u.adjust = pre;
10115 mo.insn = insn;
10116 if (dump_file && (dump_flags & TDF_DETAILS))
10117 log_op_type (PATTERN (insn), bb, insn,
10118 MO_ADJUST, dump_file);
10119 VTI (bb)->mos.safe_push (mo);
10120 VTI (bb)->out.stack_adjust += pre;
10124 cselib_hook_called = false;
10125 adjust_insn (bb, insn);
10126 if (MAY_HAVE_DEBUG_INSNS)
10128 if (CALL_P (insn))
10129 prepare_call_arguments (bb, insn);
10130 cselib_process_insn (insn);
10131 if (dump_file && (dump_flags & TDF_DETAILS))
10133 print_rtl_single (dump_file, insn);
10134 dump_cselib_table (dump_file);
10137 if (!cselib_hook_called)
10138 add_with_sets (insn, 0, 0);
10139 cancel_changes (0);
10141 if (!frame_pointer_needed && post)
10143 micro_operation mo;
10144 mo.type = MO_ADJUST;
10145 mo.u.adjust = post;
10146 mo.insn = insn;
10147 if (dump_file && (dump_flags & TDF_DETAILS))
10148 log_op_type (PATTERN (insn), bb, insn,
10149 MO_ADJUST, dump_file);
10150 VTI (bb)->mos.safe_push (mo);
10151 VTI (bb)->out.stack_adjust += post;
10154 if (fp_cfa_offset != -1
10155 && hard_frame_pointer_adjustment == -1
10156 && fp_setter_insn (insn))
10158 vt_init_cfa_base ();
10159 hard_frame_pointer_adjustment = fp_cfa_offset;
10160 /* Disassociate sp from fp now. */
10161 if (MAY_HAVE_DEBUG_INSNS)
10163 cselib_val *v;
10164 cselib_invalidate_rtx (stack_pointer_rtx);
10165 v = cselib_lookup (stack_pointer_rtx, Pmode, 1,
10166 VOIDmode);
10167 if (v && !cselib_preserved_value_p (v))
10169 cselib_set_value_sp_based (v);
10170 preserve_value (v);
10176 gcc_assert (offset == VTI (bb)->out.stack_adjust);
10179 bb = last_bb;
10181 if (MAY_HAVE_DEBUG_INSNS)
10183 cselib_preserve_only_values ();
10184 cselib_reset_table (cselib_get_next_uid ());
10185 cselib_record_sets_hook = NULL;
10189 hard_frame_pointer_adjustment = -1;
10190 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flooded = true;
10191 cfa_base_rtx = NULL_RTX;
10192 return true;
10195 /* This is *not* reset after each function. It gives each
10196 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10197 a unique label number. */
10199 static int debug_label_num = 1;
10201 /* Get rid of all debug insns from the insn stream. */
10203 static void
10204 delete_debug_insns (void)
10206 basic_block bb;
10207 rtx_insn *insn, *next;
10209 if (!MAY_HAVE_DEBUG_INSNS)
10210 return;
10212 FOR_EACH_BB_FN (bb, cfun)
10214 FOR_BB_INSNS_SAFE (bb, insn, next)
10215 if (DEBUG_INSN_P (insn))
10217 tree decl = INSN_VAR_LOCATION_DECL (insn);
10218 if (TREE_CODE (decl) == LABEL_DECL
10219 && DECL_NAME (decl)
10220 && !DECL_RTL_SET_P (decl))
10222 PUT_CODE (insn, NOTE);
10223 NOTE_KIND (insn) = NOTE_INSN_DELETED_DEBUG_LABEL;
10224 NOTE_DELETED_LABEL_NAME (insn)
10225 = IDENTIFIER_POINTER (DECL_NAME (decl));
10226 SET_DECL_RTL (decl, insn);
10227 CODE_LABEL_NUMBER (insn) = debug_label_num++;
10229 else
10230 delete_insn (insn);
10235 /* Run a fast, BB-local only version of var tracking, to take care of
10236 information that we don't do global analysis on, such that not all
10237 information is lost. If SKIPPED holds, we're skipping the global
10238 pass entirely, so we should try to use information it would have
10239 handled as well.. */
10241 static void
10242 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
10244 /* ??? Just skip it all for now. */
10245 delete_debug_insns ();
10248 /* Free the data structures needed for variable tracking. */
10250 static void
10251 vt_finalize (void)
10253 basic_block bb;
10255 FOR_EACH_BB_FN (bb, cfun)
10257 VTI (bb)->mos.release ();
10260 FOR_ALL_BB_FN (bb, cfun)
10262 dataflow_set_destroy (&VTI (bb)->in);
10263 dataflow_set_destroy (&VTI (bb)->out);
10264 if (VTI (bb)->permp)
10266 dataflow_set_destroy (VTI (bb)->permp);
10267 XDELETE (VTI (bb)->permp);
10270 free_aux_for_blocks ();
10271 delete empty_shared_hash->htab;
10272 empty_shared_hash->htab = NULL;
10273 delete changed_variables;
10274 changed_variables = NULL;
10275 free_alloc_pool (attrs_pool);
10276 free_alloc_pool (var_pool);
10277 free_alloc_pool (loc_chain_pool);
10278 free_alloc_pool (shared_hash_pool);
10280 if (MAY_HAVE_DEBUG_INSNS)
10282 if (global_get_addr_cache)
10283 delete global_get_addr_cache;
10284 global_get_addr_cache = NULL;
10285 if (loc_exp_dep_pool)
10286 free_alloc_pool (loc_exp_dep_pool);
10287 loc_exp_dep_pool = NULL;
10288 free_alloc_pool (valvar_pool);
10289 preserved_values.release ();
10290 cselib_finish ();
10291 BITMAP_FREE (scratch_regs);
10292 scratch_regs = NULL;
10295 #ifdef HAVE_window_save
10296 vec_free (windowed_parm_regs);
10297 #endif
10299 if (vui_vec)
10300 XDELETEVEC (vui_vec);
10301 vui_vec = NULL;
10302 vui_allocated = 0;
10305 /* The entry point to variable tracking pass. */
10307 static inline unsigned int
10308 variable_tracking_main_1 (void)
10310 bool success;
10312 if (flag_var_tracking_assignments < 0
10313 /* Var-tracking right now assumes the IR doesn't contain
10314 any pseudos at this point. */
10315 || targetm.no_register_allocation)
10317 delete_debug_insns ();
10318 return 0;
10321 if (n_basic_blocks_for_fn (cfun) > 500 &&
10322 n_edges_for_fn (cfun) / n_basic_blocks_for_fn (cfun) >= 20)
10324 vt_debug_insns_local (true);
10325 return 0;
10328 mark_dfs_back_edges ();
10329 if (!vt_initialize ())
10331 vt_finalize ();
10332 vt_debug_insns_local (true);
10333 return 0;
10336 success = vt_find_locations ();
10338 if (!success && flag_var_tracking_assignments > 0)
10340 vt_finalize ();
10342 delete_debug_insns ();
10344 /* This is later restored by our caller. */
10345 flag_var_tracking_assignments = 0;
10347 success = vt_initialize ();
10348 gcc_assert (success);
10350 success = vt_find_locations ();
10353 if (!success)
10355 vt_finalize ();
10356 vt_debug_insns_local (false);
10357 return 0;
10360 if (dump_file && (dump_flags & TDF_DETAILS))
10362 dump_dataflow_sets ();
10363 dump_reg_info (dump_file);
10364 dump_flow_info (dump_file, dump_flags);
10367 timevar_push (TV_VAR_TRACKING_EMIT);
10368 vt_emit_notes ();
10369 timevar_pop (TV_VAR_TRACKING_EMIT);
10371 vt_finalize ();
10372 vt_debug_insns_local (false);
10373 return 0;
10376 unsigned int
10377 variable_tracking_main (void)
10379 unsigned int ret;
10380 int save = flag_var_tracking_assignments;
10382 ret = variable_tracking_main_1 ();
10384 flag_var_tracking_assignments = save;
10386 return ret;
10389 namespace {
10391 const pass_data pass_data_variable_tracking =
10393 RTL_PASS, /* type */
10394 "vartrack", /* name */
10395 OPTGROUP_NONE, /* optinfo_flags */
10396 TV_VAR_TRACKING, /* tv_id */
10397 0, /* properties_required */
10398 0, /* properties_provided */
10399 0, /* properties_destroyed */
10400 0, /* todo_flags_start */
10401 0, /* todo_flags_finish */
10404 class pass_variable_tracking : public rtl_opt_pass
10406 public:
10407 pass_variable_tracking (gcc::context *ctxt)
10408 : rtl_opt_pass (pass_data_variable_tracking, ctxt)
10411 /* opt_pass methods: */
10412 virtual bool gate (function *)
10414 return (flag_var_tracking && !targetm.delay_vartrack);
10417 virtual unsigned int execute (function *)
10419 return variable_tracking_main ();
10422 }; // class pass_variable_tracking
10424 } // anon namespace
10426 rtl_opt_pass *
10427 make_pass_variable_tracking (gcc::context *ctxt)
10429 return new pass_variable_tracking (ctxt);