1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
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
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
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
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
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).
90 #include "coretypes.h"
96 #include "alloc-pool.h"
97 #include "tree-pass.h"
100 #include "insn-config.h"
102 #include "emit-rtl.h"
104 #include "diagnostic.h"
106 #include "stor-layout.h"
111 #include "tree-dfa.h"
112 #include "tree-ssa.h"
115 #include "tree-pretty-print.h"
116 #include "rtl-iter.h"
117 #include "fibonacci_heap.h"
119 typedef fibonacci_heap
<long, basic_block_def
> bb_heap_t
;
120 typedef fibonacci_node
<long, basic_block_def
> bb_heap_node_t
;
122 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
123 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
124 Currently the value is the same as IDENTIFIER_NODE, which has such
125 a property. If this compile time assertion ever fails, make sure that
126 the new tree code that equals (int) VALUE has the same property. */
127 extern char check_value_val
[(int) VALUE
== (int) IDENTIFIER_NODE
? 1 : -1];
129 /* Type of micro operation. */
130 enum micro_operation_type
132 MO_USE
, /* Use location (REG or MEM). */
133 MO_USE_NO_VAR
,/* Use location which is not associated with a variable
134 or the variable is not trackable. */
135 MO_VAL_USE
, /* Use location which is associated with a value. */
136 MO_VAL_LOC
, /* Use location which appears in a debug insn. */
137 MO_VAL_SET
, /* Set location associated with a value. */
138 MO_SET
, /* Set location. */
139 MO_COPY
, /* Copy the same portion of a variable from one
140 location to another. */
141 MO_CLOBBER
, /* Clobber location. */
142 MO_CALL
, /* Call insn. */
143 MO_ADJUST
/* Adjust stack pointer. */
147 static const char * const ATTRIBUTE_UNUSED
148 micro_operation_type_name
[] = {
161 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
162 Notes emitted as AFTER_CALL are to take effect during the call,
163 rather than after the call. */
166 EMIT_NOTE_BEFORE_INSN
,
167 EMIT_NOTE_AFTER_INSN
,
168 EMIT_NOTE_AFTER_CALL_INSN
171 /* Structure holding information about micro operation. */
172 struct micro_operation
174 /* Type of micro operation. */
175 enum micro_operation_type type
;
177 /* The instruction which the micro operation is in, for MO_USE,
178 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
179 instruction or note in the original flow (before any var-tracking
180 notes are inserted, to simplify emission of notes), for MO_SET
185 /* Location. For MO_SET and MO_COPY, this is the SET that
186 performs the assignment, if known, otherwise it is the target
187 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
188 CONCAT of the VALUE and the LOC associated with it. For
189 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
190 associated with it. */
193 /* Stack adjustment. */
194 HOST_WIDE_INT adjust
;
199 /* A declaration of a variable, or an RTL value being handled like a
201 typedef void *decl_or_value
;
203 /* Return true if a decl_or_value DV is a DECL or NULL. */
205 dv_is_decl_p (decl_or_value dv
)
207 return !dv
|| (int) TREE_CODE ((tree
) dv
) != (int) VALUE
;
210 /* Return true if a decl_or_value is a VALUE rtl. */
212 dv_is_value_p (decl_or_value dv
)
214 return dv
&& !dv_is_decl_p (dv
);
217 /* Return the decl in the decl_or_value. */
219 dv_as_decl (decl_or_value dv
)
221 gcc_checking_assert (dv_is_decl_p (dv
));
225 /* Return the value in the decl_or_value. */
227 dv_as_value (decl_or_value dv
)
229 gcc_checking_assert (dv_is_value_p (dv
));
233 /* Return the opaque pointer in the decl_or_value. */
235 dv_as_opaque (decl_or_value dv
)
241 /* Description of location of a part of a variable. The content of a physical
242 register is described by a chain of these structures.
243 The chains are pretty short (usually 1 or 2 elements) and thus
244 chain is the best data structure. */
247 /* Pointer to next member of the list. */
250 /* The rtx of register. */
253 /* The declaration corresponding to LOC. */
256 /* Offset from start of DECL. */
257 HOST_WIDE_INT offset
;
260 /* Structure for chaining the locations. */
261 struct location_chain
263 /* Next element in the chain. */
264 location_chain
*next
;
266 /* The location (REG, MEM or VALUE). */
269 /* The "value" stored in this location. */
273 enum var_init_status init
;
276 /* A vector of loc_exp_dep holds the active dependencies of a one-part
277 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
278 location of DV. Each entry is also part of VALUE' s linked-list of
279 backlinks back to DV. */
282 /* The dependent DV. */
284 /* The dependency VALUE or DECL_DEBUG. */
286 /* The next entry in VALUE's backlinks list. */
287 struct loc_exp_dep
*next
;
288 /* A pointer to the pointer to this entry (head or prev's next) in
289 the doubly-linked list. */
290 struct loc_exp_dep
**pprev
;
294 /* This data structure holds information about the depth of a variable
298 /* This measures the complexity of the expanded expression. It
299 grows by one for each level of expansion that adds more than one
302 /* This counts the number of ENTRY_VALUE expressions in an
303 expansion. We want to minimize their use. */
307 /* This data structure is allocated for one-part variables at the time
308 of emitting notes. */
311 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
312 computation used the expansion of this variable, and that ought
313 to be notified should this variable change. If the DV's cur_loc
314 expanded to NULL, all components of the loc list are regarded as
315 active, so that any changes in them give us a chance to get a
316 location. Otherwise, only components of the loc that expanded to
317 non-NULL are regarded as active dependencies. */
318 loc_exp_dep
*backlinks
;
319 /* This holds the LOC that was expanded into cur_loc. We need only
320 mark a one-part variable as changed if the FROM loc is removed,
321 or if it has no known location and a loc is added, or if it gets
322 a change notification from any of its active dependencies. */
324 /* The depth of the cur_loc expression. */
326 /* Dependencies actively used when expand FROM into cur_loc. */
327 vec
<loc_exp_dep
, va_heap
, vl_embed
> deps
;
330 /* Structure describing one part of variable. */
333 /* Chain of locations of the part. */
334 location_chain
*loc_chain
;
336 /* Location which was last emitted to location list. */
341 /* The offset in the variable, if !var->onepart. */
342 HOST_WIDE_INT offset
;
344 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
345 struct onepart_aux
*onepaux
;
349 /* Maximum number of location parts. */
350 #define MAX_VAR_PARTS 16
352 /* Enumeration type used to discriminate various types of one-part
356 /* Not a one-part variable. */
358 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
360 /* A DEBUG_EXPR_DECL. */
366 /* Structure describing where the variable is located. */
369 /* The declaration of the variable, or an RTL value being handled
370 like a declaration. */
373 /* Reference count. */
376 /* Number of variable parts. */
379 /* What type of DV this is, according to enum onepart_enum. */
380 ENUM_BITFIELD (onepart_enum
) onepart
: CHAR_BIT
;
382 /* True if this variable_def struct is currently in the
383 changed_variables hash table. */
384 bool in_changed_variables
;
386 /* The variable parts. */
387 variable_part var_part
[1];
390 /* Pointer to the BB's information specific to variable tracking pass. */
391 #define VTI(BB) ((variable_tracking_info *) (BB)->aux)
393 /* Return MEM_OFFSET (MEM) as a HOST_WIDE_INT, or 0 if we can't. */
395 static inline HOST_WIDE_INT
396 int_mem_offset (const_rtx mem
)
398 HOST_WIDE_INT offset
;
399 if (MEM_OFFSET_KNOWN_P (mem
) && MEM_OFFSET (mem
).is_constant (&offset
))
404 #if CHECKING_P && (GCC_VERSION >= 2007)
406 /* Access VAR's Ith part's offset, checking that it's not a one-part
408 #define VAR_PART_OFFSET(var, i) __extension__ \
409 (*({ variable *const __v = (var); \
410 gcc_checking_assert (!__v->onepart); \
411 &__v->var_part[(i)].aux.offset; }))
413 /* Access VAR's one-part auxiliary data, checking that it is a
414 one-part variable. */
415 #define VAR_LOC_1PAUX(var) __extension__ \
416 (*({ variable *const __v = (var); \
417 gcc_checking_assert (__v->onepart); \
418 &__v->var_part[0].aux.onepaux; }))
421 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
422 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
425 /* These are accessor macros for the one-part auxiliary data. When
426 convenient for users, they're guarded by tests that the data was
428 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
429 ? VAR_LOC_1PAUX (var)->backlinks \
431 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
432 ? &VAR_LOC_1PAUX (var)->backlinks \
434 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
435 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
436 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
437 ? &VAR_LOC_1PAUX (var)->deps \
442 typedef unsigned int dvuid
;
444 /* Return the uid of DV. */
447 dv_uid (decl_or_value dv
)
449 if (dv_is_value_p (dv
))
450 return CSELIB_VAL_PTR (dv_as_value (dv
))->uid
;
452 return DECL_UID (dv_as_decl (dv
));
455 /* Compute the hash from the uid. */
457 static inline hashval_t
458 dv_uid2hash (dvuid uid
)
463 /* The hash function for a mask table in a shared_htab chain. */
465 static inline hashval_t
466 dv_htab_hash (decl_or_value dv
)
468 return dv_uid2hash (dv_uid (dv
));
471 static void variable_htab_free (void *);
473 /* Variable hashtable helpers. */
475 struct variable_hasher
: pointer_hash
<variable
>
477 typedef void *compare_type
;
478 static inline hashval_t
hash (const variable
*);
479 static inline bool equal (const variable
*, const void *);
480 static inline void remove (variable
*);
483 /* The hash function for variable_htab, computes the hash value
484 from the declaration of variable X. */
487 variable_hasher::hash (const variable
*v
)
489 return dv_htab_hash (v
->dv
);
492 /* Compare the declaration of variable X with declaration Y. */
495 variable_hasher::equal (const variable
*v
, const void *y
)
497 decl_or_value dv
= CONST_CAST2 (decl_or_value
, const void *, y
);
499 return (dv_as_opaque (v
->dv
) == dv_as_opaque (dv
));
502 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
505 variable_hasher::remove (variable
*var
)
507 variable_htab_free (var
);
510 typedef hash_table
<variable_hasher
> variable_table_type
;
511 typedef variable_table_type::iterator variable_iterator_type
;
513 /* Structure for passing some other parameters to function
514 emit_note_insn_var_location. */
515 struct emit_note_data
517 /* The instruction which the note will be emitted before/after. */
520 /* Where the note will be emitted (before/after insn)? */
521 enum emit_note_where where
;
523 /* The variables and values active at this point. */
524 variable_table_type
*vars
;
527 /* Structure holding a refcounted hash table. If refcount > 1,
528 it must be first unshared before modified. */
531 /* Reference count. */
534 /* Actual hash table. */
535 variable_table_type
*htab
;
538 /* Structure holding the IN or OUT set for a basic block. */
541 /* Adjustment of stack offset. */
542 HOST_WIDE_INT stack_adjust
;
544 /* Attributes for registers (lists of attrs). */
545 attrs
*regs
[FIRST_PSEUDO_REGISTER
];
547 /* Variable locations. */
550 /* Vars that is being traversed. */
551 shared_hash
*traversed_vars
;
554 /* The structure (one for each basic block) containing the information
555 needed for variable tracking. */
556 struct variable_tracking_info
558 /* The vector of micro operations. */
559 vec
<micro_operation
> mos
;
561 /* The IN and OUT set for dataflow analysis. */
565 /* The permanent-in dataflow set for this block. This is used to
566 hold values for which we had to compute entry values. ??? This
567 should probably be dynamically allocated, to avoid using more
568 memory in non-debug builds. */
571 /* Has the block been visited in DFS? */
574 /* Has the block been flooded in VTA? */
579 /* Alloc pool for struct attrs_def. */
580 object_allocator
<attrs
> attrs_pool ("attrs pool");
582 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
584 static pool_allocator var_pool
585 ("variable_def pool", sizeof (variable
) +
586 (MAX_VAR_PARTS
- 1) * sizeof (((variable
*)NULL
)->var_part
[0]));
588 /* Alloc pool for struct variable_def with a single var_part entry. */
589 static pool_allocator valvar_pool
590 ("small variable_def pool", sizeof (variable
));
592 /* Alloc pool for struct location_chain. */
593 static object_allocator
<location_chain
> location_chain_pool
594 ("location_chain pool");
596 /* Alloc pool for struct shared_hash. */
597 static object_allocator
<shared_hash
> shared_hash_pool ("shared_hash pool");
599 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
600 object_allocator
<loc_exp_dep
> loc_exp_dep_pool ("loc_exp_dep pool");
602 /* Changed variables, notes will be emitted for them. */
603 static variable_table_type
*changed_variables
;
605 /* Shall notes be emitted? */
606 static bool emit_notes
;
608 /* Values whose dynamic location lists have gone empty, but whose
609 cselib location lists are still usable. Use this to hold the
610 current location, the backlinks, etc, during emit_notes. */
611 static variable_table_type
*dropped_values
;
613 /* Empty shared hashtable. */
614 static shared_hash
*empty_shared_hash
;
616 /* Scratch register bitmap used by cselib_expand_value_rtx. */
617 static bitmap scratch_regs
= NULL
;
619 #ifdef HAVE_window_save
620 struct GTY(()) parm_reg
{
626 /* Vector of windowed parameter registers, if any. */
627 static vec
<parm_reg
, va_gc
> *windowed_parm_regs
= NULL
;
630 /* Variable used to tell whether cselib_process_insn called our hook. */
631 static bool cselib_hook_called
;
633 /* Local function prototypes. */
634 static void stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
636 static void insn_stack_adjust_offset_pre_post (rtx_insn
*, HOST_WIDE_INT
*,
638 static bool vt_stack_adjustments (void);
640 static void init_attrs_list_set (attrs
**);
641 static void attrs_list_clear (attrs
**);
642 static attrs
*attrs_list_member (attrs
*, decl_or_value
, HOST_WIDE_INT
);
643 static void attrs_list_insert (attrs
**, decl_or_value
, HOST_WIDE_INT
, rtx
);
644 static void attrs_list_copy (attrs
**, attrs
*);
645 static void attrs_list_union (attrs
**, attrs
*);
647 static variable
**unshare_variable (dataflow_set
*set
, variable
**slot
,
648 variable
*var
, enum var_init_status
);
649 static void vars_copy (variable_table_type
*, variable_table_type
*);
650 static tree
var_debug_decl (tree
);
651 static void var_reg_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
652 static void var_reg_delete_and_set (dataflow_set
*, rtx
, bool,
653 enum var_init_status
, rtx
);
654 static void var_reg_delete (dataflow_set
*, rtx
, bool);
655 static void var_regno_delete (dataflow_set
*, int);
656 static void var_mem_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
657 static void var_mem_delete_and_set (dataflow_set
*, rtx
, bool,
658 enum var_init_status
, rtx
);
659 static void var_mem_delete (dataflow_set
*, rtx
, bool);
661 static void dataflow_set_init (dataflow_set
*);
662 static void dataflow_set_clear (dataflow_set
*);
663 static void dataflow_set_copy (dataflow_set
*, dataflow_set
*);
664 static int variable_union_info_cmp_pos (const void *, const void *);
665 static void dataflow_set_union (dataflow_set
*, dataflow_set
*);
666 static location_chain
*find_loc_in_1pdv (rtx
, variable
*,
667 variable_table_type
*);
668 static bool canon_value_cmp (rtx
, rtx
);
669 static int loc_cmp (rtx
, rtx
);
670 static bool variable_part_different_p (variable_part
*, variable_part
*);
671 static bool onepart_variable_different_p (variable
*, variable
*);
672 static bool variable_different_p (variable
*, variable
*);
673 static bool dataflow_set_different (dataflow_set
*, dataflow_set
*);
674 static void dataflow_set_destroy (dataflow_set
*);
676 static bool track_expr_p (tree
, bool);
677 static void add_uses_1 (rtx
*, void *);
678 static void add_stores (rtx
, const_rtx
, void *);
679 static bool compute_bb_dataflow (basic_block
);
680 static bool vt_find_locations (void);
682 static void dump_attrs_list (attrs
*);
683 static void dump_var (variable
*);
684 static void dump_vars (variable_table_type
*);
685 static void dump_dataflow_set (dataflow_set
*);
686 static void dump_dataflow_sets (void);
688 static void set_dv_changed (decl_or_value
, bool);
689 static void variable_was_changed (variable
*, dataflow_set
*);
690 static variable
**set_slot_part (dataflow_set
*, rtx
, variable
**,
691 decl_or_value
, HOST_WIDE_INT
,
692 enum var_init_status
, rtx
);
693 static void set_variable_part (dataflow_set
*, rtx
,
694 decl_or_value
, HOST_WIDE_INT
,
695 enum var_init_status
, rtx
, enum insert_option
);
696 static variable
**clobber_slot_part (dataflow_set
*, rtx
,
697 variable
**, HOST_WIDE_INT
, rtx
);
698 static void clobber_variable_part (dataflow_set
*, rtx
,
699 decl_or_value
, HOST_WIDE_INT
, rtx
);
700 static variable
**delete_slot_part (dataflow_set
*, rtx
, variable
**,
702 static void delete_variable_part (dataflow_set
*, rtx
,
703 decl_or_value
, HOST_WIDE_INT
);
704 static void emit_notes_in_bb (basic_block
, dataflow_set
*);
705 static void vt_emit_notes (void);
707 static void vt_add_function_parameters (void);
708 static bool vt_initialize (void);
709 static void vt_finalize (void);
711 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
714 stack_adjust_offset_pre_post_cb (rtx
, rtx op
, rtx dest
, rtx src
, rtx srcoff
,
717 if (dest
!= stack_pointer_rtx
)
720 switch (GET_CODE (op
))
724 ((HOST_WIDE_INT
*)arg
)[0] -= INTVAL (srcoff
);
728 ((HOST_WIDE_INT
*)arg
)[1] -= INTVAL (srcoff
);
732 /* We handle only adjustments by constant amount. */
733 gcc_assert (GET_CODE (src
) == PLUS
734 && CONST_INT_P (XEXP (src
, 1))
735 && XEXP (src
, 0) == stack_pointer_rtx
);
736 ((HOST_WIDE_INT
*)arg
)[GET_CODE (op
) == POST_MODIFY
]
737 -= INTVAL (XEXP (src
, 1));
744 /* Given a SET, calculate the amount of stack adjustment it contains
745 PRE- and POST-modifying stack pointer.
746 This function is similar to stack_adjust_offset. */
749 stack_adjust_offset_pre_post (rtx pattern
, HOST_WIDE_INT
*pre
,
752 rtx src
= SET_SRC (pattern
);
753 rtx dest
= SET_DEST (pattern
);
756 if (dest
== stack_pointer_rtx
)
758 /* (set (reg sp) (plus (reg sp) (const_int))) */
759 code
= GET_CODE (src
);
760 if (! (code
== PLUS
|| code
== MINUS
)
761 || XEXP (src
, 0) != stack_pointer_rtx
762 || !CONST_INT_P (XEXP (src
, 1)))
766 *post
+= INTVAL (XEXP (src
, 1));
768 *post
-= INTVAL (XEXP (src
, 1));
771 HOST_WIDE_INT res
[2] = { 0, 0 };
772 for_each_inc_dec (pattern
, stack_adjust_offset_pre_post_cb
, res
);
777 /* Given an INSN, calculate the amount of stack adjustment it contains
778 PRE- and POST-modifying stack pointer. */
781 insn_stack_adjust_offset_pre_post (rtx_insn
*insn
, HOST_WIDE_INT
*pre
,
789 pattern
= PATTERN (insn
);
790 if (RTX_FRAME_RELATED_P (insn
))
792 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
794 pattern
= XEXP (expr
, 0);
797 if (GET_CODE (pattern
) == SET
)
798 stack_adjust_offset_pre_post (pattern
, pre
, post
);
799 else if (GET_CODE (pattern
) == PARALLEL
800 || GET_CODE (pattern
) == SEQUENCE
)
804 /* There may be stack adjustments inside compound insns. Search
806 for ( i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
807 if (GET_CODE (XVECEXP (pattern
, 0, i
)) == SET
)
808 stack_adjust_offset_pre_post (XVECEXP (pattern
, 0, i
), pre
, post
);
812 /* Compute stack adjustments for all blocks by traversing DFS tree.
813 Return true when the adjustments on all incoming edges are consistent.
814 Heavily borrowed from pre_and_rev_post_order_compute. */
817 vt_stack_adjustments (void)
819 edge_iterator
*stack
;
822 /* Initialize entry block. */
823 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->visited
= true;
824 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->in
.stack_adjust
825 = INCOMING_FRAME_SP_OFFSET
;
826 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
.stack_adjust
827 = INCOMING_FRAME_SP_OFFSET
;
829 /* Allocate stack for back-tracking up CFG. */
830 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
833 /* Push the first edge on to the stack. */
834 stack
[sp
++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
842 /* Look at the edge on the top of the stack. */
844 src
= ei_edge (ei
)->src
;
845 dest
= ei_edge (ei
)->dest
;
847 /* Check if the edge destination has been visited yet. */
848 if (!VTI (dest
)->visited
)
851 HOST_WIDE_INT pre
, post
, offset
;
852 VTI (dest
)->visited
= true;
853 VTI (dest
)->in
.stack_adjust
= offset
= VTI (src
)->out
.stack_adjust
;
855 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
856 for (insn
= BB_HEAD (dest
);
857 insn
!= NEXT_INSN (BB_END (dest
));
858 insn
= NEXT_INSN (insn
))
861 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
862 offset
+= pre
+ post
;
865 VTI (dest
)->out
.stack_adjust
= offset
;
867 if (EDGE_COUNT (dest
->succs
) > 0)
868 /* Since the DEST node has been visited for the first
869 time, check its successors. */
870 stack
[sp
++] = ei_start (dest
->succs
);
874 /* We can end up with different stack adjustments for the exit block
875 of a shrink-wrapped function if stack_adjust_offset_pre_post
876 doesn't understand the rtx pattern used to restore the stack
877 pointer in the epilogue. For example, on s390(x), the stack
878 pointer is often restored via a load-multiple instruction
879 and so no stack_adjust offset is recorded for it. This means
880 that the stack offset at the end of the epilogue block is the
881 same as the offset before the epilogue, whereas other paths
882 to the exit block will have the correct stack_adjust.
884 It is safe to ignore these differences because (a) we never
885 use the stack_adjust for the exit block in this pass and
886 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
887 function are correct.
889 We must check whether the adjustments on other edges are
891 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
892 && VTI (dest
)->in
.stack_adjust
!= VTI (src
)->out
.stack_adjust
)
898 if (! ei_one_before_end_p (ei
))
899 /* Go to the next edge. */
900 ei_next (&stack
[sp
- 1]);
902 /* Return to previous level if there are no more edges. */
911 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
912 hard_frame_pointer_rtx is being mapped to it and offset for it. */
913 static rtx cfa_base_rtx
;
914 static HOST_WIDE_INT cfa_base_offset
;
916 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
917 or hard_frame_pointer_rtx. */
920 compute_cfa_pointer (HOST_WIDE_INT adjustment
)
922 return plus_constant (Pmode
, cfa_base_rtx
, adjustment
+ cfa_base_offset
);
925 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
926 or -1 if the replacement shouldn't be done. */
927 static HOST_WIDE_INT hard_frame_pointer_adjustment
= -1;
929 /* Data for adjust_mems callback. */
931 struct adjust_mem_data
934 machine_mode mem_mode
;
935 HOST_WIDE_INT stack_adjust
;
936 auto_vec
<rtx
> side_effects
;
939 /* Helper for adjust_mems. Return true if X is suitable for
940 transformation of wider mode arithmetics to narrower mode. */
943 use_narrower_mode_test (rtx x
, const_rtx subreg
)
945 subrtx_var_iterator::array_type array
;
946 FOR_EACH_SUBRTX_VAR (iter
, array
, x
, NONCONST
)
950 iter
.skip_subrtxes ();
952 switch (GET_CODE (x
))
955 if (cselib_lookup (x
, GET_MODE (SUBREG_REG (subreg
)), 0, VOIDmode
))
957 if (!validate_subreg (GET_MODE (subreg
), GET_MODE (x
), x
,
958 subreg_lowpart_offset (GET_MODE (subreg
),
967 iter
.substitute (XEXP (x
, 0));
976 /* Transform X into narrower mode MODE from wider mode WMODE. */
979 use_narrower_mode (rtx x
, scalar_int_mode mode
, scalar_int_mode wmode
)
983 return lowpart_subreg (mode
, x
, wmode
);
984 switch (GET_CODE (x
))
987 return lowpart_subreg (mode
, x
, wmode
);
991 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
992 op1
= use_narrower_mode (XEXP (x
, 1), mode
, wmode
);
993 return simplify_gen_binary (GET_CODE (x
), mode
, op0
, op1
);
995 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
997 /* Ensure shift amount is not wider than mode. */
998 if (GET_MODE (op1
) == VOIDmode
)
999 op1
= lowpart_subreg (mode
, op1
, wmode
);
1000 else if (GET_MODE_PRECISION (mode
)
1001 < GET_MODE_PRECISION (as_a
<scalar_int_mode
> (GET_MODE (op1
))))
1002 op1
= lowpart_subreg (mode
, op1
, GET_MODE (op1
));
1003 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
1009 /* Helper function for adjusting used MEMs. */
1012 adjust_mems (rtx loc
, const_rtx old_rtx
, void *data
)
1014 struct adjust_mem_data
*amd
= (struct adjust_mem_data
*) data
;
1015 rtx mem
, addr
= loc
, tem
;
1016 machine_mode mem_mode_save
;
1018 scalar_int_mode tem_mode
, tem_subreg_mode
;
1019 switch (GET_CODE (loc
))
1022 /* Don't do any sp or fp replacements outside of MEM addresses
1024 if (amd
->mem_mode
== VOIDmode
&& amd
->store
)
1026 if (loc
== stack_pointer_rtx
1027 && !frame_pointer_needed
1029 return compute_cfa_pointer (amd
->stack_adjust
);
1030 else if (loc
== hard_frame_pointer_rtx
1031 && frame_pointer_needed
1032 && hard_frame_pointer_adjustment
!= -1
1034 return compute_cfa_pointer (hard_frame_pointer_adjustment
);
1035 gcc_checking_assert (loc
!= virtual_incoming_args_rtx
);
1041 mem
= targetm
.delegitimize_address (mem
);
1042 if (mem
!= loc
&& !MEM_P (mem
))
1043 return simplify_replace_fn_rtx (mem
, old_rtx
, adjust_mems
, data
);
1046 addr
= XEXP (mem
, 0);
1047 mem_mode_save
= amd
->mem_mode
;
1048 amd
->mem_mode
= GET_MODE (mem
);
1049 store_save
= amd
->store
;
1051 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1052 amd
->store
= store_save
;
1053 amd
->mem_mode
= mem_mode_save
;
1055 addr
= targetm
.delegitimize_address (addr
);
1056 if (addr
!= XEXP (mem
, 0))
1057 mem
= replace_equiv_address_nv (mem
, addr
);
1059 mem
= avoid_constant_pool_reference (mem
);
1063 addr
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1064 gen_int_mode (GET_CODE (loc
) == PRE_INC
1065 ? GET_MODE_SIZE (amd
->mem_mode
)
1066 : -GET_MODE_SIZE (amd
->mem_mode
),
1072 addr
= XEXP (loc
, 0);
1073 gcc_assert (amd
->mem_mode
!= VOIDmode
&& amd
->mem_mode
!= BLKmode
);
1074 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1075 tem
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1076 gen_int_mode ((GET_CODE (loc
) == PRE_INC
1077 || GET_CODE (loc
) == POST_INC
)
1078 ? GET_MODE_SIZE (amd
->mem_mode
)
1079 : -GET_MODE_SIZE (amd
->mem_mode
),
1081 store_save
= amd
->store
;
1083 tem
= simplify_replace_fn_rtx (tem
, old_rtx
, adjust_mems
, data
);
1084 amd
->store
= store_save
;
1085 amd
->side_effects
.safe_push (gen_rtx_SET (XEXP (loc
, 0), tem
));
1088 addr
= XEXP (loc
, 1);
1092 addr
= XEXP (loc
, 0);
1093 gcc_assert (amd
->mem_mode
!= VOIDmode
);
1094 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1095 store_save
= amd
->store
;
1097 tem
= simplify_replace_fn_rtx (XEXP (loc
, 1), old_rtx
,
1099 amd
->store
= store_save
;
1100 amd
->side_effects
.safe_push (gen_rtx_SET (XEXP (loc
, 0), tem
));
1103 /* First try without delegitimization of whole MEMs and
1104 avoid_constant_pool_reference, which is more likely to succeed. */
1105 store_save
= amd
->store
;
1107 addr
= simplify_replace_fn_rtx (SUBREG_REG (loc
), old_rtx
, adjust_mems
,
1109 amd
->store
= store_save
;
1110 mem
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1111 if (mem
== SUBREG_REG (loc
))
1116 tem
= simplify_gen_subreg (GET_MODE (loc
), mem
,
1117 GET_MODE (SUBREG_REG (loc
)),
1121 tem
= simplify_gen_subreg (GET_MODE (loc
), addr
,
1122 GET_MODE (SUBREG_REG (loc
)),
1124 if (tem
== NULL_RTX
)
1125 tem
= gen_rtx_raw_SUBREG (GET_MODE (loc
), addr
, SUBREG_BYTE (loc
));
1127 if (MAY_HAVE_DEBUG_BIND_INSNS
1128 && GET_CODE (tem
) == SUBREG
1129 && (GET_CODE (SUBREG_REG (tem
)) == PLUS
1130 || GET_CODE (SUBREG_REG (tem
)) == MINUS
1131 || GET_CODE (SUBREG_REG (tem
)) == MULT
1132 || GET_CODE (SUBREG_REG (tem
)) == ASHIFT
)
1133 && is_a
<scalar_int_mode
> (GET_MODE (tem
), &tem_mode
)
1134 && is_a
<scalar_int_mode
> (GET_MODE (SUBREG_REG (tem
)),
1136 && (GET_MODE_PRECISION (tem_mode
)
1137 < GET_MODE_PRECISION (tem_subreg_mode
))
1138 && subreg_lowpart_p (tem
)
1139 && use_narrower_mode_test (SUBREG_REG (tem
), tem
))
1140 return use_narrower_mode (SUBREG_REG (tem
), tem_mode
, tem_subreg_mode
);
1143 /* Don't do any replacements in second and following
1144 ASM_OPERANDS of inline-asm with multiple sets.
1145 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1146 and ASM_OPERANDS_LABEL_VEC need to be equal between
1147 all the ASM_OPERANDs in the insn and adjust_insn will
1149 if (ASM_OPERANDS_OUTPUT_IDX (loc
) != 0)
1158 /* Helper function for replacement of uses. */
1161 adjust_mem_uses (rtx
*x
, void *data
)
1163 rtx new_x
= simplify_replace_fn_rtx (*x
, NULL_RTX
, adjust_mems
, data
);
1165 validate_change (NULL_RTX
, x
, new_x
, true);
1168 /* Helper function for replacement of stores. */
1171 adjust_mem_stores (rtx loc
, const_rtx expr
, void *data
)
1175 rtx new_dest
= simplify_replace_fn_rtx (SET_DEST (expr
), NULL_RTX
,
1177 if (new_dest
!= SET_DEST (expr
))
1179 rtx xexpr
= CONST_CAST_RTX (expr
);
1180 validate_change (NULL_RTX
, &SET_DEST (xexpr
), new_dest
, true);
1185 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1186 replace them with their value in the insn and add the side-effects
1187 as other sets to the insn. */
1190 adjust_insn (basic_block bb
, rtx_insn
*insn
)
1194 #ifdef HAVE_window_save
1195 /* If the target machine has an explicit window save instruction, the
1196 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1197 if (RTX_FRAME_RELATED_P (insn
)
1198 && find_reg_note (insn
, REG_CFA_WINDOW_SAVE
, NULL_RTX
))
1200 unsigned int i
, nregs
= vec_safe_length (windowed_parm_regs
);
1201 rtx rtl
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (nregs
* 2));
1204 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs
, i
, p
)
1206 XVECEXP (rtl
, 0, i
* 2)
1207 = gen_rtx_SET (p
->incoming
, p
->outgoing
);
1208 /* Do not clobber the attached DECL, but only the REG. */
1209 XVECEXP (rtl
, 0, i
* 2 + 1)
1210 = gen_rtx_CLOBBER (GET_MODE (p
->outgoing
),
1211 gen_raw_REG (GET_MODE (p
->outgoing
),
1212 REGNO (p
->outgoing
)));
1215 validate_change (NULL_RTX
, &PATTERN (insn
), rtl
, true);
1220 adjust_mem_data amd
;
1221 amd
.mem_mode
= VOIDmode
;
1222 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
1225 note_stores (PATTERN (insn
), adjust_mem_stores
, &amd
);
1228 if (GET_CODE (PATTERN (insn
)) == PARALLEL
1229 && asm_noperands (PATTERN (insn
)) > 0
1230 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == SET
)
1235 /* inline-asm with multiple sets is tiny bit more complicated,
1236 because the 3 vectors in ASM_OPERANDS need to be shared between
1237 all ASM_OPERANDS in the instruction. adjust_mems will
1238 not touch ASM_OPERANDS other than the first one, asm_noperands
1239 test above needs to be called before that (otherwise it would fail)
1240 and afterwards this code fixes it up. */
1241 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1242 body
= PATTERN (insn
);
1243 set0
= XVECEXP (body
, 0, 0);
1244 gcc_checking_assert (GET_CODE (set0
) == SET
1245 && GET_CODE (SET_SRC (set0
)) == ASM_OPERANDS
1246 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0
)) == 0);
1247 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1248 if (GET_CODE (XVECEXP (body
, 0, i
)) != SET
)
1252 set
= XVECEXP (body
, 0, i
);
1253 gcc_checking_assert (GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
1254 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set
))
1256 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set
))
1257 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
))
1258 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set
))
1259 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
))
1260 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set
))
1261 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
)))
1263 rtx newsrc
= shallow_copy_rtx (SET_SRC (set
));
1264 ASM_OPERANDS_INPUT_VEC (newsrc
)
1265 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
));
1266 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc
)
1267 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
));
1268 ASM_OPERANDS_LABEL_VEC (newsrc
)
1269 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
));
1270 validate_change (NULL_RTX
, &SET_SRC (set
), newsrc
, true);
1275 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1277 /* For read-only MEMs containing some constant, prefer those
1279 set
= single_set (insn
);
1280 if (set
&& MEM_P (SET_SRC (set
)) && MEM_READONLY_P (SET_SRC (set
)))
1282 rtx note
= find_reg_equal_equiv_note (insn
);
1284 if (note
&& CONSTANT_P (XEXP (note
, 0)))
1285 validate_change (NULL_RTX
, &SET_SRC (set
), XEXP (note
, 0), true);
1288 if (!amd
.side_effects
.is_empty ())
1293 pat
= &PATTERN (insn
);
1294 if (GET_CODE (*pat
) == COND_EXEC
)
1295 pat
= &COND_EXEC_CODE (*pat
);
1296 if (GET_CODE (*pat
) == PARALLEL
)
1297 oldn
= XVECLEN (*pat
, 0);
1300 unsigned int newn
= amd
.side_effects
.length ();
1301 new_pat
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (oldn
+ newn
));
1302 if (GET_CODE (*pat
) == PARALLEL
)
1303 for (i
= 0; i
< oldn
; i
++)
1304 XVECEXP (new_pat
, 0, i
) = XVECEXP (*pat
, 0, i
);
1306 XVECEXP (new_pat
, 0, 0) = *pat
;
1310 FOR_EACH_VEC_ELT_REVERSE (amd
.side_effects
, j
, effect
)
1311 XVECEXP (new_pat
, 0, j
+ oldn
) = effect
;
1312 validate_change (NULL_RTX
, pat
, new_pat
, true);
1316 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1318 dv_as_rtx (decl_or_value dv
)
1322 if (dv_is_value_p (dv
))
1323 return dv_as_value (dv
);
1325 decl
= dv_as_decl (dv
);
1327 gcc_checking_assert (TREE_CODE (decl
) == DEBUG_EXPR_DECL
);
1328 return DECL_RTL_KNOWN_SET (decl
);
1331 /* Return nonzero if a decl_or_value must not have more than one
1332 variable part. The returned value discriminates among various
1333 kinds of one-part DVs ccording to enum onepart_enum. */
1334 static inline onepart_enum
1335 dv_onepart_p (decl_or_value dv
)
1339 if (!MAY_HAVE_DEBUG_BIND_INSNS
)
1342 if (dv_is_value_p (dv
))
1343 return ONEPART_VALUE
;
1345 decl
= dv_as_decl (dv
);
1347 if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
1348 return ONEPART_DEXPR
;
1350 if (target_for_debug_bind (decl
) != NULL_TREE
)
1351 return ONEPART_VDECL
;
1356 /* Return the variable pool to be used for a dv of type ONEPART. */
1357 static inline pool_allocator
&
1358 onepart_pool (onepart_enum onepart
)
1360 return onepart
? valvar_pool
: var_pool
;
1363 /* Allocate a variable_def from the corresponding variable pool. */
1364 static inline variable
*
1365 onepart_pool_allocate (onepart_enum onepart
)
1367 return (variable
*) onepart_pool (onepart
).allocate ();
1370 /* Build a decl_or_value out of a decl. */
1371 static inline decl_or_value
1372 dv_from_decl (tree decl
)
1376 gcc_checking_assert (dv_is_decl_p (dv
));
1380 /* Build a decl_or_value out of a value. */
1381 static inline decl_or_value
1382 dv_from_value (rtx value
)
1386 gcc_checking_assert (dv_is_value_p (dv
));
1390 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1391 static inline decl_or_value
1396 switch (GET_CODE (x
))
1399 dv
= dv_from_decl (DEBUG_EXPR_TREE_DECL (x
));
1400 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x
)) == x
);
1404 dv
= dv_from_value (x
);
1414 extern void debug_dv (decl_or_value dv
);
1417 debug_dv (decl_or_value dv
)
1419 if (dv_is_value_p (dv
))
1420 debug_rtx (dv_as_value (dv
));
1422 debug_generic_stmt (dv_as_decl (dv
));
1425 static void loc_exp_dep_clear (variable
*var
);
1427 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1430 variable_htab_free (void *elem
)
1433 variable
*var
= (variable
*) elem
;
1434 location_chain
*node
, *next
;
1436 gcc_checking_assert (var
->refcount
> 0);
1439 if (var
->refcount
> 0)
1442 for (i
= 0; i
< var
->n_var_parts
; i
++)
1444 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= next
)
1449 var
->var_part
[i
].loc_chain
= NULL
;
1451 if (var
->onepart
&& VAR_LOC_1PAUX (var
))
1453 loc_exp_dep_clear (var
);
1454 if (VAR_LOC_DEP_LST (var
))
1455 VAR_LOC_DEP_LST (var
)->pprev
= NULL
;
1456 XDELETE (VAR_LOC_1PAUX (var
));
1457 /* These may be reused across functions, so reset
1459 if (var
->onepart
== ONEPART_DEXPR
)
1460 set_dv_changed (var
->dv
, true);
1462 onepart_pool (var
->onepart
).remove (var
);
1465 /* Initialize the set (array) SET of attrs to empty lists. */
1468 init_attrs_list_set (attrs
**set
)
1472 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1476 /* Make the list *LISTP empty. */
1479 attrs_list_clear (attrs
**listp
)
1483 for (list
= *listp
; list
; list
= next
)
1491 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1494 attrs_list_member (attrs
*list
, decl_or_value dv
, HOST_WIDE_INT offset
)
1496 for (; list
; list
= list
->next
)
1497 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
) && list
->offset
== offset
)
1502 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1505 attrs_list_insert (attrs
**listp
, decl_or_value dv
,
1506 HOST_WIDE_INT offset
, rtx loc
)
1508 attrs
*list
= new attrs
;
1511 list
->offset
= offset
;
1512 list
->next
= *listp
;
1516 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1519 attrs_list_copy (attrs
**dstp
, attrs
*src
)
1521 attrs_list_clear (dstp
);
1522 for (; src
; src
= src
->next
)
1524 attrs
*n
= new attrs
;
1527 n
->offset
= src
->offset
;
1533 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1536 attrs_list_union (attrs
**dstp
, attrs
*src
)
1538 for (; src
; src
= src
->next
)
1540 if (!attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1541 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1545 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1549 attrs_list_mpdv_union (attrs
**dstp
, attrs
*src
, attrs
*src2
)
1551 gcc_assert (!*dstp
);
1552 for (; src
; src
= src
->next
)
1554 if (!dv_onepart_p (src
->dv
))
1555 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1557 for (src
= src2
; src
; src
= src
->next
)
1559 if (!dv_onepart_p (src
->dv
)
1560 && !attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1561 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1565 /* Shared hashtable support. */
1567 /* Return true if VARS is shared. */
1570 shared_hash_shared (shared_hash
*vars
)
1572 return vars
->refcount
> 1;
1575 /* Return the hash table for VARS. */
1577 static inline variable_table_type
*
1578 shared_hash_htab (shared_hash
*vars
)
1583 /* Return true if VAR is shared, or maybe because VARS is shared. */
1586 shared_var_p (variable
*var
, shared_hash
*vars
)
1588 /* Don't count an entry in the changed_variables table as a duplicate. */
1589 return ((var
->refcount
> 1 + (int) var
->in_changed_variables
)
1590 || shared_hash_shared (vars
));
1593 /* Copy variables into a new hash table. */
1595 static shared_hash
*
1596 shared_hash_unshare (shared_hash
*vars
)
1598 shared_hash
*new_vars
= new shared_hash
;
1599 gcc_assert (vars
->refcount
> 1);
1600 new_vars
->refcount
= 1;
1601 new_vars
->htab
= new variable_table_type (vars
->htab
->elements () + 3);
1602 vars_copy (new_vars
->htab
, vars
->htab
);
1607 /* Increment reference counter on VARS and return it. */
1609 static inline shared_hash
*
1610 shared_hash_copy (shared_hash
*vars
)
1616 /* Decrement reference counter and destroy hash table if not shared
1620 shared_hash_destroy (shared_hash
*vars
)
1622 gcc_checking_assert (vars
->refcount
> 0);
1623 if (--vars
->refcount
== 0)
1630 /* Unshare *PVARS if shared and return slot for DV. If INS is
1631 INSERT, insert it if not already present. */
1633 static inline variable
**
1634 shared_hash_find_slot_unshare_1 (shared_hash
**pvars
, decl_or_value dv
,
1635 hashval_t dvhash
, enum insert_option ins
)
1637 if (shared_hash_shared (*pvars
))
1638 *pvars
= shared_hash_unshare (*pvars
);
1639 return shared_hash_htab (*pvars
)->find_slot_with_hash (dv
, dvhash
, ins
);
1642 static inline variable
**
1643 shared_hash_find_slot_unshare (shared_hash
**pvars
, decl_or_value dv
,
1644 enum insert_option ins
)
1646 return shared_hash_find_slot_unshare_1 (pvars
, dv
, dv_htab_hash (dv
), ins
);
1649 /* Return slot for DV, if it is already present in the hash table.
1650 If it is not present, insert it only VARS is not shared, otherwise
1653 static inline variable
**
1654 shared_hash_find_slot_1 (shared_hash
*vars
, decl_or_value dv
, hashval_t dvhash
)
1656 return shared_hash_htab (vars
)->find_slot_with_hash (dv
, dvhash
,
1657 shared_hash_shared (vars
)
1658 ? NO_INSERT
: INSERT
);
1661 static inline variable
**
1662 shared_hash_find_slot (shared_hash
*vars
, decl_or_value dv
)
1664 return shared_hash_find_slot_1 (vars
, dv
, dv_htab_hash (dv
));
1667 /* Return slot for DV only if it is already present in the hash table. */
1669 static inline variable
**
1670 shared_hash_find_slot_noinsert_1 (shared_hash
*vars
, decl_or_value dv
,
1673 return shared_hash_htab (vars
)->find_slot_with_hash (dv
, dvhash
, NO_INSERT
);
1676 static inline variable
**
1677 shared_hash_find_slot_noinsert (shared_hash
*vars
, decl_or_value dv
)
1679 return shared_hash_find_slot_noinsert_1 (vars
, dv
, dv_htab_hash (dv
));
1682 /* Return variable for DV or NULL if not already present in the hash
1685 static inline variable
*
1686 shared_hash_find_1 (shared_hash
*vars
, decl_or_value dv
, hashval_t dvhash
)
1688 return shared_hash_htab (vars
)->find_with_hash (dv
, dvhash
);
1691 static inline variable
*
1692 shared_hash_find (shared_hash
*vars
, decl_or_value dv
)
1694 return shared_hash_find_1 (vars
, dv
, dv_htab_hash (dv
));
1697 /* Return true if TVAL is better than CVAL as a canonival value. We
1698 choose lowest-numbered VALUEs, using the RTX address as a
1699 tie-breaker. The idea is to arrange them into a star topology,
1700 such that all of them are at most one step away from the canonical
1701 value, and the canonical value has backlinks to all of them, in
1702 addition to all the actual locations. We don't enforce this
1703 topology throughout the entire dataflow analysis, though.
1707 canon_value_cmp (rtx tval
, rtx cval
)
1710 || CSELIB_VAL_PTR (tval
)->uid
< CSELIB_VAL_PTR (cval
)->uid
;
1713 static bool dst_can_be_shared
;
1715 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1718 unshare_variable (dataflow_set
*set
, variable
**slot
, variable
*var
,
1719 enum var_init_status initialized
)
1724 new_var
= onepart_pool_allocate (var
->onepart
);
1725 new_var
->dv
= var
->dv
;
1726 new_var
->refcount
= 1;
1728 new_var
->n_var_parts
= var
->n_var_parts
;
1729 new_var
->onepart
= var
->onepart
;
1730 new_var
->in_changed_variables
= false;
1732 if (! flag_var_tracking_uninit
)
1733 initialized
= VAR_INIT_STATUS_INITIALIZED
;
1735 for (i
= 0; i
< var
->n_var_parts
; i
++)
1737 location_chain
*node
;
1738 location_chain
**nextp
;
1740 if (i
== 0 && var
->onepart
)
1742 /* One-part auxiliary data is only used while emitting
1743 notes, so propagate it to the new variable in the active
1744 dataflow set. If we're not emitting notes, this will be
1746 gcc_checking_assert (!VAR_LOC_1PAUX (var
) || emit_notes
);
1747 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (var
);
1748 VAR_LOC_1PAUX (var
) = NULL
;
1751 VAR_PART_OFFSET (new_var
, i
) = VAR_PART_OFFSET (var
, i
);
1752 nextp
= &new_var
->var_part
[i
].loc_chain
;
1753 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
1755 location_chain
*new_lc
;
1757 new_lc
= new location_chain
;
1758 new_lc
->next
= NULL
;
1759 if (node
->init
> initialized
)
1760 new_lc
->init
= node
->init
;
1762 new_lc
->init
= initialized
;
1763 if (node
->set_src
&& !(MEM_P (node
->set_src
)))
1764 new_lc
->set_src
= node
->set_src
;
1766 new_lc
->set_src
= NULL
;
1767 new_lc
->loc
= node
->loc
;
1770 nextp
= &new_lc
->next
;
1773 new_var
->var_part
[i
].cur_loc
= var
->var_part
[i
].cur_loc
;
1776 dst_can_be_shared
= false;
1777 if (shared_hash_shared (set
->vars
))
1778 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
, NO_INSERT
);
1779 else if (set
->traversed_vars
&& set
->vars
!= set
->traversed_vars
)
1780 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
1782 if (var
->in_changed_variables
)
1785 = changed_variables
->find_slot_with_hash (var
->dv
,
1786 dv_htab_hash (var
->dv
),
1788 gcc_assert (*cslot
== (void *) var
);
1789 var
->in_changed_variables
= false;
1790 variable_htab_free (var
);
1792 new_var
->in_changed_variables
= true;
1797 /* Copy all variables from hash table SRC to hash table DST. */
1800 vars_copy (variable_table_type
*dst
, variable_table_type
*src
)
1802 variable_iterator_type hi
;
1805 FOR_EACH_HASH_TABLE_ELEMENT (*src
, var
, variable
, hi
)
1809 dstp
= dst
->find_slot_with_hash (var
->dv
, dv_htab_hash (var
->dv
),
1815 /* Map a decl to its main debug decl. */
1818 var_debug_decl (tree decl
)
1820 if (decl
&& VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
1822 tree debugdecl
= DECL_DEBUG_EXPR (decl
);
1823 if (DECL_P (debugdecl
))
1830 /* Set the register LOC to contain DV, OFFSET. */
1833 var_reg_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1834 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
1835 enum insert_option iopt
)
1838 bool decl_p
= dv_is_decl_p (dv
);
1841 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
1843 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
1844 if (dv_as_opaque (node
->dv
) == dv_as_opaque (dv
)
1845 && node
->offset
== offset
)
1848 attrs_list_insert (&set
->regs
[REGNO (loc
)], dv
, offset
, loc
);
1849 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
1852 /* Return true if we should track a location that is OFFSET bytes from
1853 a variable. Store the constant offset in *OFFSET_OUT if so. */
1856 track_offset_p (poly_int64 offset
, HOST_WIDE_INT
*offset_out
)
1858 HOST_WIDE_INT const_offset
;
1859 if (!offset
.is_constant (&const_offset
)
1860 || !IN_RANGE (const_offset
, 0, MAX_VAR_PARTS
- 1))
1862 *offset_out
= const_offset
;
1866 /* Return the offset of a register that track_offset_p says we
1869 static HOST_WIDE_INT
1870 get_tracked_reg_offset (rtx loc
)
1872 HOST_WIDE_INT offset
;
1873 if (!track_offset_p (REG_OFFSET (loc
), &offset
))
1878 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1881 var_reg_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1884 tree decl
= REG_EXPR (loc
);
1885 HOST_WIDE_INT offset
= get_tracked_reg_offset (loc
);
1887 var_reg_decl_set (set
, loc
, initialized
,
1888 dv_from_decl (decl
), offset
, set_src
, INSERT
);
1891 static enum var_init_status
1892 get_init_value (dataflow_set
*set
, rtx loc
, decl_or_value dv
)
1896 enum var_init_status ret_val
= VAR_INIT_STATUS_UNKNOWN
;
1898 if (! flag_var_tracking_uninit
)
1899 return VAR_INIT_STATUS_INITIALIZED
;
1901 var
= shared_hash_find (set
->vars
, dv
);
1904 for (i
= 0; i
< var
->n_var_parts
&& ret_val
== VAR_INIT_STATUS_UNKNOWN
; i
++)
1906 location_chain
*nextp
;
1907 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
; nextp
= nextp
->next
)
1908 if (rtx_equal_p (nextp
->loc
, loc
))
1910 ret_val
= nextp
->init
;
1919 /* Delete current content of register LOC in dataflow set SET and set
1920 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1921 MODIFY is true, any other live copies of the same variable part are
1922 also deleted from the dataflow set, otherwise the variable part is
1923 assumed to be copied from another location holding the same
1927 var_reg_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
1928 enum var_init_status initialized
, rtx set_src
)
1930 tree decl
= REG_EXPR (loc
);
1931 HOST_WIDE_INT offset
= get_tracked_reg_offset (loc
);
1935 decl
= var_debug_decl (decl
);
1937 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
1938 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
1940 nextp
= &set
->regs
[REGNO (loc
)];
1941 for (node
= *nextp
; node
; node
= next
)
1944 if (dv_as_opaque (node
->dv
) != decl
|| node
->offset
!= offset
)
1946 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1953 nextp
= &node
->next
;
1957 clobber_variable_part (set
, loc
, dv_from_decl (decl
), offset
, set_src
);
1958 var_reg_set (set
, loc
, initialized
, set_src
);
1961 /* Delete the association of register LOC in dataflow set SET with any
1962 variables that aren't onepart. If CLOBBER is true, also delete any
1963 other live copies of the same variable part, and delete the
1964 association with onepart dvs too. */
1967 var_reg_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
1969 attrs
**nextp
= &set
->regs
[REGNO (loc
)];
1972 HOST_WIDE_INT offset
;
1973 if (clobber
&& track_offset_p (REG_OFFSET (loc
), &offset
))
1975 tree decl
= REG_EXPR (loc
);
1977 decl
= var_debug_decl (decl
);
1979 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
1982 for (node
= *nextp
; node
; node
= next
)
1985 if (clobber
|| !dv_onepart_p (node
->dv
))
1987 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1992 nextp
= &node
->next
;
1996 /* Delete content of register with number REGNO in dataflow set SET. */
1999 var_regno_delete (dataflow_set
*set
, int regno
)
2001 attrs
**reg
= &set
->regs
[regno
];
2004 for (node
= *reg
; node
; node
= next
)
2007 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
2013 /* Return true if I is the negated value of a power of two. */
2015 negative_power_of_two_p (HOST_WIDE_INT i
)
2017 unsigned HOST_WIDE_INT x
= -(unsigned HOST_WIDE_INT
)i
;
2018 return pow2_or_zerop (x
);
2021 /* Strip constant offsets and alignments off of LOC. Return the base
2025 vt_get_canonicalize_base (rtx loc
)
2027 while ((GET_CODE (loc
) == PLUS
2028 || GET_CODE (loc
) == AND
)
2029 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
2030 && (GET_CODE (loc
) != AND
2031 || negative_power_of_two_p (INTVAL (XEXP (loc
, 1)))))
2032 loc
= XEXP (loc
, 0);
2037 /* This caches canonicalized addresses for VALUEs, computed using
2038 information in the global cselib table. */
2039 static hash_map
<rtx
, rtx
> *global_get_addr_cache
;
2041 /* This caches canonicalized addresses for VALUEs, computed using
2042 information from the global cache and information pertaining to a
2043 basic block being analyzed. */
2044 static hash_map
<rtx
, rtx
> *local_get_addr_cache
;
2046 static rtx
vt_canonicalize_addr (dataflow_set
*, rtx
);
2048 /* Return the canonical address for LOC, that must be a VALUE, using a
2049 cached global equivalence or computing it and storing it in the
2053 get_addr_from_global_cache (rtx
const loc
)
2057 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2060 rtx
*slot
= &global_get_addr_cache
->get_or_insert (loc
, &existed
);
2064 x
= canon_rtx (get_addr (loc
));
2066 /* Tentative, avoiding infinite recursion. */
2071 rtx nx
= vt_canonicalize_addr (NULL
, x
);
2074 /* The table may have moved during recursion, recompute
2076 *global_get_addr_cache
->get (loc
) = x
= nx
;
2083 /* Return the canonical address for LOC, that must be a VALUE, using a
2084 cached local equivalence or computing it and storing it in the
2088 get_addr_from_local_cache (dataflow_set
*set
, rtx
const loc
)
2095 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2098 rtx
*slot
= &local_get_addr_cache
->get_or_insert (loc
, &existed
);
2102 x
= get_addr_from_global_cache (loc
);
2104 /* Tentative, avoiding infinite recursion. */
2107 /* Recurse to cache local expansion of X, or if we need to search
2108 for a VALUE in the expansion. */
2111 rtx nx
= vt_canonicalize_addr (set
, x
);
2114 slot
= local_get_addr_cache
->get (loc
);
2120 dv
= dv_from_rtx (x
);
2121 var
= shared_hash_find (set
->vars
, dv
);
2125 /* Look for an improved equivalent expression. */
2126 for (l
= var
->var_part
[0].loc_chain
; l
; l
= l
->next
)
2128 rtx base
= vt_get_canonicalize_base (l
->loc
);
2129 if (GET_CODE (base
) == VALUE
2130 && canon_value_cmp (base
, loc
))
2132 rtx nx
= vt_canonicalize_addr (set
, l
->loc
);
2135 slot
= local_get_addr_cache
->get (loc
);
2145 /* Canonicalize LOC using equivalences from SET in addition to those
2146 in the cselib static table. It expects a VALUE-based expression,
2147 and it will only substitute VALUEs with other VALUEs or
2148 function-global equivalences, so that, if two addresses have base
2149 VALUEs that are locally or globally related in ways that
2150 memrefs_conflict_p cares about, they will both canonicalize to
2151 expressions that have the same base VALUE.
2153 The use of VALUEs as canonical base addresses enables the canonical
2154 RTXs to remain unchanged globally, if they resolve to a constant,
2155 or throughout a basic block otherwise, so that they can be cached
2156 and the cache needs not be invalidated when REGs, MEMs or such
2160 vt_canonicalize_addr (dataflow_set
*set
, rtx oloc
)
2162 HOST_WIDE_INT ofst
= 0;
2163 machine_mode mode
= GET_MODE (oloc
);
2170 while (GET_CODE (loc
) == PLUS
2171 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2173 ofst
+= INTVAL (XEXP (loc
, 1));
2174 loc
= XEXP (loc
, 0);
2177 /* Alignment operations can't normally be combined, so just
2178 canonicalize the base and we're done. We'll normally have
2179 only one stack alignment anyway. */
2180 if (GET_CODE (loc
) == AND
2181 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
2182 && negative_power_of_two_p (INTVAL (XEXP (loc
, 1))))
2184 x
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2185 if (x
!= XEXP (loc
, 0))
2186 loc
= gen_rtx_AND (mode
, x
, XEXP (loc
, 1));
2190 if (GET_CODE (loc
) == VALUE
)
2193 loc
= get_addr_from_local_cache (set
, loc
);
2195 loc
= get_addr_from_global_cache (loc
);
2197 /* Consolidate plus_constants. */
2198 while (ofst
&& GET_CODE (loc
) == PLUS
2199 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2201 ofst
+= INTVAL (XEXP (loc
, 1));
2202 loc
= XEXP (loc
, 0);
2209 x
= canon_rtx (loc
);
2216 /* Add OFST back in. */
2219 /* Don't build new RTL if we can help it. */
2220 if (GET_CODE (oloc
) == PLUS
2221 && XEXP (oloc
, 0) == loc
2222 && INTVAL (XEXP (oloc
, 1)) == ofst
)
2225 loc
= plus_constant (mode
, loc
, ofst
);
2231 /* Return true iff there's a true dependence between MLOC and LOC.
2232 MADDR must be a canonicalized version of MLOC's address. */
2235 vt_canon_true_dep (dataflow_set
*set
, rtx mloc
, rtx maddr
, rtx loc
)
2237 if (GET_CODE (loc
) != MEM
)
2240 rtx addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2241 if (!canon_true_dependence (mloc
, GET_MODE (mloc
), maddr
, loc
, addr
))
2247 /* Hold parameters for the hashtab traversal function
2248 drop_overlapping_mem_locs, see below. */
2250 struct overlapping_mems
2256 /* Remove all MEMs that overlap with COMS->LOC from the location list
2257 of a hash table entry for a onepart variable. COMS->ADDR must be a
2258 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2259 canonicalized itself. */
2262 drop_overlapping_mem_locs (variable
**slot
, overlapping_mems
*coms
)
2264 dataflow_set
*set
= coms
->set
;
2265 rtx mloc
= coms
->loc
, addr
= coms
->addr
;
2266 variable
*var
= *slot
;
2268 if (var
->onepart
!= NOT_ONEPART
)
2270 location_chain
*loc
, **locp
;
2271 bool changed
= false;
2274 gcc_assert (var
->n_var_parts
== 1);
2276 if (shared_var_p (var
, set
->vars
))
2278 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
2279 if (vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2285 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
2287 gcc_assert (var
->n_var_parts
== 1);
2290 if (VAR_LOC_1PAUX (var
))
2291 cur_loc
= VAR_LOC_FROM (var
);
2293 cur_loc
= var
->var_part
[0].cur_loc
;
2295 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
2298 if (!vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2305 /* If we have deleted the location which was last emitted
2306 we have to emit new location so add the variable to set
2307 of changed variables. */
2308 if (cur_loc
== loc
->loc
)
2311 var
->var_part
[0].cur_loc
= NULL
;
2312 if (VAR_LOC_1PAUX (var
))
2313 VAR_LOC_FROM (var
) = NULL
;
2318 if (!var
->var_part
[0].loc_chain
)
2324 variable_was_changed (var
, set
);
2330 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2333 clobber_overlapping_mems (dataflow_set
*set
, rtx loc
)
2335 struct overlapping_mems coms
;
2337 gcc_checking_assert (GET_CODE (loc
) == MEM
);
2340 coms
.loc
= canon_rtx (loc
);
2341 coms
.addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2343 set
->traversed_vars
= set
->vars
;
2344 shared_hash_htab (set
->vars
)
2345 ->traverse
<overlapping_mems
*, drop_overlapping_mem_locs
> (&coms
);
2346 set
->traversed_vars
= NULL
;
2349 /* Set the location of DV, OFFSET as the MEM LOC. */
2352 var_mem_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2353 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
2354 enum insert_option iopt
)
2356 if (dv_is_decl_p (dv
))
2357 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
2359 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
2362 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2364 Adjust the address first if it is stack pointer based. */
2367 var_mem_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2370 tree decl
= MEM_EXPR (loc
);
2371 HOST_WIDE_INT offset
= int_mem_offset (loc
);
2373 var_mem_decl_set (set
, loc
, initialized
,
2374 dv_from_decl (decl
), offset
, set_src
, INSERT
);
2377 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2378 dataflow set SET to LOC. If MODIFY is true, any other live copies
2379 of the same variable part are also deleted from the dataflow set,
2380 otherwise the variable part is assumed to be copied from another
2381 location holding the same part.
2382 Adjust the address first if it is stack pointer based. */
2385 var_mem_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
2386 enum var_init_status initialized
, rtx set_src
)
2388 tree decl
= MEM_EXPR (loc
);
2389 HOST_WIDE_INT offset
= int_mem_offset (loc
);
2391 clobber_overlapping_mems (set
, loc
);
2392 decl
= var_debug_decl (decl
);
2394 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
2395 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
2398 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, set_src
);
2399 var_mem_set (set
, loc
, initialized
, set_src
);
2402 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2403 true, also delete any other live copies of the same variable part.
2404 Adjust the address first if it is stack pointer based. */
2407 var_mem_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
2409 tree decl
= MEM_EXPR (loc
);
2410 HOST_WIDE_INT offset
= int_mem_offset (loc
);
2412 clobber_overlapping_mems (set
, loc
);
2413 decl
= var_debug_decl (decl
);
2415 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
2416 delete_variable_part (set
, loc
, dv_from_decl (decl
), offset
);
2419 /* Return true if LOC should not be expanded for location expressions,
2423 unsuitable_loc (rtx loc
)
2425 switch (GET_CODE (loc
))
2439 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2443 val_bind (dataflow_set
*set
, rtx val
, rtx loc
, bool modified
)
2448 var_regno_delete (set
, REGNO (loc
));
2449 var_reg_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2450 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2452 else if (MEM_P (loc
))
2454 struct elt_loc_list
*l
= CSELIB_VAL_PTR (val
)->locs
;
2457 clobber_overlapping_mems (set
, loc
);
2459 if (l
&& GET_CODE (l
->loc
) == VALUE
)
2460 l
= canonical_cselib_val (CSELIB_VAL_PTR (l
->loc
))->locs
;
2462 /* If this MEM is a global constant, we don't need it in the
2463 dynamic tables. ??? We should test this before emitting the
2464 micro-op in the first place. */
2466 if (GET_CODE (l
->loc
) == MEM
&& XEXP (l
->loc
, 0) == XEXP (loc
, 0))
2472 var_mem_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2473 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2477 /* Other kinds of equivalences are necessarily static, at least
2478 so long as we do not perform substitutions while merging
2481 set_variable_part (set
, loc
, dv_from_value (val
), 0,
2482 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2486 /* Bind a value to a location it was just stored in. If MODIFIED
2487 holds, assume the location was modified, detaching it from any
2488 values bound to it. */
2491 val_store (dataflow_set
*set
, rtx val
, rtx loc
, rtx_insn
*insn
,
2494 cselib_val
*v
= CSELIB_VAL_PTR (val
);
2496 gcc_assert (cselib_preserved_value_p (v
));
2500 fprintf (dump_file
, "%i: ", insn
? INSN_UID (insn
) : 0);
2501 print_inline_rtx (dump_file
, loc
, 0);
2502 fprintf (dump_file
, " evaluates to ");
2503 print_inline_rtx (dump_file
, val
, 0);
2506 struct elt_loc_list
*l
;
2507 for (l
= v
->locs
; l
; l
= l
->next
)
2509 fprintf (dump_file
, "\n%i: ", INSN_UID (l
->setting_insn
));
2510 print_inline_rtx (dump_file
, l
->loc
, 0);
2513 fprintf (dump_file
, "\n");
2516 gcc_checking_assert (!unsuitable_loc (loc
));
2518 val_bind (set
, val
, loc
, modified
);
2521 /* Clear (canonical address) slots that reference X. */
2524 local_get_addr_clear_given_value (rtx
const &, rtx
*slot
, rtx x
)
2526 if (vt_get_canonicalize_base (*slot
) == x
)
2531 /* Reset this node, detaching all its equivalences. Return the slot
2532 in the variable hash table that holds dv, if there is one. */
2535 val_reset (dataflow_set
*set
, decl_or_value dv
)
2537 variable
*var
= shared_hash_find (set
->vars
, dv
) ;
2538 location_chain
*node
;
2541 if (!var
|| !var
->n_var_parts
)
2544 gcc_assert (var
->n_var_parts
== 1);
2546 if (var
->onepart
== ONEPART_VALUE
)
2548 rtx x
= dv_as_value (dv
);
2550 /* Relationships in the global cache don't change, so reset the
2551 local cache entry only. */
2552 rtx
*slot
= local_get_addr_cache
->get (x
);
2555 /* If the value resolved back to itself, odds are that other
2556 values may have cached it too. These entries now refer
2557 to the old X, so detach them too. Entries that used the
2558 old X but resolved to something else remain ok as long as
2559 that something else isn't also reset. */
2561 local_get_addr_cache
2562 ->traverse
<rtx
, local_get_addr_clear_given_value
> (x
);
2568 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2569 if (GET_CODE (node
->loc
) == VALUE
2570 && canon_value_cmp (node
->loc
, cval
))
2573 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2574 if (GET_CODE (node
->loc
) == VALUE
&& cval
!= node
->loc
)
2576 /* Redirect the equivalence link to the new canonical
2577 value, or simply remove it if it would point at
2580 set_variable_part (set
, cval
, dv_from_value (node
->loc
),
2581 0, node
->init
, node
->set_src
, NO_INSERT
);
2582 delete_variable_part (set
, dv_as_value (dv
),
2583 dv_from_value (node
->loc
), 0);
2588 decl_or_value cdv
= dv_from_value (cval
);
2590 /* Keep the remaining values connected, accumulating links
2591 in the canonical value. */
2592 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2594 if (node
->loc
== cval
)
2596 else if (GET_CODE (node
->loc
) == REG
)
2597 var_reg_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2598 node
->set_src
, NO_INSERT
);
2599 else if (GET_CODE (node
->loc
) == MEM
)
2600 var_mem_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2601 node
->set_src
, NO_INSERT
);
2603 set_variable_part (set
, node
->loc
, cdv
, 0,
2604 node
->init
, node
->set_src
, NO_INSERT
);
2608 /* We remove this last, to make sure that the canonical value is not
2609 removed to the point of requiring reinsertion. */
2611 delete_variable_part (set
, dv_as_value (dv
), dv_from_value (cval
), 0);
2613 clobber_variable_part (set
, NULL
, dv
, 0, NULL
);
2616 /* Find the values in a given location and map the val to another
2617 value, if it is unique, or add the location as one holding the
2621 val_resolve (dataflow_set
*set
, rtx val
, rtx loc
, rtx_insn
*insn
)
2623 decl_or_value dv
= dv_from_value (val
);
2625 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2628 fprintf (dump_file
, "%i: ", INSN_UID (insn
));
2630 fprintf (dump_file
, "head: ");
2631 print_inline_rtx (dump_file
, val
, 0);
2632 fputs (" is at ", dump_file
);
2633 print_inline_rtx (dump_file
, loc
, 0);
2634 fputc ('\n', dump_file
);
2637 val_reset (set
, dv
);
2639 gcc_checking_assert (!unsuitable_loc (loc
));
2643 attrs
*node
, *found
= NULL
;
2645 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
2646 if (dv_is_value_p (node
->dv
)
2647 && GET_MODE (dv_as_value (node
->dv
)) == GET_MODE (loc
))
2651 /* Map incoming equivalences. ??? Wouldn't it be nice if
2652 we just started sharing the location lists? Maybe a
2653 circular list ending at the value itself or some
2655 set_variable_part (set
, dv_as_value (node
->dv
),
2656 dv_from_value (val
), node
->offset
,
2657 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2658 set_variable_part (set
, val
, node
->dv
, node
->offset
,
2659 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2662 /* If we didn't find any equivalence, we need to remember that
2663 this value is held in the named register. */
2667 /* ??? Attempt to find and merge equivalent MEMs or other
2670 val_bind (set
, val
, loc
, false);
2673 /* Initialize dataflow set SET to be empty.
2674 VARS_SIZE is the initial size of hash table VARS. */
2677 dataflow_set_init (dataflow_set
*set
)
2679 init_attrs_list_set (set
->regs
);
2680 set
->vars
= shared_hash_copy (empty_shared_hash
);
2681 set
->stack_adjust
= 0;
2682 set
->traversed_vars
= NULL
;
2685 /* Delete the contents of dataflow set SET. */
2688 dataflow_set_clear (dataflow_set
*set
)
2692 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2693 attrs_list_clear (&set
->regs
[i
]);
2695 shared_hash_destroy (set
->vars
);
2696 set
->vars
= shared_hash_copy (empty_shared_hash
);
2699 /* Copy the contents of dataflow set SRC to DST. */
2702 dataflow_set_copy (dataflow_set
*dst
, dataflow_set
*src
)
2706 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2707 attrs_list_copy (&dst
->regs
[i
], src
->regs
[i
]);
2709 shared_hash_destroy (dst
->vars
);
2710 dst
->vars
= shared_hash_copy (src
->vars
);
2711 dst
->stack_adjust
= src
->stack_adjust
;
2714 /* Information for merging lists of locations for a given offset of variable.
2716 struct variable_union_info
2718 /* Node of the location chain. */
2721 /* The sum of positions in the input chains. */
2724 /* The position in the chain of DST dataflow set. */
2728 /* Buffer for location list sorting and its allocated size. */
2729 static struct variable_union_info
*vui_vec
;
2730 static int vui_allocated
;
2732 /* Compare function for qsort, order the structures by POS element. */
2735 variable_union_info_cmp_pos (const void *n1
, const void *n2
)
2737 const struct variable_union_info
*const i1
=
2738 (const struct variable_union_info
*) n1
;
2739 const struct variable_union_info
*const i2
=
2740 ( const struct variable_union_info
*) n2
;
2742 if (i1
->pos
!= i2
->pos
)
2743 return i1
->pos
- i2
->pos
;
2745 return (i1
->pos_dst
- i2
->pos_dst
);
2748 /* Compute union of location parts of variable *SLOT and the same variable
2749 from hash table DATA. Compute "sorted" union of the location chains
2750 for common offsets, i.e. the locations of a variable part are sorted by
2751 a priority where the priority is the sum of the positions in the 2 chains
2752 (if a location is only in one list the position in the second list is
2753 defined to be larger than the length of the chains).
2754 When we are updating the location parts the newest location is in the
2755 beginning of the chain, so when we do the described "sorted" union
2756 we keep the newest locations in the beginning. */
2759 variable_union (variable
*src
, dataflow_set
*set
)
2765 dstp
= shared_hash_find_slot (set
->vars
, src
->dv
);
2766 if (!dstp
|| !*dstp
)
2770 dst_can_be_shared
= false;
2772 dstp
= shared_hash_find_slot_unshare (&set
->vars
, src
->dv
, INSERT
);
2776 /* Continue traversing the hash table. */
2782 gcc_assert (src
->n_var_parts
);
2783 gcc_checking_assert (src
->onepart
== dst
->onepart
);
2785 /* We can combine one-part variables very efficiently, because their
2786 entries are in canonical order. */
2789 location_chain
**nodep
, *dnode
, *snode
;
2791 gcc_assert (src
->n_var_parts
== 1
2792 && dst
->n_var_parts
== 1);
2794 snode
= src
->var_part
[0].loc_chain
;
2797 restart_onepart_unshared
:
2798 nodep
= &dst
->var_part
[0].loc_chain
;
2804 int r
= dnode
? loc_cmp (dnode
->loc
, snode
->loc
) : 1;
2808 location_chain
*nnode
;
2810 if (shared_var_p (dst
, set
->vars
))
2812 dstp
= unshare_variable (set
, dstp
, dst
,
2813 VAR_INIT_STATUS_INITIALIZED
);
2815 goto restart_onepart_unshared
;
2818 *nodep
= nnode
= new location_chain
;
2819 nnode
->loc
= snode
->loc
;
2820 nnode
->init
= snode
->init
;
2821 if (!snode
->set_src
|| MEM_P (snode
->set_src
))
2822 nnode
->set_src
= NULL
;
2824 nnode
->set_src
= snode
->set_src
;
2825 nnode
->next
= dnode
;
2829 gcc_checking_assert (rtx_equal_p (dnode
->loc
, snode
->loc
));
2832 snode
= snode
->next
;
2834 nodep
= &dnode
->next
;
2841 gcc_checking_assert (!src
->onepart
);
2843 /* Count the number of location parts, result is K. */
2844 for (i
= 0, j
= 0, k
= 0;
2845 i
< src
->n_var_parts
&& j
< dst
->n_var_parts
; k
++)
2847 if (VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2852 else if (VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
2857 k
+= src
->n_var_parts
- i
;
2858 k
+= dst
->n_var_parts
- j
;
2860 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2861 thus there are at most MAX_VAR_PARTS different offsets. */
2862 gcc_checking_assert (dst
->onepart
? k
== 1 : k
<= MAX_VAR_PARTS
);
2864 if (dst
->n_var_parts
!= k
&& shared_var_p (dst
, set
->vars
))
2866 dstp
= unshare_variable (set
, dstp
, dst
, VAR_INIT_STATUS_UNKNOWN
);
2870 i
= src
->n_var_parts
- 1;
2871 j
= dst
->n_var_parts
- 1;
2872 dst
->n_var_parts
= k
;
2874 for (k
--; k
>= 0; k
--)
2876 location_chain
*node
, *node2
;
2878 if (i
>= 0 && j
>= 0
2879 && VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2881 /* Compute the "sorted" union of the chains, i.e. the locations which
2882 are in both chains go first, they are sorted by the sum of
2883 positions in the chains. */
2886 struct variable_union_info
*vui
;
2888 /* If DST is shared compare the location chains.
2889 If they are different we will modify the chain in DST with
2890 high probability so make a copy of DST. */
2891 if (shared_var_p (dst
, set
->vars
))
2893 for (node
= src
->var_part
[i
].loc_chain
,
2894 node2
= dst
->var_part
[j
].loc_chain
; node
&& node2
;
2895 node
= node
->next
, node2
= node2
->next
)
2897 if (!((REG_P (node2
->loc
)
2898 && REG_P (node
->loc
)
2899 && REGNO (node2
->loc
) == REGNO (node
->loc
))
2900 || rtx_equal_p (node2
->loc
, node
->loc
)))
2902 if (node2
->init
< node
->init
)
2903 node2
->init
= node
->init
;
2909 dstp
= unshare_variable (set
, dstp
, dst
,
2910 VAR_INIT_STATUS_UNKNOWN
);
2911 dst
= (variable
*)*dstp
;
2916 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2919 for (node
= dst
->var_part
[j
].loc_chain
; node
; node
= node
->next
)
2924 /* The most common case, much simpler, no qsort is needed. */
2925 location_chain
*dstnode
= dst
->var_part
[j
].loc_chain
;
2926 dst
->var_part
[k
].loc_chain
= dstnode
;
2927 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
2929 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2930 if (!((REG_P (dstnode
->loc
)
2931 && REG_P (node
->loc
)
2932 && REGNO (dstnode
->loc
) == REGNO (node
->loc
))
2933 || rtx_equal_p (dstnode
->loc
, node
->loc
)))
2935 location_chain
*new_node
;
2937 /* Copy the location from SRC. */
2938 new_node
= new location_chain
;
2939 new_node
->loc
= node
->loc
;
2940 new_node
->init
= node
->init
;
2941 if (!node
->set_src
|| MEM_P (node
->set_src
))
2942 new_node
->set_src
= NULL
;
2944 new_node
->set_src
= node
->set_src
;
2945 node2
->next
= new_node
;
2952 if (src_l
+ dst_l
> vui_allocated
)
2954 vui_allocated
= MAX (vui_allocated
* 2, src_l
+ dst_l
);
2955 vui_vec
= XRESIZEVEC (struct variable_union_info
, vui_vec
,
2960 /* Fill in the locations from DST. */
2961 for (node
= dst
->var_part
[j
].loc_chain
, jj
= 0; node
;
2962 node
= node
->next
, jj
++)
2965 vui
[jj
].pos_dst
= jj
;
2967 /* Pos plus value larger than a sum of 2 valid positions. */
2968 vui
[jj
].pos
= jj
+ src_l
+ dst_l
;
2971 /* Fill in the locations from SRC. */
2973 for (node
= src
->var_part
[i
].loc_chain
, ii
= 0; node
;
2974 node
= node
->next
, ii
++)
2976 /* Find location from NODE. */
2977 for (jj
= 0; jj
< dst_l
; jj
++)
2979 if ((REG_P (vui
[jj
].lc
->loc
)
2980 && REG_P (node
->loc
)
2981 && REGNO (vui
[jj
].lc
->loc
) == REGNO (node
->loc
))
2982 || rtx_equal_p (vui
[jj
].lc
->loc
, node
->loc
))
2984 vui
[jj
].pos
= jj
+ ii
;
2988 if (jj
>= dst_l
) /* The location has not been found. */
2990 location_chain
*new_node
;
2992 /* Copy the location from SRC. */
2993 new_node
= new location_chain
;
2994 new_node
->loc
= node
->loc
;
2995 new_node
->init
= node
->init
;
2996 if (!node
->set_src
|| MEM_P (node
->set_src
))
2997 new_node
->set_src
= NULL
;
2999 new_node
->set_src
= node
->set_src
;
3000 vui
[n
].lc
= new_node
;
3001 vui
[n
].pos_dst
= src_l
+ dst_l
;
3002 vui
[n
].pos
= ii
+ src_l
+ dst_l
;
3009 /* Special case still very common case. For dst_l == 2
3010 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3011 vui[i].pos == i + src_l + dst_l. */
3012 if (vui
[0].pos
> vui
[1].pos
)
3014 /* Order should be 1, 0, 2... */
3015 dst
->var_part
[k
].loc_chain
= vui
[1].lc
;
3016 vui
[1].lc
->next
= vui
[0].lc
;
3019 vui
[0].lc
->next
= vui
[2].lc
;
3020 vui
[n
- 1].lc
->next
= NULL
;
3023 vui
[0].lc
->next
= NULL
;
3028 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
3029 if (n
>= 3 && vui
[2].pos
< vui
[1].pos
)
3031 /* Order should be 0, 2, 1, 3... */
3032 vui
[0].lc
->next
= vui
[2].lc
;
3033 vui
[2].lc
->next
= vui
[1].lc
;
3036 vui
[1].lc
->next
= vui
[3].lc
;
3037 vui
[n
- 1].lc
->next
= NULL
;
3040 vui
[1].lc
->next
= NULL
;
3045 /* Order should be 0, 1, 2... */
3047 vui
[n
- 1].lc
->next
= NULL
;
3050 for (; ii
< n
; ii
++)
3051 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3055 qsort (vui
, n
, sizeof (struct variable_union_info
),
3056 variable_union_info_cmp_pos
);
3058 /* Reconnect the nodes in sorted order. */
3059 for (ii
= 1; ii
< n
; ii
++)
3060 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3061 vui
[n
- 1].lc
->next
= NULL
;
3062 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
3065 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
3070 else if ((i
>= 0 && j
>= 0
3071 && VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
3074 dst
->var_part
[k
] = dst
->var_part
[j
];
3077 else if ((i
>= 0 && j
>= 0
3078 && VAR_PART_OFFSET (src
, i
) > VAR_PART_OFFSET (dst
, j
))
3081 location_chain
**nextp
;
3083 /* Copy the chain from SRC. */
3084 nextp
= &dst
->var_part
[k
].loc_chain
;
3085 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3087 location_chain
*new_lc
;
3089 new_lc
= new location_chain
;
3090 new_lc
->next
= NULL
;
3091 new_lc
->init
= node
->init
;
3092 if (!node
->set_src
|| MEM_P (node
->set_src
))
3093 new_lc
->set_src
= NULL
;
3095 new_lc
->set_src
= node
->set_src
;
3096 new_lc
->loc
= node
->loc
;
3099 nextp
= &new_lc
->next
;
3102 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (src
, i
);
3105 dst
->var_part
[k
].cur_loc
= NULL
;
3108 if (flag_var_tracking_uninit
)
3109 for (i
= 0; i
< src
->n_var_parts
&& i
< dst
->n_var_parts
; i
++)
3111 location_chain
*node
, *node2
;
3112 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3113 for (node2
= dst
->var_part
[i
].loc_chain
; node2
; node2
= node2
->next
)
3114 if (rtx_equal_p (node
->loc
, node2
->loc
))
3116 if (node
->init
> node2
->init
)
3117 node2
->init
= node
->init
;
3121 /* Continue traversing the hash table. */
3125 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3128 dataflow_set_union (dataflow_set
*dst
, dataflow_set
*src
)
3132 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3133 attrs_list_union (&dst
->regs
[i
], src
->regs
[i
]);
3135 if (dst
->vars
== empty_shared_hash
)
3137 shared_hash_destroy (dst
->vars
);
3138 dst
->vars
= shared_hash_copy (src
->vars
);
3142 variable_iterator_type hi
;
3145 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src
->vars
),
3147 variable_union (var
, dst
);
3151 /* Whether the value is currently being expanded. */
3152 #define VALUE_RECURSED_INTO(x) \
3153 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3155 /* Whether no expansion was found, saving useless lookups.
3156 It must only be set when VALUE_CHANGED is clear. */
3157 #define NO_LOC_P(x) \
3158 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3160 /* Whether cur_loc in the value needs to be (re)computed. */
3161 #define VALUE_CHANGED(x) \
3162 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3163 /* Whether cur_loc in the decl needs to be (re)computed. */
3164 #define DECL_CHANGED(x) TREE_VISITED (x)
3166 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3167 user DECLs, this means they're in changed_variables. Values and
3168 debug exprs may be left with this flag set if no user variable
3169 requires them to be evaluated. */
3172 set_dv_changed (decl_or_value dv
, bool newv
)
3174 switch (dv_onepart_p (dv
))
3178 NO_LOC_P (dv_as_value (dv
)) = false;
3179 VALUE_CHANGED (dv_as_value (dv
)) = newv
;
3184 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv
))) = false;
3188 DECL_CHANGED (dv_as_decl (dv
)) = newv
;
3193 /* Return true if DV needs to have its cur_loc recomputed. */
3196 dv_changed_p (decl_or_value dv
)
3198 return (dv_is_value_p (dv
)
3199 ? VALUE_CHANGED (dv_as_value (dv
))
3200 : DECL_CHANGED (dv_as_decl (dv
)));
3203 /* Return a location list node whose loc is rtx_equal to LOC, in the
3204 location list of a one-part variable or value VAR, or in that of
3205 any values recursively mentioned in the location lists. VARS must
3206 be in star-canonical form. */
3208 static location_chain
*
3209 find_loc_in_1pdv (rtx loc
, variable
*var
, variable_table_type
*vars
)
3211 location_chain
*node
;
3212 enum rtx_code loc_code
;
3217 gcc_checking_assert (var
->onepart
);
3219 if (!var
->n_var_parts
)
3222 gcc_checking_assert (loc
!= dv_as_opaque (var
->dv
));
3224 loc_code
= GET_CODE (loc
);
3225 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3230 if (GET_CODE (node
->loc
) != loc_code
)
3232 if (GET_CODE (node
->loc
) != VALUE
)
3235 else if (loc
== node
->loc
)
3237 else if (loc_code
!= VALUE
)
3239 if (rtx_equal_p (loc
, node
->loc
))
3244 /* Since we're in star-canonical form, we don't need to visit
3245 non-canonical nodes: one-part variables and non-canonical
3246 values would only point back to the canonical node. */
3247 if (dv_is_value_p (var
->dv
)
3248 && !canon_value_cmp (node
->loc
, dv_as_value (var
->dv
)))
3250 /* Skip all subsequent VALUEs. */
3251 while (node
->next
&& GET_CODE (node
->next
->loc
) == VALUE
)
3254 gcc_checking_assert (!canon_value_cmp (node
->loc
,
3255 dv_as_value (var
->dv
)));
3256 if (loc
== node
->loc
)
3262 gcc_checking_assert (node
== var
->var_part
[0].loc_chain
);
3263 gcc_checking_assert (!node
->next
);
3265 dv
= dv_from_value (node
->loc
);
3266 rvar
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
3267 return find_loc_in_1pdv (loc
, rvar
, vars
);
3270 /* ??? Gotta look in cselib_val locations too. */
3275 /* Hash table iteration argument passed to variable_merge. */
3278 /* The set in which the merge is to be inserted. */
3280 /* The set that we're iterating in. */
3282 /* The set that may contain the other dv we are to merge with. */
3284 /* Number of onepart dvs in src. */
3285 int src_onepart_cnt
;
3288 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3289 loc_cmp order, and it is maintained as such. */
3292 insert_into_intersection (location_chain
**nodep
, rtx loc
,
3293 enum var_init_status status
)
3295 location_chain
*node
;
3298 for (node
= *nodep
; node
; nodep
= &node
->next
, node
= *nodep
)
3299 if ((r
= loc_cmp (node
->loc
, loc
)) == 0)
3301 node
->init
= MIN (node
->init
, status
);
3307 node
= new location_chain
;
3310 node
->set_src
= NULL
;
3311 node
->init
= status
;
3312 node
->next
= *nodep
;
3316 /* Insert in DEST the intersection of the locations present in both
3317 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3318 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3322 intersect_loc_chains (rtx val
, location_chain
**dest
, struct dfset_merge
*dsm
,
3323 location_chain
*s1node
, variable
*s2var
)
3325 dataflow_set
*s1set
= dsm
->cur
;
3326 dataflow_set
*s2set
= dsm
->src
;
3327 location_chain
*found
;
3331 location_chain
*s2node
;
3333 gcc_checking_assert (s2var
->onepart
);
3335 if (s2var
->n_var_parts
)
3337 s2node
= s2var
->var_part
[0].loc_chain
;
3339 for (; s1node
&& s2node
;
3340 s1node
= s1node
->next
, s2node
= s2node
->next
)
3341 if (s1node
->loc
!= s2node
->loc
)
3343 else if (s1node
->loc
== val
)
3346 insert_into_intersection (dest
, s1node
->loc
,
3347 MIN (s1node
->init
, s2node
->init
));
3351 for (; s1node
; s1node
= s1node
->next
)
3353 if (s1node
->loc
== val
)
3356 if ((found
= find_loc_in_1pdv (s1node
->loc
, s2var
,
3357 shared_hash_htab (s2set
->vars
))))
3359 insert_into_intersection (dest
, s1node
->loc
,
3360 MIN (s1node
->init
, found
->init
));
3364 if (GET_CODE (s1node
->loc
) == VALUE
3365 && !VALUE_RECURSED_INTO (s1node
->loc
))
3367 decl_or_value dv
= dv_from_value (s1node
->loc
);
3368 variable
*svar
= shared_hash_find (s1set
->vars
, dv
);
3371 if (svar
->n_var_parts
== 1)
3373 VALUE_RECURSED_INTO (s1node
->loc
) = true;
3374 intersect_loc_chains (val
, dest
, dsm
,
3375 svar
->var_part
[0].loc_chain
,
3377 VALUE_RECURSED_INTO (s1node
->loc
) = false;
3382 /* ??? gotta look in cselib_val locations too. */
3384 /* ??? if the location is equivalent to any location in src,
3385 searched recursively
3387 add to dst the values needed to represent the equivalence
3389 telling whether locations S is equivalent to another dv's
3392 for each location D in the list
3394 if S and D satisfy rtx_equal_p, then it is present
3396 else if D is a value, recurse without cycles
3398 else if S and D have the same CODE and MODE
3400 for each operand oS and the corresponding oD
3402 if oS and oD are not equivalent, then S an D are not equivalent
3404 else if they are RTX vectors
3406 if any vector oS element is not equivalent to its respective oD,
3407 then S and D are not equivalent
3415 /* Return -1 if X should be before Y in a location list for a 1-part
3416 variable, 1 if Y should be before X, and 0 if they're equivalent
3417 and should not appear in the list. */
3420 loc_cmp (rtx x
, rtx y
)
3423 RTX_CODE code
= GET_CODE (x
);
3433 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3434 if (REGNO (x
) == REGNO (y
))
3436 else if (REGNO (x
) < REGNO (y
))
3449 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3450 return loc_cmp (XEXP (x
, 0), XEXP (y
, 0));
3456 if (GET_CODE (x
) == VALUE
)
3458 if (GET_CODE (y
) != VALUE
)
3460 /* Don't assert the modes are the same, that is true only
3461 when not recursing. (subreg:QI (value:SI 1:1) 0)
3462 and (subreg:QI (value:DI 2:2) 0) can be compared,
3463 even when the modes are different. */
3464 if (canon_value_cmp (x
, y
))
3470 if (GET_CODE (y
) == VALUE
)
3473 /* Entry value is the least preferable kind of expression. */
3474 if (GET_CODE (x
) == ENTRY_VALUE
)
3476 if (GET_CODE (y
) != ENTRY_VALUE
)
3478 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3479 return loc_cmp (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
3482 if (GET_CODE (y
) == ENTRY_VALUE
)
3485 if (GET_CODE (x
) == GET_CODE (y
))
3486 /* Compare operands below. */;
3487 else if (GET_CODE (x
) < GET_CODE (y
))
3492 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3494 if (GET_CODE (x
) == DEBUG_EXPR
)
3496 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3497 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)))
3499 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3500 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)));
3504 fmt
= GET_RTX_FORMAT (code
);
3505 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
3509 if (XWINT (x
, i
) == XWINT (y
, i
))
3511 else if (XWINT (x
, i
) < XWINT (y
, i
))
3518 if (XINT (x
, i
) == XINT (y
, i
))
3520 else if (XINT (x
, i
) < XINT (y
, i
))
3527 /* Compare the vector length first. */
3528 if (XVECLEN (x
, i
) == XVECLEN (y
, i
))
3529 /* Compare the vectors elements. */;
3530 else if (XVECLEN (x
, i
) < XVECLEN (y
, i
))
3535 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3536 if ((r
= loc_cmp (XVECEXP (x
, i
, j
),
3537 XVECEXP (y
, i
, j
))))
3542 if ((r
= loc_cmp (XEXP (x
, i
), XEXP (y
, i
))))
3548 if (XSTR (x
, i
) == XSTR (y
, i
))
3554 if ((r
= strcmp (XSTR (x
, i
), XSTR (y
, i
))) == 0)
3562 /* These are just backpointers, so they don't matter. */
3569 /* It is believed that rtx's at this level will never
3570 contain anything but integers and other rtx's,
3571 except for within LABEL_REFs and SYMBOL_REFs. */
3575 if (CONST_WIDE_INT_P (x
))
3577 /* Compare the vector length first. */
3578 if (CONST_WIDE_INT_NUNITS (x
) >= CONST_WIDE_INT_NUNITS (y
))
3580 else if (CONST_WIDE_INT_NUNITS (x
) < CONST_WIDE_INT_NUNITS (y
))
3583 /* Compare the vectors elements. */;
3584 for (j
= CONST_WIDE_INT_NUNITS (x
) - 1; j
>= 0 ; j
--)
3586 if (CONST_WIDE_INT_ELT (x
, j
) < CONST_WIDE_INT_ELT (y
, j
))
3588 if (CONST_WIDE_INT_ELT (x
, j
) > CONST_WIDE_INT_ELT (y
, j
))
3596 /* Check the order of entries in one-part variables. */
3599 canonicalize_loc_order_check (variable
**slot
,
3600 dataflow_set
*data ATTRIBUTE_UNUSED
)
3602 variable
*var
= *slot
;
3603 location_chain
*node
, *next
;
3605 #ifdef ENABLE_RTL_CHECKING
3607 for (i
= 0; i
< var
->n_var_parts
; i
++)
3608 gcc_assert (var
->var_part
[0].cur_loc
== NULL
);
3609 gcc_assert (!var
->in_changed_variables
);
3615 gcc_assert (var
->n_var_parts
== 1);
3616 node
= var
->var_part
[0].loc_chain
;
3619 while ((next
= node
->next
))
3621 gcc_assert (loc_cmp (node
->loc
, next
->loc
) < 0);
3628 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3629 more likely to be chosen as canonical for an equivalence set.
3630 Ensure less likely values can reach more likely neighbors, making
3631 the connections bidirectional. */
3634 canonicalize_values_mark (variable
**slot
, dataflow_set
*set
)
3636 variable
*var
= *slot
;
3637 decl_or_value dv
= var
->dv
;
3639 location_chain
*node
;
3641 if (!dv_is_value_p (dv
))
3644 gcc_checking_assert (var
->n_var_parts
== 1);
3646 val
= dv_as_value (dv
);
3648 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3649 if (GET_CODE (node
->loc
) == VALUE
)
3651 if (canon_value_cmp (node
->loc
, val
))
3652 VALUE_RECURSED_INTO (val
) = true;
3655 decl_or_value odv
= dv_from_value (node
->loc
);
3657 oslot
= shared_hash_find_slot_noinsert (set
->vars
, odv
);
3659 set_slot_part (set
, val
, oslot
, odv
, 0,
3660 node
->init
, NULL_RTX
);
3662 VALUE_RECURSED_INTO (node
->loc
) = true;
3669 /* Remove redundant entries from equivalence lists in onepart
3670 variables, canonicalizing equivalence sets into star shapes. */
3673 canonicalize_values_star (variable
**slot
, dataflow_set
*set
)
3675 variable
*var
= *slot
;
3676 decl_or_value dv
= var
->dv
;
3677 location_chain
*node
;
3687 gcc_checking_assert (var
->n_var_parts
== 1);
3689 if (dv_is_value_p (dv
))
3691 cval
= dv_as_value (dv
);
3692 if (!VALUE_RECURSED_INTO (cval
))
3694 VALUE_RECURSED_INTO (cval
) = false;
3704 gcc_assert (var
->n_var_parts
== 1);
3706 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3707 if (GET_CODE (node
->loc
) == VALUE
)
3710 if (VALUE_RECURSED_INTO (node
->loc
))
3712 if (canon_value_cmp (node
->loc
, cval
))
3721 if (!has_marks
|| dv_is_decl_p (dv
))
3724 /* Keep it marked so that we revisit it, either after visiting a
3725 child node, or after visiting a new parent that might be
3727 VALUE_RECURSED_INTO (val
) = true;
3729 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3730 if (GET_CODE (node
->loc
) == VALUE
3731 && VALUE_RECURSED_INTO (node
->loc
))
3735 VALUE_RECURSED_INTO (cval
) = false;
3736 dv
= dv_from_value (cval
);
3737 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
3740 gcc_assert (dv_is_decl_p (var
->dv
));
3741 /* The canonical value was reset and dropped.
3743 clobber_variable_part (set
, NULL
, var
->dv
, 0, NULL
);
3747 gcc_assert (dv_is_value_p (var
->dv
));
3748 if (var
->n_var_parts
== 0)
3750 gcc_assert (var
->n_var_parts
== 1);
3754 VALUE_RECURSED_INTO (val
) = false;
3759 /* Push values to the canonical one. */
3760 cdv
= dv_from_value (cval
);
3761 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3763 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3764 if (node
->loc
!= cval
)
3766 cslot
= set_slot_part (set
, node
->loc
, cslot
, cdv
, 0,
3767 node
->init
, NULL_RTX
);
3768 if (GET_CODE (node
->loc
) == VALUE
)
3770 decl_or_value ndv
= dv_from_value (node
->loc
);
3772 set_variable_part (set
, cval
, ndv
, 0, node
->init
, NULL_RTX
,
3775 if (canon_value_cmp (node
->loc
, val
))
3777 /* If it could have been a local minimum, it's not any more,
3778 since it's now neighbor to cval, so it may have to push
3779 to it. Conversely, if it wouldn't have prevailed over
3780 val, then whatever mark it has is fine: if it was to
3781 push, it will now push to a more canonical node, but if
3782 it wasn't, then it has already pushed any values it might
3784 VALUE_RECURSED_INTO (node
->loc
) = true;
3785 /* Make sure we visit node->loc by ensuring we cval is
3787 VALUE_RECURSED_INTO (cval
) = true;
3789 else if (!VALUE_RECURSED_INTO (node
->loc
))
3790 /* If we have no need to "recurse" into this node, it's
3791 already "canonicalized", so drop the link to the old
3793 clobber_variable_part (set
, cval
, ndv
, 0, NULL
);
3795 else if (GET_CODE (node
->loc
) == REG
)
3797 attrs
*list
= set
->regs
[REGNO (node
->loc
)], **listp
;
3799 /* Change an existing attribute referring to dv so that it
3800 refers to cdv, removing any duplicate this might
3801 introduce, and checking that no previous duplicates
3802 existed, all in a single pass. */
3806 if (list
->offset
== 0
3807 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3808 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3815 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3818 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3823 if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3825 *listp
= list
->next
;
3831 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (dv
));
3834 else if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3836 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3841 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3843 *listp
= list
->next
;
3849 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (cdv
));
3858 if (list
->offset
== 0
3859 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3860 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3869 set_slot_part (set
, val
, cslot
, cdv
, 0,
3870 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
);
3872 slot
= clobber_slot_part (set
, cval
, slot
, 0, NULL
);
3874 /* Variable may have been unshared. */
3876 gcc_checking_assert (var
->n_var_parts
&& var
->var_part
[0].loc_chain
->loc
== cval
3877 && var
->var_part
[0].loc_chain
->next
== NULL
);
3879 if (VALUE_RECURSED_INTO (cval
))
3880 goto restart_with_cval
;
3885 /* Bind one-part variables to the canonical value in an equivalence
3886 set. Not doing this causes dataflow convergence failure in rare
3887 circumstances, see PR42873. Unfortunately we can't do this
3888 efficiently as part of canonicalize_values_star, since we may not
3889 have determined or even seen the canonical value of a set when we
3890 get to a variable that references another member of the set. */
3893 canonicalize_vars_star (variable
**slot
, dataflow_set
*set
)
3895 variable
*var
= *slot
;
3896 decl_or_value dv
= var
->dv
;
3897 location_chain
*node
;
3902 location_chain
*cnode
;
3904 if (!var
->onepart
|| var
->onepart
== ONEPART_VALUE
)
3907 gcc_assert (var
->n_var_parts
== 1);
3909 node
= var
->var_part
[0].loc_chain
;
3911 if (GET_CODE (node
->loc
) != VALUE
)
3914 gcc_assert (!node
->next
);
3917 /* Push values to the canonical one. */
3918 cdv
= dv_from_value (cval
);
3919 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3923 gcc_assert (cvar
->n_var_parts
== 1);
3925 cnode
= cvar
->var_part
[0].loc_chain
;
3927 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3928 that are not “more canonical” than it. */
3929 if (GET_CODE (cnode
->loc
) != VALUE
3930 || !canon_value_cmp (cnode
->loc
, cval
))
3933 /* CVAL was found to be non-canonical. Change the variable to point
3934 to the canonical VALUE. */
3935 gcc_assert (!cnode
->next
);
3938 slot
= set_slot_part (set
, cval
, slot
, dv
, 0,
3939 node
->init
, node
->set_src
);
3940 clobber_slot_part (set
, cval
, slot
, 0, node
->set_src
);
3945 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3946 corresponding entry in DSM->src. Multi-part variables are combined
3947 with variable_union, whereas onepart dvs are combined with
3951 variable_merge_over_cur (variable
*s1var
, struct dfset_merge
*dsm
)
3953 dataflow_set
*dst
= dsm
->dst
;
3955 variable
*s2var
, *dvar
= NULL
;
3956 decl_or_value dv
= s1var
->dv
;
3957 onepart_enum onepart
= s1var
->onepart
;
3960 location_chain
*node
, **nodep
;
3962 /* If the incoming onepart variable has an empty location list, then
3963 the intersection will be just as empty. For other variables,
3964 it's always union. */
3965 gcc_checking_assert (s1var
->n_var_parts
3966 && s1var
->var_part
[0].loc_chain
);
3969 return variable_union (s1var
, dst
);
3971 gcc_checking_assert (s1var
->n_var_parts
== 1);
3973 dvhash
= dv_htab_hash (dv
);
3974 if (dv_is_value_p (dv
))
3975 val
= dv_as_value (dv
);
3979 s2var
= shared_hash_find_1 (dsm
->src
->vars
, dv
, dvhash
);
3982 dst_can_be_shared
= false;
3986 dsm
->src_onepart_cnt
--;
3987 gcc_assert (s2var
->var_part
[0].loc_chain
3988 && s2var
->onepart
== onepart
3989 && s2var
->n_var_parts
== 1);
3991 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
3995 gcc_assert (dvar
->refcount
== 1
3996 && dvar
->onepart
== onepart
3997 && dvar
->n_var_parts
== 1);
3998 nodep
= &dvar
->var_part
[0].loc_chain
;
4006 if (!dstslot
&& !onepart_variable_different_p (s1var
, s2var
))
4008 dstslot
= shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
,
4010 *dstslot
= dvar
= s2var
;
4015 dst_can_be_shared
= false;
4017 intersect_loc_chains (val
, nodep
, dsm
,
4018 s1var
->var_part
[0].loc_chain
, s2var
);
4024 dvar
= onepart_pool_allocate (onepart
);
4027 dvar
->n_var_parts
= 1;
4028 dvar
->onepart
= onepart
;
4029 dvar
->in_changed_variables
= false;
4030 dvar
->var_part
[0].loc_chain
= node
;
4031 dvar
->var_part
[0].cur_loc
= NULL
;
4033 VAR_LOC_1PAUX (dvar
) = NULL
;
4035 VAR_PART_OFFSET (dvar
, 0) = 0;
4038 = shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
, dvhash
,
4040 gcc_assert (!*dstslot
);
4048 nodep
= &dvar
->var_part
[0].loc_chain
;
4049 while ((node
= *nodep
))
4051 location_chain
**nextp
= &node
->next
;
4053 if (GET_CODE (node
->loc
) == REG
)
4057 for (list
= dst
->regs
[REGNO (node
->loc
)]; list
; list
= list
->next
)
4058 if (GET_MODE (node
->loc
) == GET_MODE (list
->loc
)
4059 && dv_is_value_p (list
->dv
))
4063 attrs_list_insert (&dst
->regs
[REGNO (node
->loc
)],
4065 /* If this value became canonical for another value that had
4066 this register, we want to leave it alone. */
4067 else if (dv_as_value (list
->dv
) != val
)
4069 dstslot
= set_slot_part (dst
, dv_as_value (list
->dv
),
4071 node
->init
, NULL_RTX
);
4072 dstslot
= delete_slot_part (dst
, node
->loc
, dstslot
, 0);
4074 /* Since nextp points into the removed node, we can't
4075 use it. The pointer to the next node moved to nodep.
4076 However, if the variable we're walking is unshared
4077 during our walk, we'll keep walking the location list
4078 of the previously-shared variable, in which case the
4079 node won't have been removed, and we'll want to skip
4080 it. That's why we test *nodep here. */
4086 /* Canonicalization puts registers first, so we don't have to
4092 if (dvar
!= *dstslot
)
4094 nodep
= &dvar
->var_part
[0].loc_chain
;
4098 /* Mark all referenced nodes for canonicalization, and make sure
4099 we have mutual equivalence links. */
4100 VALUE_RECURSED_INTO (val
) = true;
4101 for (node
= *nodep
; node
; node
= node
->next
)
4102 if (GET_CODE (node
->loc
) == VALUE
)
4104 VALUE_RECURSED_INTO (node
->loc
) = true;
4105 set_variable_part (dst
, val
, dv_from_value (node
->loc
), 0,
4106 node
->init
, NULL
, INSERT
);
4109 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4110 gcc_assert (*dstslot
== dvar
);
4111 canonicalize_values_star (dstslot
, dst
);
4112 gcc_checking_assert (dstslot
4113 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4119 bool has_value
= false, has_other
= false;
4121 /* If we have one value and anything else, we're going to
4122 canonicalize this, so make sure all values have an entry in
4123 the table and are marked for canonicalization. */
4124 for (node
= *nodep
; node
; node
= node
->next
)
4126 if (GET_CODE (node
->loc
) == VALUE
)
4128 /* If this was marked during register canonicalization,
4129 we know we have to canonicalize values. */
4144 if (has_value
&& has_other
)
4146 for (node
= *nodep
; node
; node
= node
->next
)
4148 if (GET_CODE (node
->loc
) == VALUE
)
4150 decl_or_value dv
= dv_from_value (node
->loc
);
4151 variable
**slot
= NULL
;
4153 if (shared_hash_shared (dst
->vars
))
4154 slot
= shared_hash_find_slot_noinsert (dst
->vars
, dv
);
4156 slot
= shared_hash_find_slot_unshare (&dst
->vars
, dv
,
4160 variable
*var
= onepart_pool_allocate (ONEPART_VALUE
);
4163 var
->n_var_parts
= 1;
4164 var
->onepart
= ONEPART_VALUE
;
4165 var
->in_changed_variables
= false;
4166 var
->var_part
[0].loc_chain
= NULL
;
4167 var
->var_part
[0].cur_loc
= NULL
;
4168 VAR_LOC_1PAUX (var
) = NULL
;
4172 VALUE_RECURSED_INTO (node
->loc
) = true;
4176 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4177 gcc_assert (*dstslot
== dvar
);
4178 canonicalize_values_star (dstslot
, dst
);
4179 gcc_checking_assert (dstslot
4180 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4186 if (!onepart_variable_different_p (dvar
, s2var
))
4188 variable_htab_free (dvar
);
4189 *dstslot
= dvar
= s2var
;
4192 else if (s2var
!= s1var
&& !onepart_variable_different_p (dvar
, s1var
))
4194 variable_htab_free (dvar
);
4195 *dstslot
= dvar
= s1var
;
4197 dst_can_be_shared
= false;
4200 dst_can_be_shared
= false;
4205 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4206 multi-part variable. Unions of multi-part variables and
4207 intersections of one-part ones will be handled in
4208 variable_merge_over_cur(). */
4211 variable_merge_over_src (variable
*s2var
, struct dfset_merge
*dsm
)
4213 dataflow_set
*dst
= dsm
->dst
;
4214 decl_or_value dv
= s2var
->dv
;
4216 if (!s2var
->onepart
)
4218 variable
**dstp
= shared_hash_find_slot (dst
->vars
, dv
);
4224 dsm
->src_onepart_cnt
++;
4228 /* Combine dataflow set information from SRC2 into DST, using PDST
4229 to carry over information across passes. */
4232 dataflow_set_merge (dataflow_set
*dst
, dataflow_set
*src2
)
4234 dataflow_set cur
= *dst
;
4235 dataflow_set
*src1
= &cur
;
4236 struct dfset_merge dsm
;
4238 size_t src1_elems
, src2_elems
;
4239 variable_iterator_type hi
;
4242 src1_elems
= shared_hash_htab (src1
->vars
)->elements ();
4243 src2_elems
= shared_hash_htab (src2
->vars
)->elements ();
4244 dataflow_set_init (dst
);
4245 dst
->stack_adjust
= cur
.stack_adjust
;
4246 shared_hash_destroy (dst
->vars
);
4247 dst
->vars
= new shared_hash
;
4248 dst
->vars
->refcount
= 1;
4249 dst
->vars
->htab
= new variable_table_type (MAX (src1_elems
, src2_elems
));
4251 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4252 attrs_list_mpdv_union (&dst
->regs
[i
], src1
->regs
[i
], src2
->regs
[i
]);
4257 dsm
.src_onepart_cnt
= 0;
4259 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm
.src
->vars
),
4261 variable_merge_over_src (var
, &dsm
);
4262 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm
.cur
->vars
),
4264 variable_merge_over_cur (var
, &dsm
);
4266 if (dsm
.src_onepart_cnt
)
4267 dst_can_be_shared
= false;
4269 dataflow_set_destroy (src1
);
4272 /* Mark register equivalences. */
4275 dataflow_set_equiv_regs (dataflow_set
*set
)
4278 attrs
*list
, **listp
;
4280 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4282 rtx canon
[NUM_MACHINE_MODES
];
4284 /* If the list is empty or one entry, no need to canonicalize
4286 if (set
->regs
[i
] == NULL
|| set
->regs
[i
]->next
== NULL
)
4289 memset (canon
, 0, sizeof (canon
));
4291 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4292 if (list
->offset
== 0 && dv_is_value_p (list
->dv
))
4294 rtx val
= dv_as_value (list
->dv
);
4295 rtx
*cvalp
= &canon
[(int)GET_MODE (val
)];
4298 if (canon_value_cmp (val
, cval
))
4302 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4303 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4305 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4310 if (dv_is_value_p (list
->dv
))
4312 rtx val
= dv_as_value (list
->dv
);
4317 VALUE_RECURSED_INTO (val
) = true;
4318 set_variable_part (set
, val
, dv_from_value (cval
), 0,
4319 VAR_INIT_STATUS_INITIALIZED
,
4323 VALUE_RECURSED_INTO (cval
) = true;
4324 set_variable_part (set
, cval
, list
->dv
, 0,
4325 VAR_INIT_STATUS_INITIALIZED
, NULL
, NO_INSERT
);
4328 for (listp
= &set
->regs
[i
]; (list
= *listp
);
4329 listp
= list
? &list
->next
: listp
)
4330 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4332 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4338 if (dv_is_value_p (list
->dv
))
4340 rtx val
= dv_as_value (list
->dv
);
4341 if (!VALUE_RECURSED_INTO (val
))
4345 slot
= shared_hash_find_slot_noinsert (set
->vars
, list
->dv
);
4346 canonicalize_values_star (slot
, set
);
4353 /* Remove any redundant values in the location list of VAR, which must
4354 be unshared and 1-part. */
4357 remove_duplicate_values (variable
*var
)
4359 location_chain
*node
, **nodep
;
4361 gcc_assert (var
->onepart
);
4362 gcc_assert (var
->n_var_parts
== 1);
4363 gcc_assert (var
->refcount
== 1);
4365 for (nodep
= &var
->var_part
[0].loc_chain
; (node
= *nodep
); )
4367 if (GET_CODE (node
->loc
) == VALUE
)
4369 if (VALUE_RECURSED_INTO (node
->loc
))
4371 /* Remove duplicate value node. */
4372 *nodep
= node
->next
;
4377 VALUE_RECURSED_INTO (node
->loc
) = true;
4379 nodep
= &node
->next
;
4382 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4383 if (GET_CODE (node
->loc
) == VALUE
)
4385 gcc_assert (VALUE_RECURSED_INTO (node
->loc
));
4386 VALUE_RECURSED_INTO (node
->loc
) = false;
4391 /* Hash table iteration argument passed to variable_post_merge. */
4392 struct dfset_post_merge
4394 /* The new input set for the current block. */
4396 /* Pointer to the permanent input set for the current block, or
4398 dataflow_set
**permp
;
4401 /* Create values for incoming expressions associated with one-part
4402 variables that don't have value numbers for them. */
4405 variable_post_merge_new_vals (variable
**slot
, dfset_post_merge
*dfpm
)
4407 dataflow_set
*set
= dfpm
->set
;
4408 variable
*var
= *slot
;
4409 location_chain
*node
;
4411 if (!var
->onepart
|| !var
->n_var_parts
)
4414 gcc_assert (var
->n_var_parts
== 1);
4416 if (dv_is_decl_p (var
->dv
))
4418 bool check_dupes
= false;
4421 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4423 if (GET_CODE (node
->loc
) == VALUE
)
4424 gcc_assert (!VALUE_RECURSED_INTO (node
->loc
));
4425 else if (GET_CODE (node
->loc
) == REG
)
4427 attrs
*att
, **attp
, **curp
= NULL
;
4429 if (var
->refcount
!= 1)
4431 slot
= unshare_variable (set
, slot
, var
,
4432 VAR_INIT_STATUS_INITIALIZED
);
4437 for (attp
= &set
->regs
[REGNO (node
->loc
)]; (att
= *attp
);
4439 if (att
->offset
== 0
4440 && GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4442 if (dv_is_value_p (att
->dv
))
4444 rtx cval
= dv_as_value (att
->dv
);
4449 else if (dv_as_opaque (att
->dv
) == dv_as_opaque (var
->dv
))
4457 if ((*curp
)->offset
== 0
4458 && GET_MODE ((*curp
)->loc
) == GET_MODE (node
->loc
)
4459 && dv_as_opaque ((*curp
)->dv
) == dv_as_opaque (var
->dv
))
4462 curp
= &(*curp
)->next
;
4473 *dfpm
->permp
= XNEW (dataflow_set
);
4474 dataflow_set_init (*dfpm
->permp
);
4477 for (att
= (*dfpm
->permp
)->regs
[REGNO (node
->loc
)];
4478 att
; att
= att
->next
)
4479 if (GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4481 gcc_assert (att
->offset
== 0
4482 && dv_is_value_p (att
->dv
));
4483 val_reset (set
, att
->dv
);
4490 cval
= dv_as_value (cdv
);
4494 /* Create a unique value to hold this register,
4495 that ought to be found and reused in
4496 subsequent rounds. */
4498 gcc_assert (!cselib_lookup (node
->loc
,
4499 GET_MODE (node
->loc
), 0,
4501 v
= cselib_lookup (node
->loc
, GET_MODE (node
->loc
), 1,
4503 cselib_preserve_value (v
);
4504 cselib_invalidate_rtx (node
->loc
);
4506 cdv
= dv_from_value (cval
);
4509 "Created new value %u:%u for reg %i\n",
4510 v
->uid
, v
->hash
, REGNO (node
->loc
));
4513 var_reg_decl_set (*dfpm
->permp
, node
->loc
,
4514 VAR_INIT_STATUS_INITIALIZED
,
4515 cdv
, 0, NULL
, INSERT
);
4521 /* Remove attribute referring to the decl, which now
4522 uses the value for the register, already existing or
4523 to be added when we bring perm in. */
4531 remove_duplicate_values (var
);
4537 /* Reset values in the permanent set that are not associated with the
4538 chosen expression. */
4541 variable_post_merge_perm_vals (variable
**pslot
, dfset_post_merge
*dfpm
)
4543 dataflow_set
*set
= dfpm
->set
;
4544 variable
*pvar
= *pslot
, *var
;
4545 location_chain
*pnode
;
4549 gcc_assert (dv_is_value_p (pvar
->dv
)
4550 && pvar
->n_var_parts
== 1);
4551 pnode
= pvar
->var_part
[0].loc_chain
;
4554 && REG_P (pnode
->loc
));
4558 var
= shared_hash_find (set
->vars
, dv
);
4561 /* Although variable_post_merge_new_vals may have made decls
4562 non-star-canonical, values that pre-existed in canonical form
4563 remain canonical, and newly-created values reference a single
4564 REG, so they are canonical as well. Since VAR has the
4565 location list for a VALUE, using find_loc_in_1pdv for it is
4566 fine, since VALUEs don't map back to DECLs. */
4567 if (find_loc_in_1pdv (pnode
->loc
, var
, shared_hash_htab (set
->vars
)))
4569 val_reset (set
, dv
);
4572 for (att
= set
->regs
[REGNO (pnode
->loc
)]; att
; att
= att
->next
)
4573 if (att
->offset
== 0
4574 && GET_MODE (att
->loc
) == GET_MODE (pnode
->loc
)
4575 && dv_is_value_p (att
->dv
))
4578 /* If there is a value associated with this register already, create
4580 if (att
&& dv_as_value (att
->dv
) != dv_as_value (dv
))
4582 rtx cval
= dv_as_value (att
->dv
);
4583 set_variable_part (set
, cval
, dv
, 0, pnode
->init
, NULL
, INSERT
);
4584 set_variable_part (set
, dv_as_value (dv
), att
->dv
, 0, pnode
->init
,
4589 attrs_list_insert (&set
->regs
[REGNO (pnode
->loc
)],
4591 variable_union (pvar
, set
);
4597 /* Just checking stuff and registering register attributes for
4601 dataflow_post_merge_adjust (dataflow_set
*set
, dataflow_set
**permp
)
4603 struct dfset_post_merge dfpm
;
4608 shared_hash_htab (set
->vars
)
4609 ->traverse
<dfset_post_merge
*, variable_post_merge_new_vals
> (&dfpm
);
4611 shared_hash_htab ((*permp
)->vars
)
4612 ->traverse
<dfset_post_merge
*, variable_post_merge_perm_vals
> (&dfpm
);
4613 shared_hash_htab (set
->vars
)
4614 ->traverse
<dataflow_set
*, canonicalize_values_star
> (set
);
4615 shared_hash_htab (set
->vars
)
4616 ->traverse
<dataflow_set
*, canonicalize_vars_star
> (set
);
4619 /* Return a node whose loc is a MEM that refers to EXPR in the
4620 location list of a one-part variable or value VAR, or in that of
4621 any values recursively mentioned in the location lists. */
4623 static location_chain
*
4624 find_mem_expr_in_1pdv (tree expr
, rtx val
, variable_table_type
*vars
)
4626 location_chain
*node
;
4629 location_chain
*where
= NULL
;
4634 gcc_assert (GET_CODE (val
) == VALUE
4635 && !VALUE_RECURSED_INTO (val
));
4637 dv
= dv_from_value (val
);
4638 var
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
4643 gcc_assert (var
->onepart
);
4645 if (!var
->n_var_parts
)
4648 VALUE_RECURSED_INTO (val
) = true;
4650 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4651 if (MEM_P (node
->loc
)
4652 && MEM_EXPR (node
->loc
) == expr
4653 && int_mem_offset (node
->loc
) == 0)
4658 else if (GET_CODE (node
->loc
) == VALUE
4659 && !VALUE_RECURSED_INTO (node
->loc
)
4660 && (where
= find_mem_expr_in_1pdv (expr
, node
->loc
, vars
)))
4663 VALUE_RECURSED_INTO (val
) = false;
4668 /* Return TRUE if the value of MEM may vary across a call. */
4671 mem_dies_at_call (rtx mem
)
4673 tree expr
= MEM_EXPR (mem
);
4679 decl
= get_base_address (expr
);
4687 return (may_be_aliased (decl
)
4688 || (!TREE_READONLY (decl
) && is_global_var (decl
)));
4691 /* Remove all MEMs from the location list of a hash table entry for a
4692 one-part variable, except those whose MEM attributes map back to
4693 the variable itself, directly or within a VALUE. */
4696 dataflow_set_preserve_mem_locs (variable
**slot
, dataflow_set
*set
)
4698 variable
*var
= *slot
;
4700 if (var
->onepart
== ONEPART_VDECL
|| var
->onepart
== ONEPART_DEXPR
)
4702 tree decl
= dv_as_decl (var
->dv
);
4703 location_chain
*loc
, **locp
;
4704 bool changed
= false;
4706 if (!var
->n_var_parts
)
4709 gcc_assert (var
->n_var_parts
== 1);
4711 if (shared_var_p (var
, set
->vars
))
4713 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4715 /* We want to remove dying MEMs that don't refer to DECL. */
4716 if (GET_CODE (loc
->loc
) == MEM
4717 && (MEM_EXPR (loc
->loc
) != decl
4718 || int_mem_offset (loc
->loc
) != 0)
4719 && mem_dies_at_call (loc
->loc
))
4721 /* We want to move here MEMs that do refer to DECL. */
4722 else if (GET_CODE (loc
->loc
) == VALUE
4723 && find_mem_expr_in_1pdv (decl
, loc
->loc
,
4724 shared_hash_htab (set
->vars
)))
4731 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4733 gcc_assert (var
->n_var_parts
== 1);
4736 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4739 rtx old_loc
= loc
->loc
;
4740 if (GET_CODE (old_loc
) == VALUE
)
4742 location_chain
*mem_node
4743 = find_mem_expr_in_1pdv (decl
, loc
->loc
,
4744 shared_hash_htab (set
->vars
));
4746 /* ??? This picks up only one out of multiple MEMs that
4747 refer to the same variable. Do we ever need to be
4748 concerned about dealing with more than one, or, given
4749 that they should all map to the same variable
4750 location, their addresses will have been merged and
4751 they will be regarded as equivalent? */
4754 loc
->loc
= mem_node
->loc
;
4755 loc
->set_src
= mem_node
->set_src
;
4756 loc
->init
= MIN (loc
->init
, mem_node
->init
);
4760 if (GET_CODE (loc
->loc
) != MEM
4761 || (MEM_EXPR (loc
->loc
) == decl
4762 && int_mem_offset (loc
->loc
) == 0)
4763 || !mem_dies_at_call (loc
->loc
))
4765 if (old_loc
!= loc
->loc
&& emit_notes
)
4767 if (old_loc
== var
->var_part
[0].cur_loc
)
4770 var
->var_part
[0].cur_loc
= NULL
;
4779 if (old_loc
== var
->var_part
[0].cur_loc
)
4782 var
->var_part
[0].cur_loc
= NULL
;
4789 if (!var
->var_part
[0].loc_chain
)
4795 variable_was_changed (var
, set
);
4801 /* Remove all MEMs from the location list of a hash table entry for a
4802 onepart variable. */
4805 dataflow_set_remove_mem_locs (variable
**slot
, dataflow_set
*set
)
4807 variable
*var
= *slot
;
4809 if (var
->onepart
!= NOT_ONEPART
)
4811 location_chain
*loc
, **locp
;
4812 bool changed
= false;
4815 gcc_assert (var
->n_var_parts
== 1);
4817 if (shared_var_p (var
, set
->vars
))
4819 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4820 if (GET_CODE (loc
->loc
) == MEM
4821 && mem_dies_at_call (loc
->loc
))
4827 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4829 gcc_assert (var
->n_var_parts
== 1);
4832 if (VAR_LOC_1PAUX (var
))
4833 cur_loc
= VAR_LOC_FROM (var
);
4835 cur_loc
= var
->var_part
[0].cur_loc
;
4837 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4840 if (GET_CODE (loc
->loc
) != MEM
4841 || !mem_dies_at_call (loc
->loc
))
4848 /* If we have deleted the location which was last emitted
4849 we have to emit new location so add the variable to set
4850 of changed variables. */
4851 if (cur_loc
== loc
->loc
)
4854 var
->var_part
[0].cur_loc
= NULL
;
4855 if (VAR_LOC_1PAUX (var
))
4856 VAR_LOC_FROM (var
) = NULL
;
4861 if (!var
->var_part
[0].loc_chain
)
4867 variable_was_changed (var
, set
);
4873 /* Remove all variable-location information about call-clobbered
4874 registers, as well as associations between MEMs and VALUEs. */
4877 dataflow_set_clear_at_call (dataflow_set
*set
, rtx_insn
*call_insn
)
4880 hard_reg_set_iterator hrsi
;
4881 HARD_REG_SET invalidated_regs
;
4883 get_call_reg_set_usage (call_insn
, &invalidated_regs
,
4884 regs_invalidated_by_call
);
4886 EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs
, 0, r
, hrsi
)
4887 var_regno_delete (set
, r
);
4889 if (MAY_HAVE_DEBUG_BIND_INSNS
)
4891 set
->traversed_vars
= set
->vars
;
4892 shared_hash_htab (set
->vars
)
4893 ->traverse
<dataflow_set
*, dataflow_set_preserve_mem_locs
> (set
);
4894 set
->traversed_vars
= set
->vars
;
4895 shared_hash_htab (set
->vars
)
4896 ->traverse
<dataflow_set
*, dataflow_set_remove_mem_locs
> (set
);
4897 set
->traversed_vars
= NULL
;
4902 variable_part_different_p (variable_part
*vp1
, variable_part
*vp2
)
4904 location_chain
*lc1
, *lc2
;
4906 for (lc1
= vp1
->loc_chain
; lc1
; lc1
= lc1
->next
)
4908 for (lc2
= vp2
->loc_chain
; lc2
; lc2
= lc2
->next
)
4910 if (REG_P (lc1
->loc
) && REG_P (lc2
->loc
))
4912 if (REGNO (lc1
->loc
) == REGNO (lc2
->loc
))
4915 if (rtx_equal_p (lc1
->loc
, lc2
->loc
))
4924 /* Return true if one-part variables VAR1 and VAR2 are different.
4925 They must be in canonical order. */
4928 onepart_variable_different_p (variable
*var1
, variable
*var2
)
4930 location_chain
*lc1
, *lc2
;
4935 gcc_assert (var1
->n_var_parts
== 1
4936 && var2
->n_var_parts
== 1);
4938 lc1
= var1
->var_part
[0].loc_chain
;
4939 lc2
= var2
->var_part
[0].loc_chain
;
4941 gcc_assert (lc1
&& lc2
);
4945 if (loc_cmp (lc1
->loc
, lc2
->loc
))
4954 /* Return true if one-part variables VAR1 and VAR2 are different.
4955 They must be in canonical order. */
4958 dump_onepart_variable_differences (variable
*var1
, variable
*var2
)
4960 location_chain
*lc1
, *lc2
;
4962 gcc_assert (var1
!= var2
);
4963 gcc_assert (dump_file
);
4964 gcc_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
));
4965 gcc_assert (var1
->n_var_parts
== 1
4966 && var2
->n_var_parts
== 1);
4968 lc1
= var1
->var_part
[0].loc_chain
;
4969 lc2
= var2
->var_part
[0].loc_chain
;
4971 gcc_assert (lc1
&& lc2
);
4975 switch (loc_cmp (lc1
->loc
, lc2
->loc
))
4978 fprintf (dump_file
, "removed: ");
4979 print_rtl_single (dump_file
, lc1
->loc
);
4985 fprintf (dump_file
, "added: ");
4986 print_rtl_single (dump_file
, lc2
->loc
);
4998 fprintf (dump_file
, "removed: ");
4999 print_rtl_single (dump_file
, lc1
->loc
);
5005 fprintf (dump_file
, "added: ");
5006 print_rtl_single (dump_file
, lc2
->loc
);
5011 /* Return true if variables VAR1 and VAR2 are different. */
5014 variable_different_p (variable
*var1
, variable
*var2
)
5021 if (var1
->onepart
!= var2
->onepart
)
5024 if (var1
->n_var_parts
!= var2
->n_var_parts
)
5027 if (var1
->onepart
&& var1
->n_var_parts
)
5029 gcc_checking_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
)
5030 && var1
->n_var_parts
== 1);
5031 /* One-part values have locations in a canonical order. */
5032 return onepart_variable_different_p (var1
, var2
);
5035 for (i
= 0; i
< var1
->n_var_parts
; i
++)
5037 if (VAR_PART_OFFSET (var1
, i
) != VAR_PART_OFFSET (var2
, i
))
5039 if (variable_part_different_p (&var1
->var_part
[i
], &var2
->var_part
[i
]))
5041 if (variable_part_different_p (&var2
->var_part
[i
], &var1
->var_part
[i
]))
5047 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5050 dataflow_set_different (dataflow_set
*old_set
, dataflow_set
*new_set
)
5052 variable_iterator_type hi
;
5054 bool diffound
= false;
5055 bool details
= (dump_file
&& (dump_flags
& TDF_DETAILS
));
5067 if (old_set
->vars
== new_set
->vars
)
5070 if (shared_hash_htab (old_set
->vars
)->elements ()
5071 != shared_hash_htab (new_set
->vars
)->elements ())
5074 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set
->vars
),
5077 variable_table_type
*htab
= shared_hash_htab (new_set
->vars
);
5078 variable
*var2
= htab
->find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
5082 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5084 fprintf (dump_file
, "dataflow difference found: removal of:\n");
5089 else if (variable_different_p (var1
, var2
))
5093 fprintf (dump_file
, "dataflow difference found: "
5094 "old and new follow:\n");
5096 if (dv_onepart_p (var1
->dv
))
5097 dump_onepart_variable_differences (var1
, var2
);
5104 /* There's no need to traverse the second hashtab unless we want to
5105 print the details. If both have the same number of elements and
5106 the second one had all entries found in the first one, then the
5107 second can't have any extra entries. */
5111 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set
->vars
),
5114 variable_table_type
*htab
= shared_hash_htab (old_set
->vars
);
5115 variable
*var2
= htab
->find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
5120 fprintf (dump_file
, "dataflow difference found: addition of:\n");
5132 /* Free the contents of dataflow set SET. */
5135 dataflow_set_destroy (dataflow_set
*set
)
5139 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
5140 attrs_list_clear (&set
->regs
[i
]);
5142 shared_hash_destroy (set
->vars
);
5146 /* Return true if T is a tracked parameter with non-degenerate record type. */
5149 tracked_record_parameter_p (tree t
)
5151 if (TREE_CODE (t
) != PARM_DECL
)
5154 if (DECL_MODE (t
) == BLKmode
)
5157 tree type
= TREE_TYPE (t
);
5158 if (TREE_CODE (type
) != RECORD_TYPE
)
5161 if (TYPE_FIELDS (type
) == NULL_TREE
5162 || DECL_CHAIN (TYPE_FIELDS (type
)) == NULL_TREE
)
5168 /* Shall EXPR be tracked? */
5171 track_expr_p (tree expr
, bool need_rtl
)
5176 if (TREE_CODE (expr
) == DEBUG_EXPR_DECL
)
5177 return DECL_RTL_SET_P (expr
);
5179 /* If EXPR is not a parameter or a variable do not track it. */
5180 if (!VAR_P (expr
) && TREE_CODE (expr
) != PARM_DECL
)
5183 /* It also must have a name... */
5184 if (!DECL_NAME (expr
) && need_rtl
)
5187 /* ... and a RTL assigned to it. */
5188 decl_rtl
= DECL_RTL_IF_SET (expr
);
5189 if (!decl_rtl
&& need_rtl
)
5192 /* If this expression is really a debug alias of some other declaration, we
5193 don't need to track this expression if the ultimate declaration is
5196 if (VAR_P (realdecl
) && DECL_HAS_DEBUG_EXPR_P (realdecl
))
5198 realdecl
= DECL_DEBUG_EXPR (realdecl
);
5199 if (!DECL_P (realdecl
))
5201 if (handled_component_p (realdecl
)
5202 || (TREE_CODE (realdecl
) == MEM_REF
5203 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5205 HOST_WIDE_INT bitsize
, bitpos
, maxsize
;
5208 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
,
5209 &maxsize
, &reverse
);
5210 if (!DECL_P (innerdecl
)
5211 || DECL_IGNORED_P (innerdecl
)
5212 /* Do not track declarations for parts of tracked record
5213 parameters since we want to track them as a whole. */
5214 || tracked_record_parameter_p (innerdecl
)
5215 || TREE_STATIC (innerdecl
)
5217 || bitpos
+ bitsize
> 256
5218 || bitsize
!= maxsize
)
5228 /* Do not track EXPR if REALDECL it should be ignored for debugging
5230 if (DECL_IGNORED_P (realdecl
))
5233 /* Do not track global variables until we are able to emit correct location
5235 if (TREE_STATIC (realdecl
))
5238 /* When the EXPR is a DECL for alias of some variable (see example)
5239 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5240 DECL_RTL contains SYMBOL_REF.
5243 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5246 if (decl_rtl
&& MEM_P (decl_rtl
)
5247 && contains_symbol_ref_p (XEXP (decl_rtl
, 0)))
5250 /* If RTX is a memory it should not be very large (because it would be
5251 an array or struct). */
5252 if (decl_rtl
&& MEM_P (decl_rtl
))
5254 /* Do not track structures and arrays. */
5255 if ((GET_MODE (decl_rtl
) == BLKmode
5256 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl
)))
5257 && !tracked_record_parameter_p (realdecl
))
5259 if (MEM_SIZE_KNOWN_P (decl_rtl
)
5260 && maybe_gt (MEM_SIZE (decl_rtl
), MAX_VAR_PARTS
))
5264 DECL_CHANGED (expr
) = 0;
5265 DECL_CHANGED (realdecl
) = 0;
5269 /* Determine whether a given LOC refers to the same variable part as
5273 same_variable_part_p (rtx loc
, tree expr
, poly_int64 offset
)
5278 if (! DECL_P (expr
))
5283 expr2
= REG_EXPR (loc
);
5284 offset2
= REG_OFFSET (loc
);
5286 else if (MEM_P (loc
))
5288 expr2
= MEM_EXPR (loc
);
5289 offset2
= int_mem_offset (loc
);
5294 if (! expr2
|| ! DECL_P (expr2
))
5297 expr
= var_debug_decl (expr
);
5298 expr2
= var_debug_decl (expr2
);
5300 return (expr
== expr2
&& known_eq (offset
, offset2
));
5303 /* LOC is a REG or MEM that we would like to track if possible.
5304 If EXPR is null, we don't know what expression LOC refers to,
5305 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5306 LOC is an lvalue register.
5308 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5309 is something we can track. When returning true, store the mode of
5310 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5311 from EXPR in *OFFSET_OUT (if nonnull). */
5314 track_loc_p (rtx loc
, tree expr
, poly_int64 offset
, bool store_reg_p
,
5315 machine_mode
*mode_out
, HOST_WIDE_INT
*offset_out
)
5319 if (expr
== NULL
|| !track_expr_p (expr
, true))
5322 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5323 whole subreg, but only the old inner part is really relevant. */
5324 mode
= GET_MODE (loc
);
5325 if (REG_P (loc
) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc
)))
5327 machine_mode pseudo_mode
;
5329 pseudo_mode
= PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc
));
5330 if (paradoxical_subreg_p (mode
, pseudo_mode
))
5332 offset
+= byte_lowpart_offset (pseudo_mode
, mode
);
5337 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5338 Do the same if we are storing to a register and EXPR occupies
5339 the whole of register LOC; in that case, the whole of EXPR is
5340 being changed. We exclude complex modes from the second case
5341 because the real and imaginary parts are represented as separate
5342 pseudo registers, even if the whole complex value fits into one
5344 if ((paradoxical_subreg_p (mode
, DECL_MODE (expr
))
5346 && !COMPLEX_MODE_P (DECL_MODE (expr
))
5347 && hard_regno_nregs (REGNO (loc
), DECL_MODE (expr
)) == 1))
5348 && known_eq (offset
+ byte_lowpart_offset (DECL_MODE (expr
), mode
), 0))
5350 mode
= DECL_MODE (expr
);
5354 HOST_WIDE_INT const_offset
;
5355 if (!track_offset_p (offset
, &const_offset
))
5361 *offset_out
= const_offset
;
5365 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5366 want to track. When returning nonnull, make sure that the attributes
5367 on the returned value are updated. */
5370 var_lowpart (machine_mode mode
, rtx loc
)
5372 unsigned int offset
, reg_offset
, regno
;
5374 if (GET_MODE (loc
) == mode
)
5377 if (!REG_P (loc
) && !MEM_P (loc
))
5380 offset
= byte_lowpart_offset (mode
, GET_MODE (loc
));
5383 return adjust_address_nv (loc
, mode
, offset
);
5385 reg_offset
= subreg_lowpart_offset (mode
, GET_MODE (loc
));
5386 regno
= REGNO (loc
) + subreg_regno_offset (REGNO (loc
), GET_MODE (loc
),
5388 return gen_rtx_REG_offset (loc
, mode
, regno
, offset
);
5391 /* Carry information about uses and stores while walking rtx. */
5393 struct count_use_info
5395 /* The insn where the RTX is. */
5398 /* The basic block where insn is. */
5401 /* The array of n_sets sets in the insn, as determined by cselib. */
5402 struct cselib_set
*sets
;
5405 /* True if we're counting stores, false otherwise. */
5409 /* Find a VALUE corresponding to X. */
5411 static inline cselib_val
*
5412 find_use_val (rtx x
, machine_mode mode
, struct count_use_info
*cui
)
5418 /* This is called after uses are set up and before stores are
5419 processed by cselib, so it's safe to look up srcs, but not
5420 dsts. So we look up expressions that appear in srcs or in
5421 dest expressions, but we search the sets array for dests of
5425 /* Some targets represent memset and memcpy patterns
5426 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5427 (set (mem:BLK ...) (const_int ...)) or
5428 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5429 in that case, otherwise we end up with mode mismatches. */
5430 if (mode
== BLKmode
&& MEM_P (x
))
5432 for (i
= 0; i
< cui
->n_sets
; i
++)
5433 if (cui
->sets
[i
].dest
== x
)
5434 return cui
->sets
[i
].src_elt
;
5437 return cselib_lookup (x
, mode
, 0, VOIDmode
);
5443 /* Replace all registers and addresses in an expression with VALUE
5444 expressions that map back to them, unless the expression is a
5445 register. If no mapping is or can be performed, returns NULL. */
5448 replace_expr_with_values (rtx loc
)
5450 if (REG_P (loc
) || GET_CODE (loc
) == ENTRY_VALUE
)
5452 else if (MEM_P (loc
))
5454 cselib_val
*addr
= cselib_lookup (XEXP (loc
, 0),
5455 get_address_mode (loc
), 0,
5458 return replace_equiv_address_nv (loc
, addr
->val_rtx
);
5463 return cselib_subst_to_values (loc
, VOIDmode
);
5466 /* Return true if X contains a DEBUG_EXPR. */
5469 rtx_debug_expr_p (const_rtx x
)
5471 subrtx_iterator::array_type array
;
5472 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
5473 if (GET_CODE (*iter
) == DEBUG_EXPR
)
5478 /* Determine what kind of micro operation to choose for a USE. Return
5479 MO_CLOBBER if no micro operation is to be generated. */
5481 static enum micro_operation_type
5482 use_type (rtx loc
, struct count_use_info
*cui
, machine_mode
*modep
)
5486 if (cui
&& cui
->sets
)
5488 if (GET_CODE (loc
) == VAR_LOCATION
)
5490 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc
), false))
5492 rtx ploc
= PAT_VAR_LOCATION_LOC (loc
);
5493 if (! VAR_LOC_UNKNOWN_P (ploc
))
5495 cselib_val
*val
= cselib_lookup (ploc
, GET_MODE (loc
), 1,
5498 /* ??? flag_float_store and volatile mems are never
5499 given values, but we could in theory use them for
5501 gcc_assert (val
|| 1);
5509 if (REG_P (loc
) || MEM_P (loc
))
5512 *modep
= GET_MODE (loc
);
5516 || (find_use_val (loc
, GET_MODE (loc
), cui
)
5517 && cselib_lookup (XEXP (loc
, 0),
5518 get_address_mode (loc
), 0,
5524 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5526 if (val
&& !cselib_preserved_value_p (val
))
5534 gcc_assert (REGNO (loc
) < FIRST_PSEUDO_REGISTER
);
5536 if (loc
== cfa_base_rtx
)
5538 expr
= REG_EXPR (loc
);
5541 return MO_USE_NO_VAR
;
5542 else if (target_for_debug_bind (var_debug_decl (expr
)))
5544 else if (track_loc_p (loc
, expr
, REG_OFFSET (loc
),
5545 false, modep
, NULL
))
5548 return MO_USE_NO_VAR
;
5550 else if (MEM_P (loc
))
5552 expr
= MEM_EXPR (loc
);
5556 else if (target_for_debug_bind (var_debug_decl (expr
)))
5558 else if (track_loc_p (loc
, expr
, int_mem_offset (loc
),
5560 /* Multi-part variables shouldn't refer to one-part
5561 variable names such as VALUEs (never happens) or
5562 DEBUG_EXPRs (only happens in the presence of debug
5564 && (!MAY_HAVE_DEBUG_BIND_INSNS
5565 || !rtx_debug_expr_p (XEXP (loc
, 0))))
5574 /* Log to OUT information about micro-operation MOPT involving X in
5578 log_op_type (rtx x
, basic_block bb
, rtx_insn
*insn
,
5579 enum micro_operation_type mopt
, FILE *out
)
5581 fprintf (out
, "bb %i op %i insn %i %s ",
5582 bb
->index
, VTI (bb
)->mos
.length (),
5583 INSN_UID (insn
), micro_operation_type_name
[mopt
]);
5584 print_inline_rtx (out
, x
, 2);
5588 /* Tell whether the CONCAT used to holds a VALUE and its location
5589 needs value resolution, i.e., an attempt of mapping the location
5590 back to other incoming values. */
5591 #define VAL_NEEDS_RESOLUTION(x) \
5592 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5593 /* Whether the location in the CONCAT is a tracked expression, that
5594 should also be handled like a MO_USE. */
5595 #define VAL_HOLDS_TRACK_EXPR(x) \
5596 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5597 /* Whether the location in the CONCAT should be handled like a MO_COPY
5599 #define VAL_EXPR_IS_COPIED(x) \
5600 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5601 /* Whether the location in the CONCAT should be handled like a
5602 MO_CLOBBER as well. */
5603 #define VAL_EXPR_IS_CLOBBERED(x) \
5604 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5606 /* All preserved VALUEs. */
5607 static vec
<rtx
> preserved_values
;
5609 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5612 preserve_value (cselib_val
*val
)
5614 cselib_preserve_value (val
);
5615 preserved_values
.safe_push (val
->val_rtx
);
5618 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5619 any rtxes not suitable for CONST use not replaced by VALUEs
5623 non_suitable_const (const_rtx x
)
5625 subrtx_iterator::array_type array
;
5626 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
5628 const_rtx x
= *iter
;
5629 switch (GET_CODE (x
))
5640 if (!MEM_READONLY_P (x
))
5650 /* Add uses (register and memory references) LOC which will be tracked
5651 to VTI (bb)->mos. */
5654 add_uses (rtx loc
, struct count_use_info
*cui
)
5656 machine_mode mode
= VOIDmode
;
5657 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5659 if (type
!= MO_CLOBBER
)
5661 basic_block bb
= cui
->bb
;
5665 mo
.u
.loc
= type
== MO_USE
? var_lowpart (mode
, loc
) : loc
;
5666 mo
.insn
= cui
->insn
;
5668 if (type
== MO_VAL_LOC
)
5671 rtx vloc
= PAT_VAR_LOCATION_LOC (oloc
);
5674 gcc_assert (cui
->sets
);
5677 && !REG_P (XEXP (vloc
, 0))
5678 && !MEM_P (XEXP (vloc
, 0)))
5681 machine_mode address_mode
= get_address_mode (mloc
);
5683 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5686 if (val
&& !cselib_preserved_value_p (val
))
5687 preserve_value (val
);
5690 if (CONSTANT_P (vloc
)
5691 && (GET_CODE (vloc
) != CONST
|| non_suitable_const (vloc
)))
5692 /* For constants don't look up any value. */;
5693 else if (!VAR_LOC_UNKNOWN_P (vloc
) && !unsuitable_loc (vloc
)
5694 && (val
= find_use_val (vloc
, GET_MODE (oloc
), cui
)))
5697 enum micro_operation_type type2
;
5699 bool resolvable
= REG_P (vloc
) || MEM_P (vloc
);
5702 nloc
= replace_expr_with_values (vloc
);
5706 oloc
= shallow_copy_rtx (oloc
);
5707 PAT_VAR_LOCATION_LOC (oloc
) = nloc
;
5710 oloc
= gen_rtx_CONCAT (mode
, val
->val_rtx
, oloc
);
5712 type2
= use_type (vloc
, 0, &mode2
);
5714 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5715 || type2
== MO_CLOBBER
);
5717 if (type2
== MO_CLOBBER
5718 && !cselib_preserved_value_p (val
))
5720 VAL_NEEDS_RESOLUTION (oloc
) = resolvable
;
5721 preserve_value (val
);
5724 else if (!VAR_LOC_UNKNOWN_P (vloc
))
5726 oloc
= shallow_copy_rtx (oloc
);
5727 PAT_VAR_LOCATION_LOC (oloc
) = gen_rtx_UNKNOWN_VAR_LOC ();
5732 else if (type
== MO_VAL_USE
)
5734 machine_mode mode2
= VOIDmode
;
5735 enum micro_operation_type type2
;
5736 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5737 rtx vloc
, oloc
= loc
, nloc
;
5739 gcc_assert (cui
->sets
);
5742 && !REG_P (XEXP (oloc
, 0))
5743 && !MEM_P (XEXP (oloc
, 0)))
5746 machine_mode address_mode
= get_address_mode (mloc
);
5748 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5751 if (val
&& !cselib_preserved_value_p (val
))
5752 preserve_value (val
);
5755 type2
= use_type (loc
, 0, &mode2
);
5757 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5758 || type2
== MO_CLOBBER
);
5760 if (type2
== MO_USE
)
5761 vloc
= var_lowpart (mode2
, loc
);
5765 /* The loc of a MO_VAL_USE may have two forms:
5767 (concat val src): val is at src, a value-based
5770 (concat (concat val use) src): same as above, with use as
5771 the MO_USE tracked value, if it differs from src.
5775 gcc_checking_assert (REG_P (loc
) || MEM_P (loc
));
5776 nloc
= replace_expr_with_values (loc
);
5781 oloc
= gen_rtx_CONCAT (mode2
, val
->val_rtx
, vloc
);
5783 oloc
= val
->val_rtx
;
5785 mo
.u
.loc
= gen_rtx_CONCAT (mode
, oloc
, nloc
);
5787 if (type2
== MO_USE
)
5788 VAL_HOLDS_TRACK_EXPR (mo
.u
.loc
) = 1;
5789 if (!cselib_preserved_value_p (val
))
5791 VAL_NEEDS_RESOLUTION (mo
.u
.loc
) = 1;
5792 preserve_value (val
);
5796 gcc_assert (type
== MO_USE
|| type
== MO_USE_NO_VAR
);
5798 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5799 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
5800 VTI (bb
)->mos
.safe_push (mo
);
5804 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5807 add_uses_1 (rtx
*x
, void *cui
)
5809 subrtx_var_iterator::array_type array
;
5810 FOR_EACH_SUBRTX_VAR (iter
, array
, *x
, NONCONST
)
5811 add_uses (*iter
, (struct count_use_info
*) cui
);
5814 /* This is the value used during expansion of locations. We want it
5815 to be unbounded, so that variables expanded deep in a recursion
5816 nest are fully evaluated, so that their values are cached
5817 correctly. We avoid recursion cycles through other means, and we
5818 don't unshare RTL, so excess complexity is not a problem. */
5819 #define EXPR_DEPTH (INT_MAX)
5820 /* We use this to keep too-complex expressions from being emitted as
5821 location notes, and then to debug information. Users can trade
5822 compile time for ridiculously complex expressions, although they're
5823 seldom useful, and they may often have to be discarded as not
5824 representable anyway. */
5825 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5827 /* Attempt to reverse the EXPR operation in the debug info and record
5828 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5829 no longer live we can express its value as VAL - 6. */
5832 reverse_op (rtx val
, const_rtx expr
, rtx_insn
*insn
)
5836 struct elt_loc_list
*l
;
5840 if (GET_CODE (expr
) != SET
)
5843 if (!REG_P (SET_DEST (expr
)) || GET_MODE (val
) != GET_MODE (SET_DEST (expr
)))
5846 src
= SET_SRC (expr
);
5847 switch (GET_CODE (src
))
5854 if (!REG_P (XEXP (src
, 0)))
5859 if (!REG_P (XEXP (src
, 0)) && !MEM_P (XEXP (src
, 0)))
5866 if (!SCALAR_INT_MODE_P (GET_MODE (src
)) || XEXP (src
, 0) == cfa_base_rtx
)
5869 v
= cselib_lookup (XEXP (src
, 0), GET_MODE (XEXP (src
, 0)), 0, VOIDmode
);
5870 if (!v
|| !cselib_preserved_value_p (v
))
5873 /* Use canonical V to avoid creating multiple redundant expressions
5874 for different VALUES equivalent to V. */
5875 v
= canonical_cselib_val (v
);
5877 /* Adding a reverse op isn't useful if V already has an always valid
5878 location. Ignore ENTRY_VALUE, while it is always constant, we should
5879 prefer non-ENTRY_VALUE locations whenever possible. */
5880 for (l
= v
->locs
, count
= 0; l
; l
= l
->next
, count
++)
5881 if (CONSTANT_P (l
->loc
)
5882 && (GET_CODE (l
->loc
) != CONST
|| !references_value_p (l
->loc
, 0)))
5884 /* Avoid creating too large locs lists. */
5885 else if (count
== PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE
))
5888 switch (GET_CODE (src
))
5892 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5894 ret
= gen_rtx_fmt_e (GET_CODE (src
), GET_MODE (val
), val
);
5898 ret
= gen_lowpart_SUBREG (GET_MODE (v
->val_rtx
), val
);
5910 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5912 arg
= XEXP (src
, 1);
5913 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5915 arg
= cselib_expand_value_rtx (arg
, scratch_regs
, 5);
5916 if (arg
== NULL_RTX
)
5918 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5921 ret
= simplify_gen_binary (code
, GET_MODE (val
), val
, arg
);
5927 cselib_add_permanent_equiv (v
, ret
, insn
);
5930 /* Add stores (register and memory references) LOC which will be tracked
5931 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5932 CUIP->insn is instruction which the LOC is part of. */
5935 add_stores (rtx loc
, const_rtx expr
, void *cuip
)
5937 machine_mode mode
= VOIDmode
, mode2
;
5938 struct count_use_info
*cui
= (struct count_use_info
*)cuip
;
5939 basic_block bb
= cui
->bb
;
5941 rtx oloc
= loc
, nloc
, src
= NULL
;
5942 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5943 bool track_p
= false;
5945 bool resolve
, preserve
;
5947 if (type
== MO_CLOBBER
)
5954 gcc_assert (loc
!= cfa_base_rtx
);
5955 if ((GET_CODE (expr
) == CLOBBER
&& type
!= MO_VAL_SET
)
5956 || !(track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5957 || GET_CODE (expr
) == CLOBBER
)
5959 mo
.type
= MO_CLOBBER
;
5961 if (GET_CODE (expr
) == SET
5962 && SET_DEST (expr
) == loc
5963 && !unsuitable_loc (SET_SRC (expr
))
5964 && find_use_val (loc
, mode
, cui
))
5966 gcc_checking_assert (type
== MO_VAL_SET
);
5967 mo
.u
.loc
= gen_rtx_SET (loc
, SET_SRC (expr
));
5972 if (GET_CODE (expr
) == SET
5973 && SET_DEST (expr
) == loc
5974 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5975 src
= var_lowpart (mode2
, SET_SRC (expr
));
5976 loc
= var_lowpart (mode2
, loc
);
5985 rtx xexpr
= gen_rtx_SET (loc
, src
);
5986 if (same_variable_part_p (src
, REG_EXPR (loc
), REG_OFFSET (loc
)))
5988 /* If this is an instruction copying (part of) a parameter
5989 passed by invisible reference to its register location,
5990 pretend it's a SET so that the initial memory location
5991 is discarded, as the parameter register can be reused
5992 for other purposes and we do not track locations based
5993 on generic registers. */
5996 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5997 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5998 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5999 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0)
6010 mo
.insn
= cui
->insn
;
6012 else if (MEM_P (loc
)
6013 && ((track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
6016 if (MEM_P (loc
) && type
== MO_VAL_SET
6017 && !REG_P (XEXP (loc
, 0))
6018 && !MEM_P (XEXP (loc
, 0)))
6021 machine_mode address_mode
= get_address_mode (mloc
);
6022 cselib_val
*val
= cselib_lookup (XEXP (mloc
, 0),
6026 if (val
&& !cselib_preserved_value_p (val
))
6027 preserve_value (val
);
6030 if (GET_CODE (expr
) == CLOBBER
|| !track_p
)
6032 mo
.type
= MO_CLOBBER
;
6033 mo
.u
.loc
= track_p
? var_lowpart (mode2
, loc
) : loc
;
6037 if (GET_CODE (expr
) == SET
6038 && SET_DEST (expr
) == loc
6039 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
6040 src
= var_lowpart (mode2
, SET_SRC (expr
));
6041 loc
= var_lowpart (mode2
, loc
);
6050 rtx xexpr
= gen_rtx_SET (loc
, src
);
6051 if (same_variable_part_p (SET_SRC (xexpr
),
6053 int_mem_offset (loc
)))
6060 mo
.insn
= cui
->insn
;
6065 if (type
!= MO_VAL_SET
)
6066 goto log_and_return
;
6068 v
= find_use_val (oloc
, mode
, cui
);
6071 goto log_and_return
;
6073 resolve
= preserve
= !cselib_preserved_value_p (v
);
6075 /* We cannot track values for multiple-part variables, so we track only
6076 locations for tracked record parameters. */
6080 && tracked_record_parameter_p (REG_EXPR (loc
)))
6082 /* Although we don't use the value here, it could be used later by the
6083 mere virtue of its existence as the operand of the reverse operation
6084 that gave rise to it (typically extension/truncation). Make sure it
6085 is preserved as required by vt_expand_var_loc_chain. */
6088 goto log_and_return
;
6091 if (loc
== stack_pointer_rtx
6092 && hard_frame_pointer_adjustment
!= -1
6094 cselib_set_value_sp_based (v
);
6096 nloc
= replace_expr_with_values (oloc
);
6100 if (GET_CODE (PATTERN (cui
->insn
)) == COND_EXEC
)
6102 cselib_val
*oval
= cselib_lookup (oloc
, GET_MODE (oloc
), 0, VOIDmode
);
6106 gcc_assert (REG_P (oloc
) || MEM_P (oloc
));
6108 if (oval
&& !cselib_preserved_value_p (oval
))
6110 micro_operation moa
;
6112 preserve_value (oval
);
6114 moa
.type
= MO_VAL_USE
;
6115 moa
.u
.loc
= gen_rtx_CONCAT (mode
, oval
->val_rtx
, oloc
);
6116 VAL_NEEDS_RESOLUTION (moa
.u
.loc
) = 1;
6117 moa
.insn
= cui
->insn
;
6119 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6120 log_op_type (moa
.u
.loc
, cui
->bb
, cui
->insn
,
6121 moa
.type
, dump_file
);
6122 VTI (bb
)->mos
.safe_push (moa
);
6127 else if (resolve
&& GET_CODE (mo
.u
.loc
) == SET
)
6129 if (REG_P (SET_SRC (expr
)) || MEM_P (SET_SRC (expr
)))
6130 nloc
= replace_expr_with_values (SET_SRC (expr
));
6134 /* Avoid the mode mismatch between oexpr and expr. */
6135 if (!nloc
&& mode
!= mode2
)
6137 nloc
= SET_SRC (expr
);
6138 gcc_assert (oloc
== SET_DEST (expr
));
6141 if (nloc
&& nloc
!= SET_SRC (mo
.u
.loc
))
6142 oloc
= gen_rtx_SET (oloc
, nloc
);
6145 if (oloc
== SET_DEST (mo
.u
.loc
))
6146 /* No point in duplicating. */
6148 if (!REG_P (SET_SRC (mo
.u
.loc
)))
6154 if (GET_CODE (mo
.u
.loc
) == SET
6155 && oloc
== SET_DEST (mo
.u
.loc
))
6156 /* No point in duplicating. */
6162 loc
= gen_rtx_CONCAT (mode
, v
->val_rtx
, oloc
);
6164 if (mo
.u
.loc
!= oloc
)
6165 loc
= gen_rtx_CONCAT (GET_MODE (mo
.u
.loc
), loc
, mo
.u
.loc
);
6167 /* The loc of a MO_VAL_SET may have various forms:
6169 (concat val dst): dst now holds val
6171 (concat val (set dst src)): dst now holds val, copied from src
6173 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6174 after replacing mems and non-top-level regs with values.
6176 (concat (concat val dstv) (set dst src)): dst now holds val,
6177 copied from src. dstv is a value-based representation of dst, if
6178 it differs from dst. If resolution is needed, src is a REG, and
6179 its mode is the same as that of val.
6181 (concat (concat val (set dstv srcv)) (set dst src)): src
6182 copied to dst, holding val. dstv and srcv are value-based
6183 representations of dst and src, respectively.
6187 if (GET_CODE (PATTERN (cui
->insn
)) != COND_EXEC
)
6188 reverse_op (v
->val_rtx
, expr
, cui
->insn
);
6193 VAL_HOLDS_TRACK_EXPR (loc
) = 1;
6196 VAL_NEEDS_RESOLUTION (loc
) = resolve
;
6199 if (mo
.type
== MO_CLOBBER
)
6200 VAL_EXPR_IS_CLOBBERED (loc
) = 1;
6201 if (mo
.type
== MO_COPY
)
6202 VAL_EXPR_IS_COPIED (loc
) = 1;
6204 mo
.type
= MO_VAL_SET
;
6207 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6208 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
6209 VTI (bb
)->mos
.safe_push (mo
);
6212 /* Arguments to the call. */
6213 static rtx call_arguments
;
6215 /* Compute call_arguments. */
6218 prepare_call_arguments (basic_block bb
, rtx_insn
*insn
)
6221 rtx prev
, cur
, next
;
6222 rtx this_arg
= NULL_RTX
;
6223 tree type
= NULL_TREE
, t
, fndecl
= NULL_TREE
;
6224 tree obj_type_ref
= NULL_TREE
;
6225 CUMULATIVE_ARGS args_so_far_v
;
6226 cumulative_args_t args_so_far
;
6228 memset (&args_so_far_v
, 0, sizeof (args_so_far_v
));
6229 args_so_far
= pack_cumulative_args (&args_so_far_v
);
6230 call
= get_call_rtx_from (insn
);
6233 if (GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
6235 rtx symbol
= XEXP (XEXP (call
, 0), 0);
6236 if (SYMBOL_REF_DECL (symbol
))
6237 fndecl
= SYMBOL_REF_DECL (symbol
);
6239 if (fndecl
== NULL_TREE
)
6240 fndecl
= MEM_EXPR (XEXP (call
, 0));
6242 && TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
6243 && TREE_CODE (TREE_TYPE (fndecl
)) != METHOD_TYPE
)
6245 if (fndecl
&& TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6246 type
= TREE_TYPE (fndecl
);
6247 if (fndecl
&& TREE_CODE (fndecl
) != FUNCTION_DECL
)
6249 if (TREE_CODE (fndecl
) == INDIRECT_REF
6250 && TREE_CODE (TREE_OPERAND (fndecl
, 0)) == OBJ_TYPE_REF
)
6251 obj_type_ref
= TREE_OPERAND (fndecl
, 0);
6256 for (t
= TYPE_ARG_TYPES (type
); t
&& t
!= void_list_node
;
6258 if (TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
6259 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t
))))
6261 if ((t
== NULL
|| t
== void_list_node
) && obj_type_ref
== NULL_TREE
)
6265 int nargs ATTRIBUTE_UNUSED
= list_length (TYPE_ARG_TYPES (type
));
6266 link
= CALL_INSN_FUNCTION_USAGE (insn
);
6267 #ifndef PCC_STATIC_STRUCT_RETURN
6268 if (aggregate_value_p (TREE_TYPE (type
), type
)
6269 && targetm
.calls
.struct_value_rtx (type
, 0) == 0)
6271 tree struct_addr
= build_pointer_type (TREE_TYPE (type
));
6272 machine_mode mode
= TYPE_MODE (struct_addr
);
6274 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6276 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6278 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6280 if (reg
== NULL_RTX
)
6282 for (; link
; link
= XEXP (link
, 1))
6283 if (GET_CODE (XEXP (link
, 0)) == USE
6284 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6286 link
= XEXP (link
, 1);
6293 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6295 if (obj_type_ref
&& TYPE_ARG_TYPES (type
) != void_list_node
)
6298 t
= TYPE_ARG_TYPES (type
);
6299 mode
= TYPE_MODE (TREE_VALUE (t
));
6300 this_arg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6301 TREE_VALUE (t
), true);
6302 if (this_arg
&& !REG_P (this_arg
))
6303 this_arg
= NULL_RTX
;
6304 else if (this_arg
== NULL_RTX
)
6306 for (; link
; link
= XEXP (link
, 1))
6307 if (GET_CODE (XEXP (link
, 0)) == USE
6308 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6310 this_arg
= XEXP (XEXP (link
, 0), 0);
6318 t
= type
? TYPE_ARG_TYPES (type
) : NULL_TREE
;
6320 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
6321 if (GET_CODE (XEXP (link
, 0)) == USE
)
6323 rtx item
= NULL_RTX
;
6324 x
= XEXP (XEXP (link
, 0), 0);
6325 if (GET_MODE (link
) == VOIDmode
6326 || GET_MODE (link
) == BLKmode
6327 || (GET_MODE (link
) != GET_MODE (x
)
6328 && ((GET_MODE_CLASS (GET_MODE (link
)) != MODE_INT
6329 && GET_MODE_CLASS (GET_MODE (link
)) != MODE_PARTIAL_INT
)
6330 || (GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
6331 && GET_MODE_CLASS (GET_MODE (x
)) != MODE_PARTIAL_INT
))))
6332 /* Can't do anything for these, if the original type mode
6333 isn't known or can't be converted. */;
6336 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6337 scalar_int_mode mode
;
6338 if (val
&& cselib_preserved_value_p (val
))
6339 item
= val
->val_rtx
;
6340 else if (is_a
<scalar_int_mode
> (GET_MODE (x
), &mode
))
6342 opt_scalar_int_mode mode_iter
;
6343 FOR_EACH_WIDER_MODE (mode_iter
, mode
)
6345 mode
= mode_iter
.require ();
6346 if (GET_MODE_BITSIZE (mode
) > BITS_PER_WORD
)
6349 rtx reg
= simplify_subreg (mode
, x
, GET_MODE (x
), 0);
6350 if (reg
== NULL_RTX
|| !REG_P (reg
))
6352 val
= cselib_lookup (reg
, mode
, 0, VOIDmode
);
6353 if (val
&& cselib_preserved_value_p (val
))
6355 item
= val
->val_rtx
;
6366 if (!frame_pointer_needed
)
6368 struct adjust_mem_data amd
;
6369 amd
.mem_mode
= VOIDmode
;
6370 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
6372 mem
= simplify_replace_fn_rtx (mem
, NULL_RTX
, adjust_mems
,
6374 gcc_assert (amd
.side_effects
.is_empty ());
6376 val
= cselib_lookup (mem
, GET_MODE (mem
), 0, VOIDmode
);
6377 if (val
&& cselib_preserved_value_p (val
))
6378 item
= val
->val_rtx
;
6379 else if (GET_MODE_CLASS (GET_MODE (mem
)) != MODE_INT
6380 && GET_MODE_CLASS (GET_MODE (mem
)) != MODE_PARTIAL_INT
)
6382 /* For non-integer stack argument see also if they weren't
6383 initialized by integers. */
6384 scalar_int_mode imode
;
6385 if (int_mode_for_mode (GET_MODE (mem
)).exists (&imode
)
6386 && imode
!= GET_MODE (mem
))
6388 val
= cselib_lookup (adjust_address_nv (mem
, imode
, 0),
6389 imode
, 0, VOIDmode
);
6390 if (val
&& cselib_preserved_value_p (val
))
6391 item
= lowpart_subreg (GET_MODE (x
), val
->val_rtx
,
6399 if (GET_MODE (item
) != GET_MODE (link
))
6400 item
= lowpart_subreg (GET_MODE (link
), item
, GET_MODE (item
));
6401 if (GET_MODE (x2
) != GET_MODE (link
))
6402 x2
= lowpart_subreg (GET_MODE (link
), x2
, GET_MODE (x2
));
6403 item
= gen_rtx_CONCAT (GET_MODE (link
), x2
, item
);
6405 = gen_rtx_EXPR_LIST (VOIDmode
, item
, call_arguments
);
6407 if (t
&& t
!= void_list_node
)
6409 tree argtype
= TREE_VALUE (t
);
6410 machine_mode mode
= TYPE_MODE (argtype
);
6412 if (pass_by_reference (&args_so_far_v
, mode
, argtype
, true))
6414 argtype
= build_pointer_type (argtype
);
6415 mode
= TYPE_MODE (argtype
);
6417 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6419 if (TREE_CODE (argtype
) == REFERENCE_TYPE
6420 && INTEGRAL_TYPE_P (TREE_TYPE (argtype
))
6423 && GET_MODE (reg
) == mode
6424 && (GET_MODE_CLASS (mode
) == MODE_INT
6425 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
6427 && REGNO (x
) == REGNO (reg
)
6428 && GET_MODE (x
) == mode
6431 machine_mode indmode
6432 = TYPE_MODE (TREE_TYPE (argtype
));
6433 rtx mem
= gen_rtx_MEM (indmode
, x
);
6434 cselib_val
*val
= cselib_lookup (mem
, indmode
, 0, VOIDmode
);
6435 if (val
&& cselib_preserved_value_p (val
))
6437 item
= gen_rtx_CONCAT (indmode
, mem
, val
->val_rtx
);
6438 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6443 struct elt_loc_list
*l
;
6446 /* Try harder, when passing address of a constant
6447 pool integer it can be easily read back. */
6448 item
= XEXP (item
, 1);
6449 if (GET_CODE (item
) == SUBREG
)
6450 item
= SUBREG_REG (item
);
6451 gcc_assert (GET_CODE (item
) == VALUE
);
6452 val
= CSELIB_VAL_PTR (item
);
6453 for (l
= val
->locs
; l
; l
= l
->next
)
6454 if (GET_CODE (l
->loc
) == SYMBOL_REF
6455 && TREE_CONSTANT_POOL_ADDRESS_P (l
->loc
)
6456 && SYMBOL_REF_DECL (l
->loc
)
6457 && DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
)))
6459 initial
= DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
));
6460 if (tree_fits_shwi_p (initial
))
6462 item
= GEN_INT (tree_to_shwi (initial
));
6463 item
= gen_rtx_CONCAT (indmode
, mem
, item
);
6465 = gen_rtx_EXPR_LIST (VOIDmode
, item
,
6472 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6478 /* Add debug arguments. */
6480 && TREE_CODE (fndecl
) == FUNCTION_DECL
6481 && DECL_HAS_DEBUG_ARGS_P (fndecl
))
6483 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (fndecl
);
6488 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, ¶m
); ix
+= 2)
6491 tree dtemp
= (**debug_args
)[ix
+ 1];
6492 machine_mode mode
= DECL_MODE (dtemp
);
6493 item
= gen_rtx_DEBUG_PARAMETER_REF (mode
, param
);
6494 item
= gen_rtx_CONCAT (mode
, item
, DECL_RTL_KNOWN_SET (dtemp
));
6495 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6501 /* Reverse call_arguments chain. */
6503 for (cur
= call_arguments
; cur
; cur
= next
)
6505 next
= XEXP (cur
, 1);
6506 XEXP (cur
, 1) = prev
;
6509 call_arguments
= prev
;
6511 x
= get_call_rtx_from (insn
);
6514 x
= XEXP (XEXP (x
, 0), 0);
6515 if (GET_CODE (x
) == SYMBOL_REF
)
6516 /* Don't record anything. */;
6517 else if (CONSTANT_P (x
))
6519 x
= gen_rtx_CONCAT (GET_MODE (x
) == VOIDmode
? Pmode
: GET_MODE (x
),
6522 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6526 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6527 if (val
&& cselib_preserved_value_p (val
))
6529 x
= gen_rtx_CONCAT (GET_MODE (x
), pc_rtx
, val
->val_rtx
);
6531 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6538 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref
)));
6539 rtx clobbered
= gen_rtx_MEM (mode
, this_arg
);
6541 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref
));
6543 clobbered
= plus_constant (mode
, clobbered
,
6544 token
* GET_MODE_SIZE (mode
));
6545 clobbered
= gen_rtx_MEM (mode
, clobbered
);
6546 x
= gen_rtx_CONCAT (mode
, gen_rtx_CLOBBER (VOIDmode
, pc_rtx
), clobbered
);
6548 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6552 /* Callback for cselib_record_sets_hook, that records as micro
6553 operations uses and stores in an insn after cselib_record_sets has
6554 analyzed the sets in an insn, but before it modifies the stored
6555 values in the internal tables, unless cselib_record_sets doesn't
6556 call it directly (perhaps because we're not doing cselib in the
6557 first place, in which case sets and n_sets will be 0). */
6560 add_with_sets (rtx_insn
*insn
, struct cselib_set
*sets
, int n_sets
)
6562 basic_block bb
= BLOCK_FOR_INSN (insn
);
6564 struct count_use_info cui
;
6565 micro_operation
*mos
;
6567 cselib_hook_called
= true;
6572 cui
.n_sets
= n_sets
;
6574 n1
= VTI (bb
)->mos
.length ();
6575 cui
.store_p
= false;
6576 note_uses (&PATTERN (insn
), add_uses_1
, &cui
);
6577 n2
= VTI (bb
)->mos
.length () - 1;
6578 mos
= VTI (bb
)->mos
.address ();
6580 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6584 while (n1
< n2
&& mos
[n1
].type
== MO_USE
)
6586 while (n1
< n2
&& mos
[n2
].type
!= MO_USE
)
6589 std::swap (mos
[n1
], mos
[n2
]);
6592 n2
= VTI (bb
)->mos
.length () - 1;
6595 while (n1
< n2
&& mos
[n1
].type
!= MO_VAL_LOC
)
6597 while (n1
< n2
&& mos
[n2
].type
== MO_VAL_LOC
)
6600 std::swap (mos
[n1
], mos
[n2
]);
6609 mo
.u
.loc
= call_arguments
;
6610 call_arguments
= NULL_RTX
;
6612 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6613 log_op_type (PATTERN (insn
), bb
, insn
, mo
.type
, dump_file
);
6614 VTI (bb
)->mos
.safe_push (mo
);
6617 n1
= VTI (bb
)->mos
.length ();
6618 /* This will record NEXT_INSN (insn), such that we can
6619 insert notes before it without worrying about any
6620 notes that MO_USEs might emit after the insn. */
6622 note_stores (PATTERN (insn
), add_stores
, &cui
);
6623 n2
= VTI (bb
)->mos
.length () - 1;
6624 mos
= VTI (bb
)->mos
.address ();
6626 /* Order the MO_VAL_USEs first (note_stores does nothing
6627 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6628 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6631 while (n1
< n2
&& mos
[n1
].type
== MO_VAL_USE
)
6633 while (n1
< n2
&& mos
[n2
].type
!= MO_VAL_USE
)
6636 std::swap (mos
[n1
], mos
[n2
]);
6639 n2
= VTI (bb
)->mos
.length () - 1;
6642 while (n1
< n2
&& mos
[n1
].type
== MO_CLOBBER
)
6644 while (n1
< n2
&& mos
[n2
].type
!= MO_CLOBBER
)
6647 std::swap (mos
[n1
], mos
[n2
]);
6651 static enum var_init_status
6652 find_src_status (dataflow_set
*in
, rtx src
)
6654 tree decl
= NULL_TREE
;
6655 enum var_init_status status
= VAR_INIT_STATUS_UNINITIALIZED
;
6657 if (! flag_var_tracking_uninit
)
6658 status
= VAR_INIT_STATUS_INITIALIZED
;
6660 if (src
&& REG_P (src
))
6661 decl
= var_debug_decl (REG_EXPR (src
));
6662 else if (src
&& MEM_P (src
))
6663 decl
= var_debug_decl (MEM_EXPR (src
));
6666 status
= get_init_value (in
, src
, dv_from_decl (decl
));
6671 /* SRC is the source of an assignment. Use SET to try to find what
6672 was ultimately assigned to SRC. Return that value if known,
6673 otherwise return SRC itself. */
6676 find_src_set_src (dataflow_set
*set
, rtx src
)
6678 tree decl
= NULL_TREE
; /* The variable being copied around. */
6679 rtx set_src
= NULL_RTX
; /* The value for "decl" stored in "src". */
6681 location_chain
*nextp
;
6685 if (src
&& REG_P (src
))
6686 decl
= var_debug_decl (REG_EXPR (src
));
6687 else if (src
&& MEM_P (src
))
6688 decl
= var_debug_decl (MEM_EXPR (src
));
6692 decl_or_value dv
= dv_from_decl (decl
);
6694 var
= shared_hash_find (set
->vars
, dv
);
6698 for (i
= 0; i
< var
->n_var_parts
&& !found
; i
++)
6699 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
&& !found
;
6700 nextp
= nextp
->next
)
6701 if (rtx_equal_p (nextp
->loc
, src
))
6703 set_src
= nextp
->set_src
;
6713 /* Compute the changes of variable locations in the basic block BB. */
6716 compute_bb_dataflow (basic_block bb
)
6719 micro_operation
*mo
;
6721 dataflow_set old_out
;
6722 dataflow_set
*in
= &VTI (bb
)->in
;
6723 dataflow_set
*out
= &VTI (bb
)->out
;
6725 dataflow_set_init (&old_out
);
6726 dataflow_set_copy (&old_out
, out
);
6727 dataflow_set_copy (out
, in
);
6729 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6730 local_get_addr_cache
= new hash_map
<rtx
, rtx
>;
6732 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
6734 rtx_insn
*insn
= mo
->insn
;
6739 dataflow_set_clear_at_call (out
, insn
);
6744 rtx loc
= mo
->u
.loc
;
6747 var_reg_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6748 else if (MEM_P (loc
))
6749 var_mem_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6755 rtx loc
= mo
->u
.loc
;
6759 if (GET_CODE (loc
) == CONCAT
)
6761 val
= XEXP (loc
, 0);
6762 vloc
= XEXP (loc
, 1);
6770 var
= PAT_VAR_LOCATION_DECL (vloc
);
6772 clobber_variable_part (out
, NULL_RTX
,
6773 dv_from_decl (var
), 0, NULL_RTX
);
6776 if (VAL_NEEDS_RESOLUTION (loc
))
6777 val_resolve (out
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
6778 set_variable_part (out
, val
, dv_from_decl (var
), 0,
6779 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6782 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
6783 set_variable_part (out
, PAT_VAR_LOCATION_LOC (vloc
),
6784 dv_from_decl (var
), 0,
6785 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6792 rtx loc
= mo
->u
.loc
;
6793 rtx val
, vloc
, uloc
;
6795 vloc
= uloc
= XEXP (loc
, 1);
6796 val
= XEXP (loc
, 0);
6798 if (GET_CODE (val
) == CONCAT
)
6800 uloc
= XEXP (val
, 1);
6801 val
= XEXP (val
, 0);
6804 if (VAL_NEEDS_RESOLUTION (loc
))
6805 val_resolve (out
, val
, vloc
, insn
);
6807 val_store (out
, val
, uloc
, insn
, false);
6809 if (VAL_HOLDS_TRACK_EXPR (loc
))
6811 if (GET_CODE (uloc
) == REG
)
6812 var_reg_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6814 else if (GET_CODE (uloc
) == MEM
)
6815 var_mem_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6823 rtx loc
= mo
->u
.loc
;
6824 rtx val
, vloc
, uloc
;
6828 uloc
= XEXP (vloc
, 1);
6829 val
= XEXP (vloc
, 0);
6832 if (GET_CODE (uloc
) == SET
)
6834 dstv
= SET_DEST (uloc
);
6835 srcv
= SET_SRC (uloc
);
6843 if (GET_CODE (val
) == CONCAT
)
6845 dstv
= vloc
= XEXP (val
, 1);
6846 val
= XEXP (val
, 0);
6849 if (GET_CODE (vloc
) == SET
)
6851 srcv
= SET_SRC (vloc
);
6853 gcc_assert (val
!= srcv
);
6854 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
6856 dstv
= vloc
= SET_DEST (vloc
);
6858 if (VAL_NEEDS_RESOLUTION (loc
))
6859 val_resolve (out
, val
, srcv
, insn
);
6861 else if (VAL_NEEDS_RESOLUTION (loc
))
6863 gcc_assert (GET_CODE (uloc
) == SET
6864 && GET_CODE (SET_SRC (uloc
)) == REG
);
6865 val_resolve (out
, val
, SET_SRC (uloc
), insn
);
6868 if (VAL_HOLDS_TRACK_EXPR (loc
))
6870 if (VAL_EXPR_IS_CLOBBERED (loc
))
6873 var_reg_delete (out
, uloc
, true);
6874 else if (MEM_P (uloc
))
6876 gcc_assert (MEM_P (dstv
));
6877 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
6878 var_mem_delete (out
, dstv
, true);
6883 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
6884 rtx src
= NULL
, dst
= uloc
;
6885 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
6887 if (GET_CODE (uloc
) == SET
)
6889 src
= SET_SRC (uloc
);
6890 dst
= SET_DEST (uloc
);
6895 if (flag_var_tracking_uninit
)
6897 status
= find_src_status (in
, src
);
6899 if (status
== VAR_INIT_STATUS_UNKNOWN
)
6900 status
= find_src_status (out
, src
);
6903 src
= find_src_set_src (in
, src
);
6907 var_reg_delete_and_set (out
, dst
, !copied_p
,
6909 else if (MEM_P (dst
))
6911 gcc_assert (MEM_P (dstv
));
6912 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
6913 var_mem_delete_and_set (out
, dstv
, !copied_p
,
6918 else if (REG_P (uloc
))
6919 var_regno_delete (out
, REGNO (uloc
));
6920 else if (MEM_P (uloc
))
6922 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
6923 gcc_checking_assert (dstv
== vloc
);
6925 clobber_overlapping_mems (out
, vloc
);
6928 val_store (out
, val
, dstv
, insn
, true);
6934 rtx loc
= mo
->u
.loc
;
6937 if (GET_CODE (loc
) == SET
)
6939 set_src
= SET_SRC (loc
);
6940 loc
= SET_DEST (loc
);
6944 var_reg_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6946 else if (MEM_P (loc
))
6947 var_mem_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6954 rtx loc
= mo
->u
.loc
;
6955 enum var_init_status src_status
;
6958 if (GET_CODE (loc
) == SET
)
6960 set_src
= SET_SRC (loc
);
6961 loc
= SET_DEST (loc
);
6964 if (! flag_var_tracking_uninit
)
6965 src_status
= VAR_INIT_STATUS_INITIALIZED
;
6968 src_status
= find_src_status (in
, set_src
);
6970 if (src_status
== VAR_INIT_STATUS_UNKNOWN
)
6971 src_status
= find_src_status (out
, set_src
);
6974 set_src
= find_src_set_src (in
, set_src
);
6977 var_reg_delete_and_set (out
, loc
, false, src_status
, set_src
);
6978 else if (MEM_P (loc
))
6979 var_mem_delete_and_set (out
, loc
, false, src_status
, set_src
);
6985 rtx loc
= mo
->u
.loc
;
6988 var_reg_delete (out
, loc
, false);
6989 else if (MEM_P (loc
))
6990 var_mem_delete (out
, loc
, false);
6996 rtx loc
= mo
->u
.loc
;
6999 var_reg_delete (out
, loc
, true);
7000 else if (MEM_P (loc
))
7001 var_mem_delete (out
, loc
, true);
7006 out
->stack_adjust
+= mo
->u
.adjust
;
7011 if (MAY_HAVE_DEBUG_BIND_INSNS
)
7013 delete local_get_addr_cache
;
7014 local_get_addr_cache
= NULL
;
7016 dataflow_set_equiv_regs (out
);
7017 shared_hash_htab (out
->vars
)
7018 ->traverse
<dataflow_set
*, canonicalize_values_mark
> (out
);
7019 shared_hash_htab (out
->vars
)
7020 ->traverse
<dataflow_set
*, canonicalize_values_star
> (out
);
7022 shared_hash_htab (out
->vars
)
7023 ->traverse
<dataflow_set
*, canonicalize_loc_order_check
> (out
);
7025 changed
= dataflow_set_different (&old_out
, out
);
7026 dataflow_set_destroy (&old_out
);
7030 /* Find the locations of variables in the whole function. */
7033 vt_find_locations (void)
7035 bb_heap_t
*worklist
= new bb_heap_t (LONG_MIN
);
7036 bb_heap_t
*pending
= new bb_heap_t (LONG_MIN
);
7037 sbitmap in_worklist
, in_pending
;
7044 int htabmax
= PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE
);
7045 bool success
= true;
7047 timevar_push (TV_VAR_TRACKING_DATAFLOW
);
7048 /* Compute reverse completion order of depth first search of the CFG
7049 so that the data-flow runs faster. */
7050 rc_order
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
7051 bb_order
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
7052 pre_and_rev_post_order_compute (NULL
, rc_order
, false);
7053 for (i
= 0; i
< n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
; i
++)
7054 bb_order
[rc_order
[i
]] = i
;
7057 auto_sbitmap
visited (last_basic_block_for_fn (cfun
));
7058 in_worklist
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
7059 in_pending
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
7060 bitmap_clear (in_worklist
);
7062 FOR_EACH_BB_FN (bb
, cfun
)
7063 pending
->insert (bb_order
[bb
->index
], bb
);
7064 bitmap_ones (in_pending
);
7066 while (success
&& !pending
->empty ())
7068 std::swap (worklist
, pending
);
7069 std::swap (in_worklist
, in_pending
);
7071 bitmap_clear (visited
);
7073 while (!worklist
->empty ())
7075 bb
= worklist
->extract_min ();
7076 bitmap_clear_bit (in_worklist
, bb
->index
);
7077 gcc_assert (!bitmap_bit_p (visited
, bb
->index
));
7078 if (!bitmap_bit_p (visited
, bb
->index
))
7082 int oldinsz
, oldoutsz
;
7084 bitmap_set_bit (visited
, bb
->index
);
7086 if (VTI (bb
)->in
.vars
)
7089 -= shared_hash_htab (VTI (bb
)->in
.vars
)->size ()
7090 + shared_hash_htab (VTI (bb
)->out
.vars
)->size ();
7091 oldinsz
= shared_hash_htab (VTI (bb
)->in
.vars
)->elements ();
7093 = shared_hash_htab (VTI (bb
)->out
.vars
)->elements ();
7096 oldinsz
= oldoutsz
= 0;
7098 if (MAY_HAVE_DEBUG_BIND_INSNS
)
7100 dataflow_set
*in
= &VTI (bb
)->in
, *first_out
= NULL
;
7101 bool first
= true, adjust
= false;
7103 /* Calculate the IN set as the intersection of
7104 predecessor OUT sets. */
7106 dataflow_set_clear (in
);
7107 dst_can_be_shared
= true;
7109 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7110 if (!VTI (e
->src
)->flooded
)
7111 gcc_assert (bb_order
[bb
->index
]
7112 <= bb_order
[e
->src
->index
]);
7115 dataflow_set_copy (in
, &VTI (e
->src
)->out
);
7116 first_out
= &VTI (e
->src
)->out
;
7121 dataflow_set_merge (in
, &VTI (e
->src
)->out
);
7127 dataflow_post_merge_adjust (in
, &VTI (bb
)->permp
);
7130 /* Merge and merge_adjust should keep entries in
7132 shared_hash_htab (in
->vars
)
7133 ->traverse
<dataflow_set
*,
7134 canonicalize_loc_order_check
> (in
);
7136 if (dst_can_be_shared
)
7138 shared_hash_destroy (in
->vars
);
7139 in
->vars
= shared_hash_copy (first_out
->vars
);
7143 VTI (bb
)->flooded
= true;
7147 /* Calculate the IN set as union of predecessor OUT sets. */
7148 dataflow_set_clear (&VTI (bb
)->in
);
7149 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7150 dataflow_set_union (&VTI (bb
)->in
, &VTI (e
->src
)->out
);
7153 changed
= compute_bb_dataflow (bb
);
7154 htabsz
+= shared_hash_htab (VTI (bb
)->in
.vars
)->size ()
7155 + shared_hash_htab (VTI (bb
)->out
.vars
)->size ();
7157 if (htabmax
&& htabsz
> htabmax
)
7159 if (MAY_HAVE_DEBUG_BIND_INSNS
)
7160 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7161 "variable tracking size limit exceeded with "
7162 "-fvar-tracking-assignments, retrying without");
7164 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7165 "variable tracking size limit exceeded");
7172 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7174 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7177 if (bitmap_bit_p (visited
, e
->dest
->index
))
7179 if (!bitmap_bit_p (in_pending
, e
->dest
->index
))
7181 /* Send E->DEST to next round. */
7182 bitmap_set_bit (in_pending
, e
->dest
->index
);
7183 pending
->insert (bb_order
[e
->dest
->index
],
7187 else if (!bitmap_bit_p (in_worklist
, e
->dest
->index
))
7189 /* Add E->DEST to current round. */
7190 bitmap_set_bit (in_worklist
, e
->dest
->index
);
7191 worklist
->insert (bb_order
[e
->dest
->index
],
7199 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7201 (int)shared_hash_htab (VTI (bb
)->in
.vars
)->size (),
7203 (int)shared_hash_htab (VTI (bb
)->out
.vars
)->size (),
7205 (int)worklist
->nodes (), (int)pending
->nodes (),
7208 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7210 fprintf (dump_file
, "BB %i IN:\n", bb
->index
);
7211 dump_dataflow_set (&VTI (bb
)->in
);
7212 fprintf (dump_file
, "BB %i OUT:\n", bb
->index
);
7213 dump_dataflow_set (&VTI (bb
)->out
);
7219 if (success
&& MAY_HAVE_DEBUG_BIND_INSNS
)
7220 FOR_EACH_BB_FN (bb
, cfun
)
7221 gcc_assert (VTI (bb
)->flooded
);
7226 sbitmap_free (in_worklist
);
7227 sbitmap_free (in_pending
);
7229 timevar_pop (TV_VAR_TRACKING_DATAFLOW
);
7233 /* Print the content of the LIST to dump file. */
7236 dump_attrs_list (attrs
*list
)
7238 for (; list
; list
= list
->next
)
7240 if (dv_is_decl_p (list
->dv
))
7241 print_mem_expr (dump_file
, dv_as_decl (list
->dv
));
7243 print_rtl_single (dump_file
, dv_as_value (list
->dv
));
7244 fprintf (dump_file
, "+" HOST_WIDE_INT_PRINT_DEC
, list
->offset
);
7246 fprintf (dump_file
, "\n");
7249 /* Print the information about variable *SLOT to dump file. */
7252 dump_var_tracking_slot (variable
**slot
, void *data ATTRIBUTE_UNUSED
)
7254 variable
*var
= *slot
;
7258 /* Continue traversing the hash table. */
7262 /* Print the information about variable VAR to dump file. */
7265 dump_var (variable
*var
)
7268 location_chain
*node
;
7270 if (dv_is_decl_p (var
->dv
))
7272 const_tree decl
= dv_as_decl (var
->dv
);
7274 if (DECL_NAME (decl
))
7276 fprintf (dump_file
, " name: %s",
7277 IDENTIFIER_POINTER (DECL_NAME (decl
)));
7278 if (dump_flags
& TDF_UID
)
7279 fprintf (dump_file
, "D.%u", DECL_UID (decl
));
7281 else if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
7282 fprintf (dump_file
, " name: D#%u", DEBUG_TEMP_UID (decl
));
7284 fprintf (dump_file
, " name: D.%u", DECL_UID (decl
));
7285 fprintf (dump_file
, "\n");
7289 fputc (' ', dump_file
);
7290 print_rtl_single (dump_file
, dv_as_value (var
->dv
));
7293 for (i
= 0; i
< var
->n_var_parts
; i
++)
7295 fprintf (dump_file
, " offset %ld\n",
7296 (long)(var
->onepart
? 0 : VAR_PART_OFFSET (var
, i
)));
7297 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
7299 fprintf (dump_file
, " ");
7300 if (node
->init
== VAR_INIT_STATUS_UNINITIALIZED
)
7301 fprintf (dump_file
, "[uninit]");
7302 print_rtl_single (dump_file
, node
->loc
);
7307 /* Print the information about variables from hash table VARS to dump file. */
7310 dump_vars (variable_table_type
*vars
)
7312 if (vars
->elements () > 0)
7314 fprintf (dump_file
, "Variables:\n");
7315 vars
->traverse
<void *, dump_var_tracking_slot
> (NULL
);
7319 /* Print the dataflow set SET to dump file. */
7322 dump_dataflow_set (dataflow_set
*set
)
7326 fprintf (dump_file
, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC
"\n",
7328 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
7332 fprintf (dump_file
, "Reg %d:", i
);
7333 dump_attrs_list (set
->regs
[i
]);
7336 dump_vars (shared_hash_htab (set
->vars
));
7337 fprintf (dump_file
, "\n");
7340 /* Print the IN and OUT sets for each basic block to dump file. */
7343 dump_dataflow_sets (void)
7347 FOR_EACH_BB_FN (bb
, cfun
)
7349 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
7350 fprintf (dump_file
, "IN:\n");
7351 dump_dataflow_set (&VTI (bb
)->in
);
7352 fprintf (dump_file
, "OUT:\n");
7353 dump_dataflow_set (&VTI (bb
)->out
);
7357 /* Return the variable for DV in dropped_values, inserting one if
7358 requested with INSERT. */
7360 static inline variable
*
7361 variable_from_dropped (decl_or_value dv
, enum insert_option insert
)
7364 variable
*empty_var
;
7365 onepart_enum onepart
;
7367 slot
= dropped_values
->find_slot_with_hash (dv
, dv_htab_hash (dv
), insert
);
7375 gcc_checking_assert (insert
== INSERT
);
7377 onepart
= dv_onepart_p (dv
);
7379 gcc_checking_assert (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
);
7381 empty_var
= onepart_pool_allocate (onepart
);
7383 empty_var
->refcount
= 1;
7384 empty_var
->n_var_parts
= 0;
7385 empty_var
->onepart
= onepart
;
7386 empty_var
->in_changed_variables
= false;
7387 empty_var
->var_part
[0].loc_chain
= NULL
;
7388 empty_var
->var_part
[0].cur_loc
= NULL
;
7389 VAR_LOC_1PAUX (empty_var
) = NULL
;
7390 set_dv_changed (dv
, true);
7397 /* Recover the one-part aux from dropped_values. */
7399 static struct onepart_aux
*
7400 recover_dropped_1paux (variable
*var
)
7404 gcc_checking_assert (var
->onepart
);
7406 if (VAR_LOC_1PAUX (var
))
7407 return VAR_LOC_1PAUX (var
);
7409 if (var
->onepart
== ONEPART_VDECL
)
7412 dvar
= variable_from_dropped (var
->dv
, NO_INSERT
);
7417 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (dvar
);
7418 VAR_LOC_1PAUX (dvar
) = NULL
;
7420 return VAR_LOC_1PAUX (var
);
7423 /* Add variable VAR to the hash table of changed variables and
7424 if it has no locations delete it from SET's hash table. */
7427 variable_was_changed (variable
*var
, dataflow_set
*set
)
7429 hashval_t hash
= dv_htab_hash (var
->dv
);
7435 /* Remember this decl or VALUE has been added to changed_variables. */
7436 set_dv_changed (var
->dv
, true);
7438 slot
= changed_variables
->find_slot_with_hash (var
->dv
, hash
, INSERT
);
7442 variable
*old_var
= *slot
;
7443 gcc_assert (old_var
->in_changed_variables
);
7444 old_var
->in_changed_variables
= false;
7445 if (var
!= old_var
&& var
->onepart
)
7447 /* Restore the auxiliary info from an empty variable
7448 previously created for changed_variables, so it is
7450 gcc_checking_assert (!VAR_LOC_1PAUX (var
));
7451 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (old_var
);
7452 VAR_LOC_1PAUX (old_var
) = NULL
;
7454 variable_htab_free (*slot
);
7457 if (set
&& var
->n_var_parts
== 0)
7459 onepart_enum onepart
= var
->onepart
;
7460 variable
*empty_var
= NULL
;
7461 variable
**dslot
= NULL
;
7463 if (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
)
7465 dslot
= dropped_values
->find_slot_with_hash (var
->dv
,
7466 dv_htab_hash (var
->dv
),
7472 gcc_checking_assert (!empty_var
->in_changed_variables
);
7473 if (!VAR_LOC_1PAUX (var
))
7475 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (empty_var
);
7476 VAR_LOC_1PAUX (empty_var
) = NULL
;
7479 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
7485 empty_var
= onepart_pool_allocate (onepart
);
7486 empty_var
->dv
= var
->dv
;
7487 empty_var
->refcount
= 1;
7488 empty_var
->n_var_parts
= 0;
7489 empty_var
->onepart
= onepart
;
7492 empty_var
->refcount
++;
7497 empty_var
->refcount
++;
7498 empty_var
->in_changed_variables
= true;
7502 empty_var
->var_part
[0].loc_chain
= NULL
;
7503 empty_var
->var_part
[0].cur_loc
= NULL
;
7504 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (var
);
7505 VAR_LOC_1PAUX (var
) = NULL
;
7511 if (var
->onepart
&& !VAR_LOC_1PAUX (var
))
7512 recover_dropped_1paux (var
);
7514 var
->in_changed_variables
= true;
7521 if (var
->n_var_parts
== 0)
7526 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
7529 if (shared_hash_shared (set
->vars
))
7530 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
,
7532 shared_hash_htab (set
->vars
)->clear_slot (slot
);
7538 /* Look for the index in VAR->var_part corresponding to OFFSET.
7539 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7540 referenced int will be set to the index that the part has or should
7541 have, if it should be inserted. */
7544 find_variable_location_part (variable
*var
, HOST_WIDE_INT offset
,
7545 int *insertion_point
)
7554 if (insertion_point
)
7555 *insertion_point
= 0;
7557 return var
->n_var_parts
- 1;
7560 /* Find the location part. */
7562 high
= var
->n_var_parts
;
7565 pos
= (low
+ high
) / 2;
7566 if (VAR_PART_OFFSET (var
, pos
) < offset
)
7573 if (insertion_point
)
7574 *insertion_point
= pos
;
7576 if (pos
< var
->n_var_parts
&& VAR_PART_OFFSET (var
, pos
) == offset
)
7583 set_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7584 decl_or_value dv
, HOST_WIDE_INT offset
,
7585 enum var_init_status initialized
, rtx set_src
)
7588 location_chain
*node
, *next
;
7589 location_chain
**nextp
;
7591 onepart_enum onepart
;
7596 onepart
= var
->onepart
;
7598 onepart
= dv_onepart_p (dv
);
7600 gcc_checking_assert (offset
== 0 || !onepart
);
7601 gcc_checking_assert (loc
!= dv_as_opaque (dv
));
7603 if (! flag_var_tracking_uninit
)
7604 initialized
= VAR_INIT_STATUS_INITIALIZED
;
7608 /* Create new variable information. */
7609 var
= onepart_pool_allocate (onepart
);
7612 var
->n_var_parts
= 1;
7613 var
->onepart
= onepart
;
7614 var
->in_changed_variables
= false;
7616 VAR_LOC_1PAUX (var
) = NULL
;
7618 VAR_PART_OFFSET (var
, 0) = offset
;
7619 var
->var_part
[0].loc_chain
= NULL
;
7620 var
->var_part
[0].cur_loc
= NULL
;
7623 nextp
= &var
->var_part
[0].loc_chain
;
7629 gcc_assert (dv_as_opaque (var
->dv
) == dv_as_opaque (dv
));
7633 if (GET_CODE (loc
) == VALUE
)
7635 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7636 nextp
= &node
->next
)
7637 if (GET_CODE (node
->loc
) == VALUE
)
7639 if (node
->loc
== loc
)
7644 if (canon_value_cmp (node
->loc
, loc
))
7652 else if (REG_P (node
->loc
) || MEM_P (node
->loc
))
7660 else if (REG_P (loc
))
7662 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7663 nextp
= &node
->next
)
7664 if (REG_P (node
->loc
))
7666 if (REGNO (node
->loc
) < REGNO (loc
))
7670 if (REGNO (node
->loc
) == REGNO (loc
))
7683 else if (MEM_P (loc
))
7685 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7686 nextp
= &node
->next
)
7687 if (REG_P (node
->loc
))
7689 else if (MEM_P (node
->loc
))
7691 if ((r
= loc_cmp (XEXP (node
->loc
, 0), XEXP (loc
, 0))) >= 0)
7703 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7704 nextp
= &node
->next
)
7705 if ((r
= loc_cmp (node
->loc
, loc
)) >= 0)
7713 if (shared_var_p (var
, set
->vars
))
7715 slot
= unshare_variable (set
, slot
, var
, initialized
);
7717 for (nextp
= &var
->var_part
[0].loc_chain
; c
;
7718 nextp
= &(*nextp
)->next
)
7720 gcc_assert ((!node
&& !*nextp
) || node
->loc
== (*nextp
)->loc
);
7727 gcc_assert (dv_as_decl (var
->dv
) == dv_as_decl (dv
));
7729 pos
= find_variable_location_part (var
, offset
, &inspos
);
7733 node
= var
->var_part
[pos
].loc_chain
;
7736 && ((REG_P (node
->loc
) && REG_P (loc
)
7737 && REGNO (node
->loc
) == REGNO (loc
))
7738 || rtx_equal_p (node
->loc
, loc
)))
7740 /* LOC is in the beginning of the chain so we have nothing
7742 if (node
->init
< initialized
)
7743 node
->init
= initialized
;
7744 if (set_src
!= NULL
)
7745 node
->set_src
= set_src
;
7751 /* We have to make a copy of a shared variable. */
7752 if (shared_var_p (var
, set
->vars
))
7754 slot
= unshare_variable (set
, slot
, var
, initialized
);
7761 /* We have not found the location part, new one will be created. */
7763 /* We have to make a copy of the shared variable. */
7764 if (shared_var_p (var
, set
->vars
))
7766 slot
= unshare_variable (set
, slot
, var
, initialized
);
7770 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7771 thus there are at most MAX_VAR_PARTS different offsets. */
7772 gcc_assert (var
->n_var_parts
< MAX_VAR_PARTS
7773 && (!var
->n_var_parts
|| !onepart
));
7775 /* We have to move the elements of array starting at index
7776 inspos to the next position. */
7777 for (pos
= var
->n_var_parts
; pos
> inspos
; pos
--)
7778 var
->var_part
[pos
] = var
->var_part
[pos
- 1];
7781 gcc_checking_assert (!onepart
);
7782 VAR_PART_OFFSET (var
, pos
) = offset
;
7783 var
->var_part
[pos
].loc_chain
= NULL
;
7784 var
->var_part
[pos
].cur_loc
= NULL
;
7787 /* Delete the location from the list. */
7788 nextp
= &var
->var_part
[pos
].loc_chain
;
7789 for (node
= var
->var_part
[pos
].loc_chain
; node
; node
= next
)
7792 if ((REG_P (node
->loc
) && REG_P (loc
)
7793 && REGNO (node
->loc
) == REGNO (loc
))
7794 || rtx_equal_p (node
->loc
, loc
))
7796 /* Save these values, to assign to the new node, before
7797 deleting this one. */
7798 if (node
->init
> initialized
)
7799 initialized
= node
->init
;
7800 if (node
->set_src
!= NULL
&& set_src
== NULL
)
7801 set_src
= node
->set_src
;
7802 if (var
->var_part
[pos
].cur_loc
== node
->loc
)
7803 var
->var_part
[pos
].cur_loc
= NULL
;
7809 nextp
= &node
->next
;
7812 nextp
= &var
->var_part
[pos
].loc_chain
;
7815 /* Add the location to the beginning. */
7816 node
= new location_chain
;
7818 node
->init
= initialized
;
7819 node
->set_src
= set_src
;
7820 node
->next
= *nextp
;
7823 /* If no location was emitted do so. */
7824 if (var
->var_part
[pos
].cur_loc
== NULL
)
7825 variable_was_changed (var
, set
);
7830 /* Set the part of variable's location in the dataflow set SET. The
7831 variable part is specified by variable's declaration in DV and
7832 offset OFFSET and the part's location by LOC. IOPT should be
7833 NO_INSERT if the variable is known to be in SET already and the
7834 variable hash table must not be resized, and INSERT otherwise. */
7837 set_variable_part (dataflow_set
*set
, rtx loc
,
7838 decl_or_value dv
, HOST_WIDE_INT offset
,
7839 enum var_init_status initialized
, rtx set_src
,
7840 enum insert_option iopt
)
7844 if (iopt
== NO_INSERT
)
7845 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7848 slot
= shared_hash_find_slot (set
->vars
, dv
);
7850 slot
= shared_hash_find_slot_unshare (&set
->vars
, dv
, iopt
);
7852 set_slot_part (set
, loc
, slot
, dv
, offset
, initialized
, set_src
);
7855 /* Remove all recorded register locations for the given variable part
7856 from dataflow set SET, except for those that are identical to loc.
7857 The variable part is specified by variable's declaration or value
7858 DV and offset OFFSET. */
7861 clobber_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7862 HOST_WIDE_INT offset
, rtx set_src
)
7864 variable
*var
= *slot
;
7865 int pos
= find_variable_location_part (var
, offset
, NULL
);
7869 location_chain
*node
, *next
;
7871 /* Remove the register locations from the dataflow set. */
7872 next
= var
->var_part
[pos
].loc_chain
;
7873 for (node
= next
; node
; node
= next
)
7876 if (node
->loc
!= loc
7877 && (!flag_var_tracking_uninit
7880 || !rtx_equal_p (set_src
, node
->set_src
)))
7882 if (REG_P (node
->loc
))
7884 attrs
*anode
, *anext
;
7887 /* Remove the variable part from the register's
7888 list, but preserve any other variable parts
7889 that might be regarded as live in that same
7891 anextp
= &set
->regs
[REGNO (node
->loc
)];
7892 for (anode
= *anextp
; anode
; anode
= anext
)
7894 anext
= anode
->next
;
7895 if (dv_as_opaque (anode
->dv
) == dv_as_opaque (var
->dv
)
7896 && anode
->offset
== offset
)
7902 anextp
= &anode
->next
;
7906 slot
= delete_slot_part (set
, node
->loc
, slot
, offset
);
7914 /* Remove all recorded register locations for the given variable part
7915 from dataflow set SET, except for those that are identical to loc.
7916 The variable part is specified by variable's declaration or value
7917 DV and offset OFFSET. */
7920 clobber_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7921 HOST_WIDE_INT offset
, rtx set_src
)
7925 if (!dv_as_opaque (dv
)
7926 || (!dv_is_value_p (dv
) && ! DECL_P (dv_as_decl (dv
))))
7929 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7933 clobber_slot_part (set
, loc
, slot
, offset
, set_src
);
7936 /* Delete the part of variable's location from dataflow set SET. The
7937 variable part is specified by its SET->vars slot SLOT and offset
7938 OFFSET and the part's location by LOC. */
7941 delete_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7942 HOST_WIDE_INT offset
)
7944 variable
*var
= *slot
;
7945 int pos
= find_variable_location_part (var
, offset
, NULL
);
7949 location_chain
*node
, *next
;
7950 location_chain
**nextp
;
7954 if (shared_var_p (var
, set
->vars
))
7956 /* If the variable contains the location part we have to
7957 make a copy of the variable. */
7958 for (node
= var
->var_part
[pos
].loc_chain
; node
;
7961 if ((REG_P (node
->loc
) && REG_P (loc
)
7962 && REGNO (node
->loc
) == REGNO (loc
))
7963 || rtx_equal_p (node
->loc
, loc
))
7965 slot
= unshare_variable (set
, slot
, var
,
7966 VAR_INIT_STATUS_UNKNOWN
);
7973 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7974 cur_loc
= VAR_LOC_FROM (var
);
7976 cur_loc
= var
->var_part
[pos
].cur_loc
;
7978 /* Delete the location part. */
7980 nextp
= &var
->var_part
[pos
].loc_chain
;
7981 for (node
= *nextp
; node
; node
= next
)
7984 if ((REG_P (node
->loc
) && REG_P (loc
)
7985 && REGNO (node
->loc
) == REGNO (loc
))
7986 || rtx_equal_p (node
->loc
, loc
))
7988 /* If we have deleted the location which was last emitted
7989 we have to emit new location so add the variable to set
7990 of changed variables. */
7991 if (cur_loc
== node
->loc
)
7994 var
->var_part
[pos
].cur_loc
= NULL
;
7995 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7996 VAR_LOC_FROM (var
) = NULL
;
8003 nextp
= &node
->next
;
8006 if (var
->var_part
[pos
].loc_chain
== NULL
)
8010 while (pos
< var
->n_var_parts
)
8012 var
->var_part
[pos
] = var
->var_part
[pos
+ 1];
8017 variable_was_changed (var
, set
);
8023 /* Delete the part of variable's location from dataflow set SET. The
8024 variable part is specified by variable's declaration or value DV
8025 and offset OFFSET and the part's location by LOC. */
8028 delete_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
8029 HOST_WIDE_INT offset
)
8031 variable
**slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
8035 delete_slot_part (set
, loc
, slot
, offset
);
8039 /* Structure for passing some other parameters to function
8040 vt_expand_loc_callback. */
8041 struct expand_loc_callback_data
8043 /* The variables and values active at this point. */
8044 variable_table_type
*vars
;
8046 /* Stack of values and debug_exprs under expansion, and their
8048 auto_vec
<rtx
, 4> expanding
;
8050 /* Stack of values and debug_exprs whose expansion hit recursion
8051 cycles. They will have VALUE_RECURSED_INTO marked when added to
8052 this list. This flag will be cleared if any of its dependencies
8053 resolves to a valid location. So, if the flag remains set at the
8054 end of the search, we know no valid location for this one can
8056 auto_vec
<rtx
, 4> pending
;
8058 /* The maximum depth among the sub-expressions under expansion.
8059 Zero indicates no expansion so far. */
8063 /* Allocate the one-part auxiliary data structure for VAR, with enough
8064 room for COUNT dependencies. */
8067 loc_exp_dep_alloc (variable
*var
, int count
)
8071 gcc_checking_assert (var
->onepart
);
8073 /* We can be called with COUNT == 0 to allocate the data structure
8074 without any dependencies, e.g. for the backlinks only. However,
8075 if we are specifying a COUNT, then the dependency list must have
8076 been emptied before. It would be possible to adjust pointers or
8077 force it empty here, but this is better done at an earlier point
8078 in the algorithm, so we instead leave an assertion to catch
8080 gcc_checking_assert (!count
8081 || VAR_LOC_DEP_VEC (var
) == NULL
8082 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8084 if (VAR_LOC_1PAUX (var
) && VAR_LOC_DEP_VEC (var
)->space (count
))
8087 allocsize
= offsetof (struct onepart_aux
, deps
)
8088 + vec
<loc_exp_dep
, va_heap
, vl_embed
>::embedded_size (count
);
8090 if (VAR_LOC_1PAUX (var
))
8092 VAR_LOC_1PAUX (var
) = XRESIZEVAR (struct onepart_aux
,
8093 VAR_LOC_1PAUX (var
), allocsize
);
8094 /* If the reallocation moves the onepaux structure, the
8095 back-pointer to BACKLINKS in the first list member will still
8096 point to its old location. Adjust it. */
8097 if (VAR_LOC_DEP_LST (var
))
8098 VAR_LOC_DEP_LST (var
)->pprev
= VAR_LOC_DEP_LSTP (var
);
8102 VAR_LOC_1PAUX (var
) = XNEWVAR (struct onepart_aux
, allocsize
);
8103 *VAR_LOC_DEP_LSTP (var
) = NULL
;
8104 VAR_LOC_FROM (var
) = NULL
;
8105 VAR_LOC_DEPTH (var
).complexity
= 0;
8106 VAR_LOC_DEPTH (var
).entryvals
= 0;
8108 VAR_LOC_DEP_VEC (var
)->embedded_init (count
);
8111 /* Remove all entries from the vector of active dependencies of VAR,
8112 removing them from the back-links lists too. */
8115 loc_exp_dep_clear (variable
*var
)
8117 while (VAR_LOC_DEP_VEC (var
) && !VAR_LOC_DEP_VEC (var
)->is_empty ())
8119 loc_exp_dep
*led
= &VAR_LOC_DEP_VEC (var
)->last ();
8121 led
->next
->pprev
= led
->pprev
;
8123 *led
->pprev
= led
->next
;
8124 VAR_LOC_DEP_VEC (var
)->pop ();
8128 /* Insert an active dependency from VAR on X to the vector of
8129 dependencies, and add the corresponding back-link to X's list of
8130 back-links in VARS. */
8133 loc_exp_insert_dep (variable
*var
, rtx x
, variable_table_type
*vars
)
8139 dv
= dv_from_rtx (x
);
8141 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8142 an additional look up? */
8143 xvar
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8147 xvar
= variable_from_dropped (dv
, NO_INSERT
);
8148 gcc_checking_assert (xvar
);
8151 /* No point in adding the same backlink more than once. This may
8152 arise if say the same value appears in two complex expressions in
8153 the same loc_list, or even more than once in a single
8155 if (VAR_LOC_DEP_LST (xvar
) && VAR_LOC_DEP_LST (xvar
)->dv
== var
->dv
)
8158 if (var
->onepart
== NOT_ONEPART
)
8159 led
= new loc_exp_dep
;
8163 memset (&empty
, 0, sizeof (empty
));
8164 VAR_LOC_DEP_VEC (var
)->quick_push (empty
);
8165 led
= &VAR_LOC_DEP_VEC (var
)->last ();
8170 loc_exp_dep_alloc (xvar
, 0);
8171 led
->pprev
= VAR_LOC_DEP_LSTP (xvar
);
8172 led
->next
= *led
->pprev
;
8174 led
->next
->pprev
= &led
->next
;
8178 /* Create active dependencies of VAR on COUNT values starting at
8179 VALUE, and corresponding back-links to the entries in VARS. Return
8180 true if we found any pending-recursion results. */
8183 loc_exp_dep_set (variable
*var
, rtx result
, rtx
*value
, int count
,
8184 variable_table_type
*vars
)
8186 bool pending_recursion
= false;
8188 gcc_checking_assert (VAR_LOC_DEP_VEC (var
) == NULL
8189 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8191 /* Set up all dependencies from last_child (as set up at the end of
8192 the loop above) to the end. */
8193 loc_exp_dep_alloc (var
, count
);
8199 if (!pending_recursion
)
8200 pending_recursion
= !result
&& VALUE_RECURSED_INTO (x
);
8202 loc_exp_insert_dep (var
, x
, vars
);
8205 return pending_recursion
;
8208 /* Notify the back-links of IVAR that are pending recursion that we
8209 have found a non-NIL value for it, so they are cleared for another
8210 attempt to compute a current location. */
8213 notify_dependents_of_resolved_value (variable
*ivar
, variable_table_type
*vars
)
8215 loc_exp_dep
*led
, *next
;
8217 for (led
= VAR_LOC_DEP_LST (ivar
); led
; led
= next
)
8219 decl_or_value dv
= led
->dv
;
8224 if (dv_is_value_p (dv
))
8226 rtx value
= dv_as_value (dv
);
8228 /* If we have already resolved it, leave it alone. */
8229 if (!VALUE_RECURSED_INTO (value
))
8232 /* Check that VALUE_RECURSED_INTO, true from the test above,
8233 implies NO_LOC_P. */
8234 gcc_checking_assert (NO_LOC_P (value
));
8236 /* We won't notify variables that are being expanded,
8237 because their dependency list is cleared before
8239 NO_LOC_P (value
) = false;
8240 VALUE_RECURSED_INTO (value
) = false;
8242 gcc_checking_assert (dv_changed_p (dv
));
8246 gcc_checking_assert (dv_onepart_p (dv
) != NOT_ONEPART
);
8247 if (!dv_changed_p (dv
))
8251 var
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8254 var
= variable_from_dropped (dv
, NO_INSERT
);
8257 notify_dependents_of_resolved_value (var
, vars
);
8260 next
->pprev
= led
->pprev
;
8268 static rtx
vt_expand_loc_callback (rtx x
, bitmap regs
,
8269 int max_depth
, void *data
);
8271 /* Return the combined depth, when one sub-expression evaluated to
8272 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8274 static inline expand_depth
8275 update_depth (expand_depth saved_depth
, expand_depth best_depth
)
8277 /* If we didn't find anything, stick with what we had. */
8278 if (!best_depth
.complexity
)
8281 /* If we found hadn't found anything, use the depth of the current
8282 expression. Do NOT add one extra level, we want to compute the
8283 maximum depth among sub-expressions. We'll increment it later,
8285 if (!saved_depth
.complexity
)
8288 /* Combine the entryval count so that regardless of which one we
8289 return, the entryval count is accurate. */
8290 best_depth
.entryvals
= saved_depth
.entryvals
8291 = best_depth
.entryvals
+ saved_depth
.entryvals
;
8293 if (saved_depth
.complexity
< best_depth
.complexity
)
8299 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8300 DATA for cselib expand callback. If PENDRECP is given, indicate in
8301 it whether any sub-expression couldn't be fully evaluated because
8302 it is pending recursion resolution. */
8305 vt_expand_var_loc_chain (variable
*var
, bitmap regs
, void *data
,
8308 struct expand_loc_callback_data
*elcd
8309 = (struct expand_loc_callback_data
*) data
;
8310 location_chain
*loc
, *next
;
8312 int first_child
, result_first_child
, last_child
;
8313 bool pending_recursion
;
8314 rtx loc_from
= NULL
;
8315 struct elt_loc_list
*cloc
= NULL
;
8316 expand_depth depth
= { 0, 0 }, saved_depth
= elcd
->depth
;
8317 int wanted_entryvals
, found_entryvals
= 0;
8319 /* Clear all backlinks pointing at this, so that we're not notified
8320 while we're active. */
8321 loc_exp_dep_clear (var
);
8324 if (var
->onepart
== ONEPART_VALUE
)
8326 cselib_val
*val
= CSELIB_VAL_PTR (dv_as_value (var
->dv
));
8328 gcc_checking_assert (cselib_preserved_value_p (val
));
8333 first_child
= result_first_child
= last_child
8334 = elcd
->expanding
.length ();
8336 wanted_entryvals
= found_entryvals
;
8338 /* Attempt to expand each available location in turn. */
8339 for (next
= loc
= var
->n_var_parts
? var
->var_part
[0].loc_chain
: NULL
;
8340 loc
|| cloc
; loc
= next
)
8342 result_first_child
= last_child
;
8346 loc_from
= cloc
->loc
;
8349 if (unsuitable_loc (loc_from
))
8354 loc_from
= loc
->loc
;
8358 gcc_checking_assert (!unsuitable_loc (loc_from
));
8360 elcd
->depth
.complexity
= elcd
->depth
.entryvals
= 0;
8361 result
= cselib_expand_value_rtx_cb (loc_from
, regs
, EXPR_DEPTH
,
8362 vt_expand_loc_callback
, data
);
8363 last_child
= elcd
->expanding
.length ();
8367 depth
= elcd
->depth
;
8369 gcc_checking_assert (depth
.complexity
8370 || result_first_child
== last_child
);
8372 if (last_child
- result_first_child
!= 1)
8374 if (!depth
.complexity
&& GET_CODE (result
) == ENTRY_VALUE
)
8379 if (depth
.complexity
<= EXPR_USE_DEPTH
)
8381 if (depth
.entryvals
<= wanted_entryvals
)
8383 else if (!found_entryvals
|| depth
.entryvals
< found_entryvals
)
8384 found_entryvals
= depth
.entryvals
;
8390 /* Set it up in case we leave the loop. */
8391 depth
.complexity
= depth
.entryvals
= 0;
8393 result_first_child
= first_child
;
8396 if (!loc_from
&& wanted_entryvals
< found_entryvals
)
8398 /* We found entries with ENTRY_VALUEs and skipped them. Since
8399 we could not find any expansions without ENTRY_VALUEs, but we
8400 found at least one with them, go back and get an entry with
8401 the minimum number ENTRY_VALUE count that we found. We could
8402 avoid looping, but since each sub-loc is already resolved,
8403 the re-expansion should be trivial. ??? Should we record all
8404 attempted locs as dependencies, so that we retry the
8405 expansion should any of them change, in the hope it can give
8406 us a new entry without an ENTRY_VALUE? */
8407 elcd
->expanding
.truncate (first_child
);
8411 /* Register all encountered dependencies as active. */
8412 pending_recursion
= loc_exp_dep_set
8413 (var
, result
, elcd
->expanding
.address () + result_first_child
,
8414 last_child
- result_first_child
, elcd
->vars
);
8416 elcd
->expanding
.truncate (first_child
);
8418 /* Record where the expansion came from. */
8419 gcc_checking_assert (!result
|| !pending_recursion
);
8420 VAR_LOC_FROM (var
) = loc_from
;
8421 VAR_LOC_DEPTH (var
) = depth
;
8423 gcc_checking_assert (!depth
.complexity
== !result
);
8425 elcd
->depth
= update_depth (saved_depth
, depth
);
8427 /* Indicate whether any of the dependencies are pending recursion
8430 *pendrecp
= pending_recursion
;
8432 if (!pendrecp
|| !pending_recursion
)
8433 var
->var_part
[0].cur_loc
= result
;
8438 /* Callback for cselib_expand_value, that looks for expressions
8439 holding the value in the var-tracking hash tables. Return X for
8440 standard processing, anything else is to be used as-is. */
8443 vt_expand_loc_callback (rtx x
, bitmap regs
,
8444 int max_depth ATTRIBUTE_UNUSED
,
8447 struct expand_loc_callback_data
*elcd
8448 = (struct expand_loc_callback_data
*) data
;
8452 bool pending_recursion
= false;
8453 bool from_empty
= false;
8455 switch (GET_CODE (x
))
8458 subreg
= cselib_expand_value_rtx_cb (SUBREG_REG (x
), regs
,
8460 vt_expand_loc_callback
, data
);
8465 result
= simplify_gen_subreg (GET_MODE (x
), subreg
,
8466 GET_MODE (SUBREG_REG (x
)),
8469 /* Invalid SUBREGs are ok in debug info. ??? We could try
8470 alternate expansions for the VALUE as well. */
8472 result
= gen_rtx_raw_SUBREG (GET_MODE (x
), subreg
, SUBREG_BYTE (x
));
8478 dv
= dv_from_rtx (x
);
8485 elcd
->expanding
.safe_push (x
);
8487 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8488 gcc_checking_assert (!VALUE_RECURSED_INTO (x
) || NO_LOC_P (x
));
8492 gcc_checking_assert (VALUE_RECURSED_INTO (x
) || !dv_changed_p (dv
));
8496 var
= elcd
->vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8501 var
= variable_from_dropped (dv
, INSERT
);
8504 gcc_checking_assert (var
);
8506 if (!dv_changed_p (dv
))
8508 gcc_checking_assert (!NO_LOC_P (x
));
8509 gcc_checking_assert (var
->var_part
[0].cur_loc
);
8510 gcc_checking_assert (VAR_LOC_1PAUX (var
));
8511 gcc_checking_assert (VAR_LOC_1PAUX (var
)->depth
.complexity
);
8513 elcd
->depth
= update_depth (elcd
->depth
, VAR_LOC_1PAUX (var
)->depth
);
8515 return var
->var_part
[0].cur_loc
;
8518 VALUE_RECURSED_INTO (x
) = true;
8519 /* This is tentative, but it makes some tests simpler. */
8520 NO_LOC_P (x
) = true;
8522 gcc_checking_assert (var
->n_var_parts
== 1 || from_empty
);
8524 result
= vt_expand_var_loc_chain (var
, regs
, data
, &pending_recursion
);
8526 if (pending_recursion
)
8528 gcc_checking_assert (!result
);
8529 elcd
->pending
.safe_push (x
);
8533 NO_LOC_P (x
) = !result
;
8534 VALUE_RECURSED_INTO (x
) = false;
8535 set_dv_changed (dv
, false);
8538 notify_dependents_of_resolved_value (var
, elcd
->vars
);
8544 /* While expanding variables, we may encounter recursion cycles
8545 because of mutual (possibly indirect) dependencies between two
8546 particular variables (or values), say A and B. If we're trying to
8547 expand A when we get to B, which in turn attempts to expand A, if
8548 we can't find any other expansion for B, we'll add B to this
8549 pending-recursion stack, and tentatively return NULL for its
8550 location. This tentative value will be used for any other
8551 occurrences of B, unless A gets some other location, in which case
8552 it will notify B that it is worth another try at computing a
8553 location for it, and it will use the location computed for A then.
8554 At the end of the expansion, the tentative NULL locations become
8555 final for all members of PENDING that didn't get a notification.
8556 This function performs this finalization of NULL locations. */
8559 resolve_expansions_pending_recursion (vec
<rtx
, va_heap
> *pending
)
8561 while (!pending
->is_empty ())
8563 rtx x
= pending
->pop ();
8566 if (!VALUE_RECURSED_INTO (x
))
8569 gcc_checking_assert (NO_LOC_P (x
));
8570 VALUE_RECURSED_INTO (x
) = false;
8571 dv
= dv_from_rtx (x
);
8572 gcc_checking_assert (dv_changed_p (dv
));
8573 set_dv_changed (dv
, false);
8577 /* Initialize expand_loc_callback_data D with variable hash table V.
8578 It must be a macro because of alloca (vec stack). */
8579 #define INIT_ELCD(d, v) \
8583 (d).depth.complexity = (d).depth.entryvals = 0; \
8586 /* Finalize expand_loc_callback_data D, resolved to location L. */
8587 #define FINI_ELCD(d, l) \
8590 resolve_expansions_pending_recursion (&(d).pending); \
8591 (d).pending.release (); \
8592 (d).expanding.release (); \
8594 if ((l) && MEM_P (l)) \
8595 (l) = targetm.delegitimize_address (l); \
8599 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8600 equivalences in VARS, updating their CUR_LOCs in the process. */
8603 vt_expand_loc (rtx loc
, variable_table_type
*vars
)
8605 struct expand_loc_callback_data data
;
8608 if (!MAY_HAVE_DEBUG_BIND_INSNS
)
8611 INIT_ELCD (data
, vars
);
8613 result
= cselib_expand_value_rtx_cb (loc
, scratch_regs
, EXPR_DEPTH
,
8614 vt_expand_loc_callback
, &data
);
8616 FINI_ELCD (data
, result
);
8621 /* Expand the one-part VARiable to a location, using the equivalences
8622 in VARS, updating their CUR_LOCs in the process. */
8625 vt_expand_1pvar (variable
*var
, variable_table_type
*vars
)
8627 struct expand_loc_callback_data data
;
8630 gcc_checking_assert (var
->onepart
&& var
->n_var_parts
== 1);
8632 if (!dv_changed_p (var
->dv
))
8633 return var
->var_part
[0].cur_loc
;
8635 INIT_ELCD (data
, vars
);
8637 loc
= vt_expand_var_loc_chain (var
, scratch_regs
, &data
, NULL
);
8639 gcc_checking_assert (data
.expanding
.is_empty ());
8641 FINI_ELCD (data
, loc
);
8646 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8647 additional parameters: WHERE specifies whether the note shall be emitted
8648 before or after instruction INSN. */
8651 emit_note_insn_var_location (variable
**varp
, emit_note_data
*data
)
8653 variable
*var
= *varp
;
8654 rtx_insn
*insn
= data
->insn
;
8655 enum emit_note_where where
= data
->where
;
8656 variable_table_type
*vars
= data
->vars
;
8659 int i
, j
, n_var_parts
;
8661 enum var_init_status initialized
= VAR_INIT_STATUS_UNINITIALIZED
;
8662 HOST_WIDE_INT last_limit
;
8663 tree type_size_unit
;
8664 HOST_WIDE_INT offsets
[MAX_VAR_PARTS
];
8665 rtx loc
[MAX_VAR_PARTS
];
8669 gcc_checking_assert (var
->onepart
== NOT_ONEPART
8670 || var
->onepart
== ONEPART_VDECL
);
8672 decl
= dv_as_decl (var
->dv
);
8678 for (i
= 0; i
< var
->n_var_parts
; i
++)
8679 if (var
->var_part
[i
].cur_loc
== NULL
&& var
->var_part
[i
].loc_chain
)
8680 var
->var_part
[i
].cur_loc
= var
->var_part
[i
].loc_chain
->loc
;
8681 for (i
= 0; i
< var
->n_var_parts
; i
++)
8683 machine_mode mode
, wider_mode
;
8685 HOST_WIDE_INT offset
;
8687 if (i
== 0 && var
->onepart
)
8689 gcc_checking_assert (var
->n_var_parts
== 1);
8691 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8692 loc2
= vt_expand_1pvar (var
, vars
);
8696 if (last_limit
< VAR_PART_OFFSET (var
, i
))
8701 else if (last_limit
> VAR_PART_OFFSET (var
, i
))
8703 offset
= VAR_PART_OFFSET (var
, i
);
8704 loc2
= var
->var_part
[i
].cur_loc
;
8705 if (loc2
&& GET_CODE (loc2
) == MEM
8706 && GET_CODE (XEXP (loc2
, 0)) == VALUE
)
8708 rtx depval
= XEXP (loc2
, 0);
8710 loc2
= vt_expand_loc (loc2
, vars
);
8713 loc_exp_insert_dep (var
, depval
, vars
);
8720 gcc_checking_assert (GET_CODE (loc2
) != VALUE
);
8721 for (lc
= var
->var_part
[i
].loc_chain
; lc
; lc
= lc
->next
)
8722 if (var
->var_part
[i
].cur_loc
== lc
->loc
)
8724 initialized
= lc
->init
;
8730 offsets
[n_var_parts
] = offset
;
8736 loc
[n_var_parts
] = loc2
;
8737 mode
= GET_MODE (var
->var_part
[i
].cur_loc
);
8738 if (mode
== VOIDmode
&& var
->onepart
)
8739 mode
= DECL_MODE (decl
);
8740 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8742 /* Attempt to merge adjacent registers or memory. */
8743 for (j
= i
+ 1; j
< var
->n_var_parts
; j
++)
8744 if (last_limit
<= VAR_PART_OFFSET (var
, j
))
8746 if (j
< var
->n_var_parts
8747 && GET_MODE_WIDER_MODE (mode
).exists (&wider_mode
)
8748 && var
->var_part
[j
].cur_loc
8749 && mode
== GET_MODE (var
->var_part
[j
].cur_loc
)
8750 && (REG_P (loc
[n_var_parts
]) || MEM_P (loc
[n_var_parts
]))
8751 && last_limit
== (var
->onepart
? 0 : VAR_PART_OFFSET (var
, j
))
8752 && (loc2
= vt_expand_loc (var
->var_part
[j
].cur_loc
, vars
))
8753 && GET_CODE (loc
[n_var_parts
]) == GET_CODE (loc2
))
8757 if (REG_P (loc
[n_var_parts
])
8758 && hard_regno_nregs (REGNO (loc
[n_var_parts
]), mode
) * 2
8759 == hard_regno_nregs (REGNO (loc
[n_var_parts
]), wider_mode
)
8760 && end_hard_regno (mode
, REGNO (loc
[n_var_parts
]))
8763 if (! WORDS_BIG_ENDIAN
&& ! BYTES_BIG_ENDIAN
)
8764 new_loc
= simplify_subreg (wider_mode
, loc
[n_var_parts
],
8766 else if (WORDS_BIG_ENDIAN
&& BYTES_BIG_ENDIAN
)
8767 new_loc
= simplify_subreg (wider_mode
, loc2
, mode
, 0);
8770 if (!REG_P (new_loc
)
8771 || REGNO (new_loc
) != REGNO (loc
[n_var_parts
]))
8774 REG_ATTRS (new_loc
) = REG_ATTRS (loc
[n_var_parts
]);
8777 else if (MEM_P (loc
[n_var_parts
])
8778 && GET_CODE (XEXP (loc2
, 0)) == PLUS
8779 && REG_P (XEXP (XEXP (loc2
, 0), 0))
8780 && CONST_INT_P (XEXP (XEXP (loc2
, 0), 1)))
8782 if ((REG_P (XEXP (loc
[n_var_parts
], 0))
8783 && rtx_equal_p (XEXP (loc
[n_var_parts
], 0),
8784 XEXP (XEXP (loc2
, 0), 0))
8785 && INTVAL (XEXP (XEXP (loc2
, 0), 1))
8786 == GET_MODE_SIZE (mode
))
8787 || (GET_CODE (XEXP (loc
[n_var_parts
], 0)) == PLUS
8788 && CONST_INT_P (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8789 && rtx_equal_p (XEXP (XEXP (loc
[n_var_parts
], 0), 0),
8790 XEXP (XEXP (loc2
, 0), 0))
8791 && INTVAL (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8792 + GET_MODE_SIZE (mode
)
8793 == INTVAL (XEXP (XEXP (loc2
, 0), 1))))
8794 new_loc
= adjust_address_nv (loc
[n_var_parts
],
8800 loc
[n_var_parts
] = new_loc
;
8802 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8808 type_size_unit
= TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8809 if ((unsigned HOST_WIDE_INT
) last_limit
< TREE_INT_CST_LOW (type_size_unit
))
8812 if (! flag_var_tracking_uninit
)
8813 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8817 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, NULL_RTX
, initialized
);
8818 else if (n_var_parts
== 1)
8822 if (offsets
[0] || GET_CODE (loc
[0]) == PARALLEL
)
8823 expr_list
= gen_rtx_EXPR_LIST (VOIDmode
, loc
[0], GEN_INT (offsets
[0]));
8827 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, expr_list
, initialized
);
8829 else if (n_var_parts
)
8833 for (i
= 0; i
< n_var_parts
; i
++)
8835 = gen_rtx_EXPR_LIST (VOIDmode
, loc
[i
], GEN_INT (offsets
[i
]));
8837 parallel
= gen_rtx_PARALLEL (VOIDmode
,
8838 gen_rtvec_v (n_var_parts
, loc
));
8839 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
,
8840 parallel
, initialized
);
8843 if (where
!= EMIT_NOTE_BEFORE_INSN
)
8845 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8846 if (where
== EMIT_NOTE_AFTER_CALL_INSN
)
8847 NOTE_DURING_CALL_P (note
) = true;
8851 /* Make sure that the call related notes come first. */
8852 while (NEXT_INSN (insn
)
8854 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8855 && NOTE_DURING_CALL_P (insn
))
8856 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8857 insn
= NEXT_INSN (insn
);
8859 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8860 && NOTE_DURING_CALL_P (insn
))
8861 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8862 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8864 note
= emit_note_before (NOTE_INSN_VAR_LOCATION
, insn
);
8866 NOTE_VAR_LOCATION (note
) = note_vl
;
8868 set_dv_changed (var
->dv
, false);
8869 gcc_assert (var
->in_changed_variables
);
8870 var
->in_changed_variables
= false;
8871 changed_variables
->clear_slot (varp
);
8873 /* Continue traversing the hash table. */
8877 /* While traversing changed_variables, push onto DATA (a stack of RTX
8878 values) entries that aren't user variables. */
8881 var_track_values_to_stack (variable
**slot
,
8882 vec
<rtx
, va_heap
> *changed_values_stack
)
8884 variable
*var
= *slot
;
8886 if (var
->onepart
== ONEPART_VALUE
)
8887 changed_values_stack
->safe_push (dv_as_value (var
->dv
));
8888 else if (var
->onepart
== ONEPART_DEXPR
)
8889 changed_values_stack
->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var
->dv
)));
8894 /* Remove from changed_variables the entry whose DV corresponds to
8895 value or debug_expr VAL. */
8897 remove_value_from_changed_variables (rtx val
)
8899 decl_or_value dv
= dv_from_rtx (val
);
8903 slot
= changed_variables
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8906 var
->in_changed_variables
= false;
8907 changed_variables
->clear_slot (slot
);
8910 /* If VAL (a value or debug_expr) has backlinks to variables actively
8911 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8912 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8913 have dependencies of their own to notify. */
8916 notify_dependents_of_changed_value (rtx val
, variable_table_type
*htab
,
8917 vec
<rtx
, va_heap
> *changed_values_stack
)
8922 decl_or_value dv
= dv_from_rtx (val
);
8924 slot
= changed_variables
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8927 slot
= htab
->find_slot_with_hash (dv
, dv_htab_hash (dv
), NO_INSERT
);
8929 slot
= dropped_values
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8933 while ((led
= VAR_LOC_DEP_LST (var
)))
8935 decl_or_value ldv
= led
->dv
;
8938 /* Deactivate and remove the backlink, as it was “used up”. It
8939 makes no sense to attempt to notify the same entity again:
8940 either it will be recomputed and re-register an active
8941 dependency, or it will still have the changed mark. */
8943 led
->next
->pprev
= led
->pprev
;
8945 *led
->pprev
= led
->next
;
8949 if (dv_changed_p (ldv
))
8952 switch (dv_onepart_p (ldv
))
8956 set_dv_changed (ldv
, true);
8957 changed_values_stack
->safe_push (dv_as_rtx (ldv
));
8961 ivar
= htab
->find_with_hash (ldv
, dv_htab_hash (ldv
));
8962 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar
));
8963 variable_was_changed (ivar
, NULL
);
8968 ivar
= htab
->find_with_hash (ldv
, dv_htab_hash (ldv
));
8971 int i
= ivar
->n_var_parts
;
8974 rtx loc
= ivar
->var_part
[i
].cur_loc
;
8976 if (loc
&& GET_CODE (loc
) == MEM
8977 && XEXP (loc
, 0) == val
)
8979 variable_was_changed (ivar
, NULL
);
8992 /* Take out of changed_variables any entries that don't refer to use
8993 variables. Back-propagate change notifications from values and
8994 debug_exprs to their active dependencies in HTAB or in
8995 CHANGED_VARIABLES. */
8998 process_changed_values (variable_table_type
*htab
)
9002 auto_vec
<rtx
, 20> changed_values_stack
;
9004 /* Move values from changed_variables to changed_values_stack. */
9006 ->traverse
<vec
<rtx
, va_heap
>*, var_track_values_to_stack
>
9007 (&changed_values_stack
);
9009 /* Back-propagate change notifications in values while popping
9010 them from the stack. */
9011 for (n
= i
= changed_values_stack
.length ();
9012 i
> 0; i
= changed_values_stack
.length ())
9014 val
= changed_values_stack
.pop ();
9015 notify_dependents_of_changed_value (val
, htab
, &changed_values_stack
);
9017 /* This condition will hold when visiting each of the entries
9018 originally in changed_variables. We can't remove them
9019 earlier because this could drop the backlinks before we got a
9020 chance to use them. */
9023 remove_value_from_changed_variables (val
);
9029 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
9030 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
9031 the notes shall be emitted before of after instruction INSN. */
9034 emit_notes_for_changes (rtx_insn
*insn
, enum emit_note_where where
,
9037 emit_note_data data
;
9038 variable_table_type
*htab
= shared_hash_htab (vars
);
9040 if (!changed_variables
->elements ())
9043 if (MAY_HAVE_DEBUG_BIND_INSNS
)
9044 process_changed_values (htab
);
9051 ->traverse
<emit_note_data
*, emit_note_insn_var_location
> (&data
);
9054 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9055 same variable in hash table DATA or is not there at all. */
9058 emit_notes_for_differences_1 (variable
**slot
, variable_table_type
*new_vars
)
9060 variable
*old_var
, *new_var
;
9063 new_var
= new_vars
->find_with_hash (old_var
->dv
, dv_htab_hash (old_var
->dv
));
9067 /* Variable has disappeared. */
9068 variable
*empty_var
= NULL
;
9070 if (old_var
->onepart
== ONEPART_VALUE
9071 || old_var
->onepart
== ONEPART_DEXPR
)
9073 empty_var
= variable_from_dropped (old_var
->dv
, NO_INSERT
);
9076 gcc_checking_assert (!empty_var
->in_changed_variables
);
9077 if (!VAR_LOC_1PAUX (old_var
))
9079 VAR_LOC_1PAUX (old_var
) = VAR_LOC_1PAUX (empty_var
);
9080 VAR_LOC_1PAUX (empty_var
) = NULL
;
9083 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
9089 empty_var
= onepart_pool_allocate (old_var
->onepart
);
9090 empty_var
->dv
= old_var
->dv
;
9091 empty_var
->refcount
= 0;
9092 empty_var
->n_var_parts
= 0;
9093 empty_var
->onepart
= old_var
->onepart
;
9094 empty_var
->in_changed_variables
= false;
9097 if (empty_var
->onepart
)
9099 /* Propagate the auxiliary data to (ultimately)
9100 changed_variables. */
9101 empty_var
->var_part
[0].loc_chain
= NULL
;
9102 empty_var
->var_part
[0].cur_loc
= NULL
;
9103 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (old_var
);
9104 VAR_LOC_1PAUX (old_var
) = NULL
;
9106 variable_was_changed (empty_var
, NULL
);
9107 /* Continue traversing the hash table. */
9110 /* Update cur_loc and one-part auxiliary data, before new_var goes
9111 through variable_was_changed. */
9112 if (old_var
!= new_var
&& new_var
->onepart
)
9114 gcc_checking_assert (VAR_LOC_1PAUX (new_var
) == NULL
);
9115 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (old_var
);
9116 VAR_LOC_1PAUX (old_var
) = NULL
;
9117 new_var
->var_part
[0].cur_loc
= old_var
->var_part
[0].cur_loc
;
9119 if (variable_different_p (old_var
, new_var
))
9120 variable_was_changed (new_var
, NULL
);
9122 /* Continue traversing the hash table. */
9126 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9130 emit_notes_for_differences_2 (variable
**slot
, variable_table_type
*old_vars
)
9132 variable
*old_var
, *new_var
;
9135 old_var
= old_vars
->find_with_hash (new_var
->dv
, dv_htab_hash (new_var
->dv
));
9139 for (i
= 0; i
< new_var
->n_var_parts
; i
++)
9140 new_var
->var_part
[i
].cur_loc
= NULL
;
9141 variable_was_changed (new_var
, NULL
);
9144 /* Continue traversing the hash table. */
9148 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9152 emit_notes_for_differences (rtx_insn
*insn
, dataflow_set
*old_set
,
9153 dataflow_set
*new_set
)
9155 shared_hash_htab (old_set
->vars
)
9156 ->traverse
<variable_table_type
*, emit_notes_for_differences_1
>
9157 (shared_hash_htab (new_set
->vars
));
9158 shared_hash_htab (new_set
->vars
)
9159 ->traverse
<variable_table_type
*, emit_notes_for_differences_2
>
9160 (shared_hash_htab (old_set
->vars
));
9161 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, new_set
->vars
);
9164 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9167 next_non_note_insn_var_location (rtx_insn
*insn
)
9171 insn
= NEXT_INSN (insn
);
9174 || NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
)
9181 /* Emit the notes for changes of location parts in the basic block BB. */
9184 emit_notes_in_bb (basic_block bb
, dataflow_set
*set
)
9187 micro_operation
*mo
;
9189 dataflow_set_clear (set
);
9190 dataflow_set_copy (set
, &VTI (bb
)->in
);
9192 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
9194 rtx_insn
*insn
= mo
->insn
;
9195 rtx_insn
*next_insn
= next_non_note_insn_var_location (insn
);
9200 dataflow_set_clear_at_call (set
, insn
);
9201 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_CALL_INSN
, set
->vars
);
9203 rtx arguments
= mo
->u
.loc
, *p
= &arguments
;
9207 XEXP (XEXP (*p
, 0), 1)
9208 = vt_expand_loc (XEXP (XEXP (*p
, 0), 1),
9209 shared_hash_htab (set
->vars
));
9210 /* If expansion is successful, keep it in the list. */
9211 if (XEXP (XEXP (*p
, 0), 1))
9213 /* Otherwise, if the following item is data_value for it,
9215 else if (XEXP (*p
, 1)
9216 && REG_P (XEXP (XEXP (*p
, 0), 0))
9217 && MEM_P (XEXP (XEXP (XEXP (*p
, 1), 0), 0))
9218 && REG_P (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0), 0),
9220 && REGNO (XEXP (XEXP (*p
, 0), 0))
9221 == REGNO (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0),
9223 *p
= XEXP (XEXP (*p
, 1), 1);
9224 /* Just drop this item. */
9228 note
= emit_note_after (NOTE_INSN_CALL_ARG_LOCATION
, insn
);
9229 NOTE_VAR_LOCATION (note
) = arguments
;
9235 rtx loc
= mo
->u
.loc
;
9238 var_reg_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9240 var_mem_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9242 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9248 rtx loc
= mo
->u
.loc
;
9252 if (GET_CODE (loc
) == CONCAT
)
9254 val
= XEXP (loc
, 0);
9255 vloc
= XEXP (loc
, 1);
9263 var
= PAT_VAR_LOCATION_DECL (vloc
);
9265 clobber_variable_part (set
, NULL_RTX
,
9266 dv_from_decl (var
), 0, NULL_RTX
);
9269 if (VAL_NEEDS_RESOLUTION (loc
))
9270 val_resolve (set
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
9271 set_variable_part (set
, val
, dv_from_decl (var
), 0,
9272 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9275 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
9276 set_variable_part (set
, PAT_VAR_LOCATION_LOC (vloc
),
9277 dv_from_decl (var
), 0,
9278 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9281 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9287 rtx loc
= mo
->u
.loc
;
9288 rtx val
, vloc
, uloc
;
9290 vloc
= uloc
= XEXP (loc
, 1);
9291 val
= XEXP (loc
, 0);
9293 if (GET_CODE (val
) == CONCAT
)
9295 uloc
= XEXP (val
, 1);
9296 val
= XEXP (val
, 0);
9299 if (VAL_NEEDS_RESOLUTION (loc
))
9300 val_resolve (set
, val
, vloc
, insn
);
9302 val_store (set
, val
, uloc
, insn
, false);
9304 if (VAL_HOLDS_TRACK_EXPR (loc
))
9306 if (GET_CODE (uloc
) == REG
)
9307 var_reg_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9309 else if (GET_CODE (uloc
) == MEM
)
9310 var_mem_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9314 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9320 rtx loc
= mo
->u
.loc
;
9321 rtx val
, vloc
, uloc
;
9325 uloc
= XEXP (vloc
, 1);
9326 val
= XEXP (vloc
, 0);
9329 if (GET_CODE (uloc
) == SET
)
9331 dstv
= SET_DEST (uloc
);
9332 srcv
= SET_SRC (uloc
);
9340 if (GET_CODE (val
) == CONCAT
)
9342 dstv
= vloc
= XEXP (val
, 1);
9343 val
= XEXP (val
, 0);
9346 if (GET_CODE (vloc
) == SET
)
9348 srcv
= SET_SRC (vloc
);
9350 gcc_assert (val
!= srcv
);
9351 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
9353 dstv
= vloc
= SET_DEST (vloc
);
9355 if (VAL_NEEDS_RESOLUTION (loc
))
9356 val_resolve (set
, val
, srcv
, insn
);
9358 else if (VAL_NEEDS_RESOLUTION (loc
))
9360 gcc_assert (GET_CODE (uloc
) == SET
9361 && GET_CODE (SET_SRC (uloc
)) == REG
);
9362 val_resolve (set
, val
, SET_SRC (uloc
), insn
);
9365 if (VAL_HOLDS_TRACK_EXPR (loc
))
9367 if (VAL_EXPR_IS_CLOBBERED (loc
))
9370 var_reg_delete (set
, uloc
, true);
9371 else if (MEM_P (uloc
))
9373 gcc_assert (MEM_P (dstv
));
9374 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
9375 var_mem_delete (set
, dstv
, true);
9380 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
9381 rtx src
= NULL
, dst
= uloc
;
9382 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
9384 if (GET_CODE (uloc
) == SET
)
9386 src
= SET_SRC (uloc
);
9387 dst
= SET_DEST (uloc
);
9392 status
= find_src_status (set
, src
);
9394 src
= find_src_set_src (set
, src
);
9398 var_reg_delete_and_set (set
, dst
, !copied_p
,
9400 else if (MEM_P (dst
))
9402 gcc_assert (MEM_P (dstv
));
9403 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
9404 var_mem_delete_and_set (set
, dstv
, !copied_p
,
9409 else if (REG_P (uloc
))
9410 var_regno_delete (set
, REGNO (uloc
));
9411 else if (MEM_P (uloc
))
9413 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
9414 gcc_checking_assert (vloc
== dstv
);
9416 clobber_overlapping_mems (set
, vloc
);
9419 val_store (set
, val
, dstv
, insn
, true);
9421 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9428 rtx loc
= mo
->u
.loc
;
9431 if (GET_CODE (loc
) == SET
)
9433 set_src
= SET_SRC (loc
);
9434 loc
= SET_DEST (loc
);
9438 var_reg_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9441 var_mem_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9444 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9451 rtx loc
= mo
->u
.loc
;
9452 enum var_init_status src_status
;
9455 if (GET_CODE (loc
) == SET
)
9457 set_src
= SET_SRC (loc
);
9458 loc
= SET_DEST (loc
);
9461 src_status
= find_src_status (set
, set_src
);
9462 set_src
= find_src_set_src (set
, set_src
);
9465 var_reg_delete_and_set (set
, loc
, false, src_status
, set_src
);
9467 var_mem_delete_and_set (set
, loc
, false, src_status
, set_src
);
9469 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9476 rtx loc
= mo
->u
.loc
;
9479 var_reg_delete (set
, loc
, false);
9481 var_mem_delete (set
, loc
, false);
9483 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9489 rtx loc
= mo
->u
.loc
;
9492 var_reg_delete (set
, loc
, true);
9494 var_mem_delete (set
, loc
, true);
9496 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9502 set
->stack_adjust
+= mo
->u
.adjust
;
9508 /* Return BB's head, unless BB is the block that succeeds ENTRY_BLOCK,
9509 in which case it searches back from BB's head for the very first
9510 insn. Use [get_first_insn (bb), BB_HEAD (bb->next_bb)[ as a range
9511 to iterate over all insns of a function while iterating over its
9515 get_first_insn (basic_block bb
)
9517 rtx_insn
*insn
= BB_HEAD (bb
);
9519 if (bb
->prev_bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
9520 while (rtx_insn
*prev
= PREV_INSN (insn
))
9526 /* Emit notes for the whole function. */
9529 vt_emit_notes (void)
9534 gcc_assert (!changed_variables
->elements ());
9536 /* Free memory occupied by the out hash tables, as they aren't used
9538 FOR_EACH_BB_FN (bb
, cfun
)
9539 dataflow_set_clear (&VTI (bb
)->out
);
9541 /* Enable emitting notes by functions (mainly by set_variable_part and
9542 delete_variable_part). */
9545 if (MAY_HAVE_DEBUG_BIND_INSNS
)
9546 dropped_values
= new variable_table_type (cselib_get_next_uid () * 2);
9548 dataflow_set_init (&cur
);
9550 FOR_EACH_BB_FN (bb
, cfun
)
9552 /* Emit the notes for changes of variable locations between two
9553 subsequent basic blocks. */
9554 emit_notes_for_differences (get_first_insn (bb
),
9555 &cur
, &VTI (bb
)->in
);
9557 if (MAY_HAVE_DEBUG_BIND_INSNS
)
9558 local_get_addr_cache
= new hash_map
<rtx
, rtx
>;
9560 /* Emit the notes for the changes in the basic block itself. */
9561 emit_notes_in_bb (bb
, &cur
);
9563 if (MAY_HAVE_DEBUG_BIND_INSNS
)
9564 delete local_get_addr_cache
;
9565 local_get_addr_cache
= NULL
;
9567 /* Free memory occupied by the in hash table, we won't need it
9569 dataflow_set_clear (&VTI (bb
)->in
);
9573 shared_hash_htab (cur
.vars
)
9574 ->traverse
<variable_table_type
*, emit_notes_for_differences_1
>
9575 (shared_hash_htab (empty_shared_hash
));
9577 dataflow_set_destroy (&cur
);
9579 if (MAY_HAVE_DEBUG_BIND_INSNS
)
9580 delete dropped_values
;
9581 dropped_values
= NULL
;
9586 /* If there is a declaration and offset associated with register/memory RTL
9587 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9590 vt_get_decl_and_offset (rtx rtl
, tree
*declp
, poly_int64
*offsetp
)
9594 if (REG_ATTRS (rtl
))
9596 *declp
= REG_EXPR (rtl
);
9597 *offsetp
= REG_OFFSET (rtl
);
9601 else if (GET_CODE (rtl
) == PARALLEL
)
9603 tree decl
= NULL_TREE
;
9604 HOST_WIDE_INT offset
= MAX_VAR_PARTS
;
9605 int len
= XVECLEN (rtl
, 0), i
;
9607 for (i
= 0; i
< len
; i
++)
9609 rtx reg
= XEXP (XVECEXP (rtl
, 0, i
), 0);
9610 if (!REG_P (reg
) || !REG_ATTRS (reg
))
9613 decl
= REG_EXPR (reg
);
9614 if (REG_EXPR (reg
) != decl
)
9616 HOST_WIDE_INT this_offset
;
9617 if (!track_offset_p (REG_OFFSET (reg
), &this_offset
))
9619 offset
= MIN (offset
, this_offset
);
9629 else if (MEM_P (rtl
))
9631 if (MEM_ATTRS (rtl
))
9633 *declp
= MEM_EXPR (rtl
);
9634 *offsetp
= int_mem_offset (rtl
);
9641 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9645 record_entry_value (cselib_val
*val
, rtx rtl
)
9647 rtx ev
= gen_rtx_ENTRY_VALUE (GET_MODE (rtl
));
9649 ENTRY_VALUE_EXP (ev
) = rtl
;
9651 cselib_add_permanent_equiv (val
, ev
, get_insns ());
9654 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9657 vt_add_function_parameter (tree parm
)
9659 rtx decl_rtl
= DECL_RTL_IF_SET (parm
);
9660 rtx incoming
= DECL_INCOMING_RTL (parm
);
9667 if (TREE_CODE (parm
) != PARM_DECL
)
9670 if (!decl_rtl
|| !incoming
)
9673 if (GET_MODE (decl_rtl
) == BLKmode
|| GET_MODE (incoming
) == BLKmode
)
9676 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9677 rewrite the incoming location of parameters passed on the stack
9678 into MEMs based on the argument pointer, so that incoming doesn't
9679 depend on a pseudo. */
9680 if (MEM_P (incoming
)
9681 && (XEXP (incoming
, 0) == crtl
->args
.internal_arg_pointer
9682 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
9683 && XEXP (XEXP (incoming
, 0), 0)
9684 == crtl
->args
.internal_arg_pointer
9685 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
9687 HOST_WIDE_INT off
= -FIRST_PARM_OFFSET (current_function_decl
);
9688 if (GET_CODE (XEXP (incoming
, 0)) == PLUS
)
9689 off
+= INTVAL (XEXP (XEXP (incoming
, 0), 1));
9691 = replace_equiv_address_nv (incoming
,
9692 plus_constant (Pmode
,
9693 arg_pointer_rtx
, off
));
9696 #ifdef HAVE_window_save
9697 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9698 If the target machine has an explicit window save instruction, the
9699 actual entry value is the corresponding OUTGOING_REGNO instead. */
9700 if (HAVE_window_save
&& !crtl
->uses_only_leaf_regs
)
9702 if (REG_P (incoming
)
9703 && HARD_REGISTER_P (incoming
)
9704 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
9707 p
.incoming
= incoming
;
9709 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
9710 OUTGOING_REGNO (REGNO (incoming
)), 0);
9711 p
.outgoing
= incoming
;
9712 vec_safe_push (windowed_parm_regs
, p
);
9714 else if (GET_CODE (incoming
) == PARALLEL
)
9717 = gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (XVECLEN (incoming
, 0)));
9720 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9722 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9725 reg
= gen_rtx_REG_offset (reg
, GET_MODE (reg
),
9726 OUTGOING_REGNO (REGNO (reg
)), 0);
9728 XVECEXP (outgoing
, 0, i
)
9729 = gen_rtx_EXPR_LIST (VOIDmode
, reg
,
9730 XEXP (XVECEXP (incoming
, 0, i
), 1));
9731 vec_safe_push (windowed_parm_regs
, p
);
9734 incoming
= outgoing
;
9736 else if (MEM_P (incoming
)
9737 && REG_P (XEXP (incoming
, 0))
9738 && HARD_REGISTER_P (XEXP (incoming
, 0)))
9740 rtx reg
= XEXP (incoming
, 0);
9741 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
9745 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
9747 vec_safe_push (windowed_parm_regs
, p
);
9748 incoming
= replace_equiv_address_nv (incoming
, reg
);
9754 if (!vt_get_decl_and_offset (incoming
, &decl
, &offset
))
9756 if (MEM_P (incoming
))
9758 /* This means argument is passed by invisible reference. */
9764 if (!vt_get_decl_and_offset (decl_rtl
, &decl
, &offset
))
9766 offset
+= byte_lowpart_offset (GET_MODE (incoming
),
9767 GET_MODE (decl_rtl
));
9776 /* If that DECL_RTL wasn't a pseudo that got spilled to
9777 memory, bail out. Otherwise, the spill slot sharing code
9778 will force the memory to reference spill_slot_decl (%sfp),
9779 so we don't match above. That's ok, the pseudo must have
9780 referenced the entire parameter, so just reset OFFSET. */
9781 if (decl
!= get_spill_slot_decl (false))
9786 HOST_WIDE_INT const_offset
;
9787 if (!track_loc_p (incoming
, parm
, offset
, false, &mode
, &const_offset
))
9790 out
= &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
;
9792 dv
= dv_from_decl (parm
);
9794 if (target_for_debug_bind (parm
)
9795 /* We can't deal with these right now, because this kind of
9796 variable is single-part. ??? We could handle parallels
9797 that describe multiple locations for the same single
9798 value, but ATM we don't. */
9799 && GET_CODE (incoming
) != PARALLEL
)
9804 /* ??? We shouldn't ever hit this, but it may happen because
9805 arguments passed by invisible reference aren't dealt with
9806 above: incoming-rtl will have Pmode rather than the
9807 expected mode for the type. */
9811 lowpart
= var_lowpart (mode
, incoming
);
9815 val
= cselib_lookup_from_insn (lowpart
, mode
, true,
9816 VOIDmode
, get_insns ());
9818 /* ??? Float-typed values in memory are not handled by
9822 preserve_value (val
);
9823 set_variable_part (out
, val
->val_rtx
, dv
, const_offset
,
9824 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9825 dv
= dv_from_value (val
->val_rtx
);
9828 if (MEM_P (incoming
))
9830 val
= cselib_lookup_from_insn (XEXP (incoming
, 0), mode
, true,
9831 VOIDmode
, get_insns ());
9834 preserve_value (val
);
9835 incoming
= replace_equiv_address_nv (incoming
, val
->val_rtx
);
9840 if (REG_P (incoming
))
9842 incoming
= var_lowpart (mode
, incoming
);
9843 gcc_assert (REGNO (incoming
) < FIRST_PSEUDO_REGISTER
);
9844 attrs_list_insert (&out
->regs
[REGNO (incoming
)], dv
, const_offset
,
9846 set_variable_part (out
, incoming
, dv
, const_offset
,
9847 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9848 if (dv_is_value_p (dv
))
9850 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv
)), incoming
);
9851 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
9852 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm
))))
9854 machine_mode indmode
9855 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm
)));
9856 rtx mem
= gen_rtx_MEM (indmode
, incoming
);
9857 cselib_val
*val
= cselib_lookup_from_insn (mem
, indmode
, true,
9862 preserve_value (val
);
9863 record_entry_value (val
, mem
);
9864 set_variable_part (out
, mem
, dv_from_value (val
->val_rtx
), 0,
9865 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9870 else if (GET_CODE (incoming
) == PARALLEL
&& !dv_onepart_p (dv
))
9874 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9876 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9877 /* vt_get_decl_and_offset has already checked that the offset
9878 is a valid variable part. */
9879 const_offset
= get_tracked_reg_offset (reg
);
9880 gcc_assert (REGNO (reg
) < FIRST_PSEUDO_REGISTER
);
9881 attrs_list_insert (&out
->regs
[REGNO (reg
)], dv
, const_offset
, reg
);
9882 set_variable_part (out
, reg
, dv
, const_offset
,
9883 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9886 else if (MEM_P (incoming
))
9888 incoming
= var_lowpart (mode
, incoming
);
9889 set_variable_part (out
, incoming
, dv
, const_offset
,
9890 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9894 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9897 vt_add_function_parameters (void)
9901 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9902 parm
; parm
= DECL_CHAIN (parm
))
9903 if (!POINTER_BOUNDS_P (parm
))
9904 vt_add_function_parameter (parm
);
9906 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl
)))
9908 tree vexpr
= DECL_VALUE_EXPR (DECL_RESULT (current_function_decl
));
9910 if (TREE_CODE (vexpr
) == INDIRECT_REF
)
9911 vexpr
= TREE_OPERAND (vexpr
, 0);
9913 if (TREE_CODE (vexpr
) == PARM_DECL
9914 && DECL_ARTIFICIAL (vexpr
)
9915 && !DECL_IGNORED_P (vexpr
)
9916 && DECL_NAMELESS (vexpr
))
9917 vt_add_function_parameter (vexpr
);
9921 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9922 ensure it isn't flushed during cselib_reset_table.
9923 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9924 has been eliminated. */
9927 vt_init_cfa_base (void)
9931 #ifdef FRAME_POINTER_CFA_OFFSET
9932 cfa_base_rtx
= frame_pointer_rtx
;
9933 cfa_base_offset
= -FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9935 cfa_base_rtx
= arg_pointer_rtx
;
9936 cfa_base_offset
= -ARG_POINTER_CFA_OFFSET (current_function_decl
);
9938 if (cfa_base_rtx
== hard_frame_pointer_rtx
9939 || !fixed_regs
[REGNO (cfa_base_rtx
)])
9941 cfa_base_rtx
= NULL_RTX
;
9944 if (!MAY_HAVE_DEBUG_BIND_INSNS
)
9947 /* Tell alias analysis that cfa_base_rtx should share
9948 find_base_term value with stack pointer or hard frame pointer. */
9949 if (!frame_pointer_needed
)
9950 vt_equate_reg_base_value (cfa_base_rtx
, stack_pointer_rtx
);
9951 else if (!crtl
->stack_realign_tried
)
9952 vt_equate_reg_base_value (cfa_base_rtx
, hard_frame_pointer_rtx
);
9954 val
= cselib_lookup_from_insn (cfa_base_rtx
, GET_MODE (cfa_base_rtx
), 1,
9955 VOIDmode
, get_insns ());
9956 preserve_value (val
);
9957 cselib_preserve_cfa_base_value (val
, REGNO (cfa_base_rtx
));
9960 /* Reemit INSN, a MARKER_DEBUG_INSN, as a note. */
9963 reemit_marker_as_note (rtx_insn
*insn
, basic_block
*bb
)
9965 gcc_checking_assert (DEBUG_MARKER_INSN_P (insn
));
9967 enum insn_note kind
= INSN_DEBUG_MARKER_KIND (insn
);
9971 case NOTE_INSN_BEGIN_STMT
:
9973 rtx_insn
*note
= NULL
;
9974 if (cfun
->debug_nonbind_markers
)
9976 note
= emit_note_before (kind
, insn
);
9977 NOTE_MARKER_LOCATION (note
) = INSN_LOCATION (insn
);
9979 BLOCK_FOR_INSN (note
) = *bb
;
9990 /* Allocate and initialize the data structures for variable tracking
9991 and parse the RTL to get the micro operations. */
9994 vt_initialize (void)
9997 HOST_WIDE_INT fp_cfa_offset
= -1;
9999 alloc_aux_for_blocks (sizeof (variable_tracking_info
));
10001 empty_shared_hash
= shared_hash_pool
.allocate ();
10002 empty_shared_hash
->refcount
= 1;
10003 empty_shared_hash
->htab
= new variable_table_type (1);
10004 changed_variables
= new variable_table_type (10);
10006 /* Init the IN and OUT sets. */
10007 FOR_ALL_BB_FN (bb
, cfun
)
10009 VTI (bb
)->visited
= false;
10010 VTI (bb
)->flooded
= false;
10011 dataflow_set_init (&VTI (bb
)->in
);
10012 dataflow_set_init (&VTI (bb
)->out
);
10013 VTI (bb
)->permp
= NULL
;
10016 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10018 cselib_init (CSELIB_RECORD_MEMORY
| CSELIB_PRESERVE_CONSTANTS
);
10019 scratch_regs
= BITMAP_ALLOC (NULL
);
10020 preserved_values
.create (256);
10021 global_get_addr_cache
= new hash_map
<rtx
, rtx
>;
10025 scratch_regs
= NULL
;
10026 global_get_addr_cache
= NULL
;
10029 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10035 #ifdef FRAME_POINTER_CFA_OFFSET
10036 reg
= frame_pointer_rtx
;
10037 ofst
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
10039 reg
= arg_pointer_rtx
;
10040 ofst
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
10043 ofst
-= INCOMING_FRAME_SP_OFFSET
;
10045 val
= cselib_lookup_from_insn (reg
, GET_MODE (reg
), 1,
10046 VOIDmode
, get_insns ());
10047 preserve_value (val
);
10048 if (reg
!= hard_frame_pointer_rtx
&& fixed_regs
[REGNO (reg
)])
10049 cselib_preserve_cfa_base_value (val
, REGNO (reg
));
10050 expr
= plus_constant (GET_MODE (stack_pointer_rtx
),
10051 stack_pointer_rtx
, -ofst
);
10052 cselib_add_permanent_equiv (val
, expr
, get_insns ());
10056 val
= cselib_lookup_from_insn (stack_pointer_rtx
,
10057 GET_MODE (stack_pointer_rtx
), 1,
10058 VOIDmode
, get_insns ());
10059 preserve_value (val
);
10060 expr
= plus_constant (GET_MODE (reg
), reg
, ofst
);
10061 cselib_add_permanent_equiv (val
, expr
, get_insns ());
10065 /* In order to factor out the adjustments made to the stack pointer or to
10066 the hard frame pointer and thus be able to use DW_OP_fbreg operations
10067 instead of individual location lists, we're going to rewrite MEMs based
10068 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
10069 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
10070 resp. arg_pointer_rtx. We can do this either when there is no frame
10071 pointer in the function and stack adjustments are consistent for all
10072 basic blocks or when there is a frame pointer and no stack realignment.
10073 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
10074 has been eliminated. */
10075 if (!frame_pointer_needed
)
10079 if (!vt_stack_adjustments ())
10082 #ifdef FRAME_POINTER_CFA_OFFSET
10083 reg
= frame_pointer_rtx
;
10085 reg
= arg_pointer_rtx
;
10087 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10090 if (GET_CODE (elim
) == PLUS
)
10091 elim
= XEXP (elim
, 0);
10092 if (elim
== stack_pointer_rtx
)
10093 vt_init_cfa_base ();
10096 else if (!crtl
->stack_realign_tried
)
10100 #ifdef FRAME_POINTER_CFA_OFFSET
10101 reg
= frame_pointer_rtx
;
10102 fp_cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
10104 reg
= arg_pointer_rtx
;
10105 fp_cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
10107 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10110 if (GET_CODE (elim
) == PLUS
)
10112 fp_cfa_offset
-= INTVAL (XEXP (elim
, 1));
10113 elim
= XEXP (elim
, 0);
10115 if (elim
!= hard_frame_pointer_rtx
)
10116 fp_cfa_offset
= -1;
10119 fp_cfa_offset
= -1;
10122 /* If the stack is realigned and a DRAP register is used, we're going to
10123 rewrite MEMs based on it representing incoming locations of parameters
10124 passed on the stack into MEMs based on the argument pointer. Although
10125 we aren't going to rewrite other MEMs, we still need to initialize the
10126 virtual CFA pointer in order to ensure that the argument pointer will
10127 be seen as a constant throughout the function.
10129 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10130 else if (stack_realign_drap
)
10134 #ifdef FRAME_POINTER_CFA_OFFSET
10135 reg
= frame_pointer_rtx
;
10137 reg
= arg_pointer_rtx
;
10139 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10142 if (GET_CODE (elim
) == PLUS
)
10143 elim
= XEXP (elim
, 0);
10144 if (elim
== hard_frame_pointer_rtx
)
10145 vt_init_cfa_base ();
10149 hard_frame_pointer_adjustment
= -1;
10151 vt_add_function_parameters ();
10153 FOR_EACH_BB_FN (bb
, cfun
)
10156 HOST_WIDE_INT pre
, post
= 0;
10157 basic_block first_bb
, last_bb
;
10159 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10161 cselib_record_sets_hook
= add_with_sets
;
10162 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10163 fprintf (dump_file
, "first value: %i\n",
10164 cselib_get_next_uid ());
10171 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
10172 || ! single_pred_p (bb
->next_bb
))
10174 e
= find_edge (bb
, bb
->next_bb
);
10175 if (! e
|| (e
->flags
& EDGE_FALLTHRU
) == 0)
10181 /* Add the micro-operations to the vector. */
10182 FOR_BB_BETWEEN (bb
, first_bb
, last_bb
->next_bb
, next_bb
)
10184 HOST_WIDE_INT offset
= VTI (bb
)->out
.stack_adjust
;
10185 VTI (bb
)->out
.stack_adjust
= VTI (bb
)->in
.stack_adjust
;
10187 /* If we are walking the first basic block, walk any HEADER
10188 insns that might be before it too. Unfortunately,
10189 BB_HEADER and BB_FOOTER are not set while we run this
10192 bool outside_bb
= true;
10193 for (insn
= get_first_insn (bb
); insn
!= BB_HEAD (bb
->next_bb
);
10196 if (insn
== BB_HEAD (bb
))
10197 outside_bb
= false;
10198 else if (insn
== NEXT_INSN (BB_END (bb
)))
10200 next
= NEXT_INSN (insn
);
10205 /* Ignore non-debug insns outside of basic blocks. */
10206 if (!DEBUG_INSN_P (insn
))
10208 /* Debug binds shouldn't appear outside of bbs. */
10209 gcc_assert (!DEBUG_BIND_INSN_P (insn
));
10211 basic_block save_bb
= BLOCK_FOR_INSN (insn
);
10212 if (!BLOCK_FOR_INSN (insn
))
10214 gcc_assert (outside_bb
);
10215 BLOCK_FOR_INSN (insn
) = bb
;
10218 gcc_assert (BLOCK_FOR_INSN (insn
) == bb
);
10220 if (!frame_pointer_needed
)
10222 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
10225 micro_operation mo
;
10226 mo
.type
= MO_ADJUST
;
10229 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10230 log_op_type (PATTERN (insn
), bb
, insn
,
10231 MO_ADJUST
, dump_file
);
10232 VTI (bb
)->mos
.safe_push (mo
);
10233 VTI (bb
)->out
.stack_adjust
+= pre
;
10237 cselib_hook_called
= false;
10238 adjust_insn (bb
, insn
);
10239 if (DEBUG_MARKER_INSN_P (insn
))
10241 insn
= reemit_marker_as_note (insn
, &save_bb
);
10245 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10248 prepare_call_arguments (bb
, insn
);
10249 cselib_process_insn (insn
);
10250 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10252 print_rtl_single (dump_file
, insn
);
10253 dump_cselib_table (dump_file
);
10256 if (!cselib_hook_called
)
10257 add_with_sets (insn
, 0, 0);
10258 cancel_changes (0);
10260 if (!frame_pointer_needed
&& post
)
10262 micro_operation mo
;
10263 mo
.type
= MO_ADJUST
;
10264 mo
.u
.adjust
= post
;
10266 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10267 log_op_type (PATTERN (insn
), bb
, insn
,
10268 MO_ADJUST
, dump_file
);
10269 VTI (bb
)->mos
.safe_push (mo
);
10270 VTI (bb
)->out
.stack_adjust
+= post
;
10273 if (fp_cfa_offset
!= -1
10274 && hard_frame_pointer_adjustment
== -1
10275 && fp_setter_insn (insn
))
10277 vt_init_cfa_base ();
10278 hard_frame_pointer_adjustment
= fp_cfa_offset
;
10279 /* Disassociate sp from fp now. */
10280 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10283 cselib_invalidate_rtx (stack_pointer_rtx
);
10284 v
= cselib_lookup (stack_pointer_rtx
, Pmode
, 1,
10286 if (v
&& !cselib_preserved_value_p (v
))
10288 cselib_set_value_sp_based (v
);
10289 preserve_value (v
);
10293 BLOCK_FOR_INSN (insn
) = save_bb
;
10296 gcc_assert (offset
== VTI (bb
)->out
.stack_adjust
);
10301 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10303 cselib_preserve_only_values ();
10304 cselib_reset_table (cselib_get_next_uid ());
10305 cselib_record_sets_hook
= NULL
;
10309 hard_frame_pointer_adjustment
= -1;
10310 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flooded
= true;
10311 cfa_base_rtx
= NULL_RTX
;
10315 /* This is *not* reset after each function. It gives each
10316 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10317 a unique label number. */
10319 static int debug_label_num
= 1;
10321 /* Remove from the insn stream all debug insns used for variable
10322 tracking at assignments. */
10325 delete_vta_debug_insns (void)
10328 rtx_insn
*insn
, *next
;
10330 if (!MAY_HAVE_DEBUG_INSNS
)
10333 FOR_EACH_BB_FN (bb
, cfun
)
10335 for (insn
= get_first_insn (bb
);
10336 insn
!= BB_HEAD (bb
->next_bb
)
10337 ? next
= NEXT_INSN (insn
), true : false;
10339 if (DEBUG_INSN_P (insn
))
10341 if (DEBUG_MARKER_INSN_P (insn
))
10343 insn
= reemit_marker_as_note (insn
, NULL
);
10347 tree decl
= INSN_VAR_LOCATION_DECL (insn
);
10348 if (TREE_CODE (decl
) == LABEL_DECL
10349 && DECL_NAME (decl
)
10350 && !DECL_RTL_SET_P (decl
))
10352 PUT_CODE (insn
, NOTE
);
10353 NOTE_KIND (insn
) = NOTE_INSN_DELETED_DEBUG_LABEL
;
10354 NOTE_DELETED_LABEL_NAME (insn
)
10355 = IDENTIFIER_POINTER (DECL_NAME (decl
));
10356 SET_DECL_RTL (decl
, insn
);
10357 CODE_LABEL_NUMBER (insn
) = debug_label_num
++;
10360 delete_insn (insn
);
10365 /* Run a fast, BB-local only version of var tracking, to take care of
10366 information that we don't do global analysis on, such that not all
10367 information is lost. If SKIPPED holds, we're skipping the global
10368 pass entirely, so we should try to use information it would have
10369 handled as well.. */
10372 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED
)
10374 /* ??? Just skip it all for now. */
10375 delete_vta_debug_insns ();
10378 /* Free the data structures needed for variable tracking. */
10385 FOR_EACH_BB_FN (bb
, cfun
)
10387 VTI (bb
)->mos
.release ();
10390 FOR_ALL_BB_FN (bb
, cfun
)
10392 dataflow_set_destroy (&VTI (bb
)->in
);
10393 dataflow_set_destroy (&VTI (bb
)->out
);
10394 if (VTI (bb
)->permp
)
10396 dataflow_set_destroy (VTI (bb
)->permp
);
10397 XDELETE (VTI (bb
)->permp
);
10400 free_aux_for_blocks ();
10401 delete empty_shared_hash
->htab
;
10402 empty_shared_hash
->htab
= NULL
;
10403 delete changed_variables
;
10404 changed_variables
= NULL
;
10405 attrs_pool
.release ();
10406 var_pool
.release ();
10407 location_chain_pool
.release ();
10408 shared_hash_pool
.release ();
10410 if (MAY_HAVE_DEBUG_BIND_INSNS
)
10412 if (global_get_addr_cache
)
10413 delete global_get_addr_cache
;
10414 global_get_addr_cache
= NULL
;
10415 loc_exp_dep_pool
.release ();
10416 valvar_pool
.release ();
10417 preserved_values
.release ();
10419 BITMAP_FREE (scratch_regs
);
10420 scratch_regs
= NULL
;
10423 #ifdef HAVE_window_save
10424 vec_free (windowed_parm_regs
);
10428 XDELETEVEC (vui_vec
);
10433 /* The entry point to variable tracking pass. */
10435 static inline unsigned int
10436 variable_tracking_main_1 (void)
10440 /* We won't be called as a separate pass if flag_var_tracking is not
10441 set, but final may call us to turn debug markers into notes. */
10442 if ((!flag_var_tracking
&& MAY_HAVE_DEBUG_INSNS
)
10443 || flag_var_tracking_assignments
< 0
10444 /* Var-tracking right now assumes the IR doesn't contain
10445 any pseudos at this point. */
10446 || targetm
.no_register_allocation
)
10448 delete_vta_debug_insns ();
10452 if (!flag_var_tracking
)
10455 if (n_basic_blocks_for_fn (cfun
) > 500
10456 && n_edges_for_fn (cfun
) / n_basic_blocks_for_fn (cfun
) >= 20)
10458 vt_debug_insns_local (true);
10462 mark_dfs_back_edges ();
10463 if (!vt_initialize ())
10466 vt_debug_insns_local (true);
10470 success
= vt_find_locations ();
10472 if (!success
&& flag_var_tracking_assignments
> 0)
10476 delete_vta_debug_insns ();
10478 /* This is later restored by our caller. */
10479 flag_var_tracking_assignments
= 0;
10481 success
= vt_initialize ();
10482 gcc_assert (success
);
10484 success
= vt_find_locations ();
10490 vt_debug_insns_local (false);
10494 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10496 dump_dataflow_sets ();
10497 dump_reg_info (dump_file
);
10498 dump_flow_info (dump_file
, dump_flags
);
10501 timevar_push (TV_VAR_TRACKING_EMIT
);
10503 timevar_pop (TV_VAR_TRACKING_EMIT
);
10506 vt_debug_insns_local (false);
10511 variable_tracking_main (void)
10514 int save
= flag_var_tracking_assignments
;
10516 ret
= variable_tracking_main_1 ();
10518 flag_var_tracking_assignments
= save
;
10525 const pass_data pass_data_variable_tracking
=
10527 RTL_PASS
, /* type */
10528 "vartrack", /* name */
10529 OPTGROUP_NONE
, /* optinfo_flags */
10530 TV_VAR_TRACKING
, /* tv_id */
10531 0, /* properties_required */
10532 0, /* properties_provided */
10533 0, /* properties_destroyed */
10534 0, /* todo_flags_start */
10535 0, /* todo_flags_finish */
10538 class pass_variable_tracking
: public rtl_opt_pass
10541 pass_variable_tracking (gcc::context
*ctxt
)
10542 : rtl_opt_pass (pass_data_variable_tracking
, ctxt
)
10545 /* opt_pass methods: */
10546 virtual bool gate (function
*)
10548 return (flag_var_tracking
&& !targetm
.delay_vartrack
);
10551 virtual unsigned int execute (function
*)
10553 return variable_tracking_main ();
10556 }; // class pass_variable_tracking
10558 } // anon namespace
10561 make_pass_variable_tracking (gcc::context
*ctxt
)
10563 return new pass_variable_tracking (ctxt
);