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 /* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
394 #define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
396 #if CHECKING_P && (GCC_VERSION >= 2007)
398 /* Access VAR's Ith part's offset, checking that it's not a one-part
400 #define VAR_PART_OFFSET(var, i) __extension__ \
401 (*({ variable *const __v = (var); \
402 gcc_checking_assert (!__v->onepart); \
403 &__v->var_part[(i)].aux.offset; }))
405 /* Access VAR's one-part auxiliary data, checking that it is a
406 one-part variable. */
407 #define VAR_LOC_1PAUX(var) __extension__ \
408 (*({ variable *const __v = (var); \
409 gcc_checking_assert (__v->onepart); \
410 &__v->var_part[0].aux.onepaux; }))
413 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
414 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
417 /* These are accessor macros for the one-part auxiliary data. When
418 convenient for users, they're guarded by tests that the data was
420 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
421 ? VAR_LOC_1PAUX (var)->backlinks \
423 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
424 ? &VAR_LOC_1PAUX (var)->backlinks \
426 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
427 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
428 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
429 ? &VAR_LOC_1PAUX (var)->deps \
434 typedef unsigned int dvuid
;
436 /* Return the uid of DV. */
439 dv_uid (decl_or_value dv
)
441 if (dv_is_value_p (dv
))
442 return CSELIB_VAL_PTR (dv_as_value (dv
))->uid
;
444 return DECL_UID (dv_as_decl (dv
));
447 /* Compute the hash from the uid. */
449 static inline hashval_t
450 dv_uid2hash (dvuid uid
)
455 /* The hash function for a mask table in a shared_htab chain. */
457 static inline hashval_t
458 dv_htab_hash (decl_or_value dv
)
460 return dv_uid2hash (dv_uid (dv
));
463 static void variable_htab_free (void *);
465 /* Variable hashtable helpers. */
467 struct variable_hasher
: pointer_hash
<variable
>
469 typedef void *compare_type
;
470 static inline hashval_t
hash (const variable
*);
471 static inline bool equal (const variable
*, const void *);
472 static inline void remove (variable
*);
475 /* The hash function for variable_htab, computes the hash value
476 from the declaration of variable X. */
479 variable_hasher::hash (const variable
*v
)
481 return dv_htab_hash (v
->dv
);
484 /* Compare the declaration of variable X with declaration Y. */
487 variable_hasher::equal (const variable
*v
, const void *y
)
489 decl_or_value dv
= CONST_CAST2 (decl_or_value
, const void *, y
);
491 return (dv_as_opaque (v
->dv
) == dv_as_opaque (dv
));
494 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
497 variable_hasher::remove (variable
*var
)
499 variable_htab_free (var
);
502 typedef hash_table
<variable_hasher
> variable_table_type
;
503 typedef variable_table_type::iterator variable_iterator_type
;
505 /* Structure for passing some other parameters to function
506 emit_note_insn_var_location. */
507 struct emit_note_data
509 /* The instruction which the note will be emitted before/after. */
512 /* Where the note will be emitted (before/after insn)? */
513 enum emit_note_where where
;
515 /* The variables and values active at this point. */
516 variable_table_type
*vars
;
519 /* Structure holding a refcounted hash table. If refcount > 1,
520 it must be first unshared before modified. */
523 /* Reference count. */
526 /* Actual hash table. */
527 variable_table_type
*htab
;
530 /* Structure holding the IN or OUT set for a basic block. */
533 /* Adjustment of stack offset. */
534 HOST_WIDE_INT stack_adjust
;
536 /* Attributes for registers (lists of attrs). */
537 attrs
*regs
[FIRST_PSEUDO_REGISTER
];
539 /* Variable locations. */
542 /* Vars that is being traversed. */
543 shared_hash
*traversed_vars
;
546 /* The structure (one for each basic block) containing the information
547 needed for variable tracking. */
548 struct variable_tracking_info
550 /* The vector of micro operations. */
551 vec
<micro_operation
> mos
;
553 /* The IN and OUT set for dataflow analysis. */
557 /* The permanent-in dataflow set for this block. This is used to
558 hold values for which we had to compute entry values. ??? This
559 should probably be dynamically allocated, to avoid using more
560 memory in non-debug builds. */
563 /* Has the block been visited in DFS? */
566 /* Has the block been flooded in VTA? */
571 /* Alloc pool for struct attrs_def. */
572 object_allocator
<attrs
> attrs_pool ("attrs pool");
574 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
576 static pool_allocator var_pool
577 ("variable_def pool", sizeof (variable
) +
578 (MAX_VAR_PARTS
- 1) * sizeof (((variable
*)NULL
)->var_part
[0]));
580 /* Alloc pool for struct variable_def with a single var_part entry. */
581 static pool_allocator valvar_pool
582 ("small variable_def pool", sizeof (variable
));
584 /* Alloc pool for struct location_chain. */
585 static object_allocator
<location_chain
> location_chain_pool
586 ("location_chain pool");
588 /* Alloc pool for struct shared_hash. */
589 static object_allocator
<shared_hash
> shared_hash_pool ("shared_hash pool");
591 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
592 object_allocator
<loc_exp_dep
> loc_exp_dep_pool ("loc_exp_dep pool");
594 /* Changed variables, notes will be emitted for them. */
595 static variable_table_type
*changed_variables
;
597 /* Shall notes be emitted? */
598 static bool emit_notes
;
600 /* Values whose dynamic location lists have gone empty, but whose
601 cselib location lists are still usable. Use this to hold the
602 current location, the backlinks, etc, during emit_notes. */
603 static variable_table_type
*dropped_values
;
605 /* Empty shared hashtable. */
606 static shared_hash
*empty_shared_hash
;
608 /* Scratch register bitmap used by cselib_expand_value_rtx. */
609 static bitmap scratch_regs
= NULL
;
611 #ifdef HAVE_window_save
612 struct GTY(()) parm_reg
{
618 /* Vector of windowed parameter registers, if any. */
619 static vec
<parm_reg
, va_gc
> *windowed_parm_regs
= NULL
;
622 /* Variable used to tell whether cselib_process_insn called our hook. */
623 static bool cselib_hook_called
;
625 /* Local function prototypes. */
626 static void stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
628 static void insn_stack_adjust_offset_pre_post (rtx_insn
*, HOST_WIDE_INT
*,
630 static bool vt_stack_adjustments (void);
632 static void init_attrs_list_set (attrs
**);
633 static void attrs_list_clear (attrs
**);
634 static attrs
*attrs_list_member (attrs
*, decl_or_value
, HOST_WIDE_INT
);
635 static void attrs_list_insert (attrs
**, decl_or_value
, HOST_WIDE_INT
, rtx
);
636 static void attrs_list_copy (attrs
**, attrs
*);
637 static void attrs_list_union (attrs
**, attrs
*);
639 static variable
**unshare_variable (dataflow_set
*set
, variable
**slot
,
640 variable
*var
, enum var_init_status
);
641 static void vars_copy (variable_table_type
*, variable_table_type
*);
642 static tree
var_debug_decl (tree
);
643 static void var_reg_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
644 static void var_reg_delete_and_set (dataflow_set
*, rtx
, bool,
645 enum var_init_status
, rtx
);
646 static void var_reg_delete (dataflow_set
*, rtx
, bool);
647 static void var_regno_delete (dataflow_set
*, int);
648 static void var_mem_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
649 static void var_mem_delete_and_set (dataflow_set
*, rtx
, bool,
650 enum var_init_status
, rtx
);
651 static void var_mem_delete (dataflow_set
*, rtx
, bool);
653 static void dataflow_set_init (dataflow_set
*);
654 static void dataflow_set_clear (dataflow_set
*);
655 static void dataflow_set_copy (dataflow_set
*, dataflow_set
*);
656 static int variable_union_info_cmp_pos (const void *, const void *);
657 static void dataflow_set_union (dataflow_set
*, dataflow_set
*);
658 static location_chain
*find_loc_in_1pdv (rtx
, variable
*,
659 variable_table_type
*);
660 static bool canon_value_cmp (rtx
, rtx
);
661 static int loc_cmp (rtx
, rtx
);
662 static bool variable_part_different_p (variable_part
*, variable_part
*);
663 static bool onepart_variable_different_p (variable
*, variable
*);
664 static bool variable_different_p (variable
*, variable
*);
665 static bool dataflow_set_different (dataflow_set
*, dataflow_set
*);
666 static void dataflow_set_destroy (dataflow_set
*);
668 static bool track_expr_p (tree
, bool);
669 static bool same_variable_part_p (rtx
, tree
, HOST_WIDE_INT
);
670 static void add_uses_1 (rtx
*, void *);
671 static void add_stores (rtx
, const_rtx
, void *);
672 static bool compute_bb_dataflow (basic_block
);
673 static bool vt_find_locations (void);
675 static void dump_attrs_list (attrs
*);
676 static void dump_var (variable
*);
677 static void dump_vars (variable_table_type
*);
678 static void dump_dataflow_set (dataflow_set
*);
679 static void dump_dataflow_sets (void);
681 static void set_dv_changed (decl_or_value
, bool);
682 static void variable_was_changed (variable
*, dataflow_set
*);
683 static variable
**set_slot_part (dataflow_set
*, rtx
, variable
**,
684 decl_or_value
, HOST_WIDE_INT
,
685 enum var_init_status
, rtx
);
686 static void set_variable_part (dataflow_set
*, rtx
,
687 decl_or_value
, HOST_WIDE_INT
,
688 enum var_init_status
, rtx
, enum insert_option
);
689 static variable
**clobber_slot_part (dataflow_set
*, rtx
,
690 variable
**, HOST_WIDE_INT
, rtx
);
691 static void clobber_variable_part (dataflow_set
*, rtx
,
692 decl_or_value
, HOST_WIDE_INT
, rtx
);
693 static variable
**delete_slot_part (dataflow_set
*, rtx
, variable
**,
695 static void delete_variable_part (dataflow_set
*, rtx
,
696 decl_or_value
, HOST_WIDE_INT
);
697 static void emit_notes_in_bb (basic_block
, dataflow_set
*);
698 static void vt_emit_notes (void);
700 static bool vt_get_decl_and_offset (rtx
, tree
*, HOST_WIDE_INT
*);
701 static void vt_add_function_parameters (void);
702 static bool vt_initialize (void);
703 static void vt_finalize (void);
705 /* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
708 stack_adjust_offset_pre_post_cb (rtx
, rtx op
, rtx dest
, rtx src
, rtx srcoff
,
711 if (dest
!= stack_pointer_rtx
)
714 switch (GET_CODE (op
))
718 ((HOST_WIDE_INT
*)arg
)[0] -= INTVAL (srcoff
);
722 ((HOST_WIDE_INT
*)arg
)[1] -= INTVAL (srcoff
);
726 /* We handle only adjustments by constant amount. */
727 gcc_assert (GET_CODE (src
) == PLUS
728 && CONST_INT_P (XEXP (src
, 1))
729 && XEXP (src
, 0) == stack_pointer_rtx
);
730 ((HOST_WIDE_INT
*)arg
)[GET_CODE (op
) == POST_MODIFY
]
731 -= INTVAL (XEXP (src
, 1));
738 /* Given a SET, calculate the amount of stack adjustment it contains
739 PRE- and POST-modifying stack pointer.
740 This function is similar to stack_adjust_offset. */
743 stack_adjust_offset_pre_post (rtx pattern
, HOST_WIDE_INT
*pre
,
746 rtx src
= SET_SRC (pattern
);
747 rtx dest
= SET_DEST (pattern
);
750 if (dest
== stack_pointer_rtx
)
752 /* (set (reg sp) (plus (reg sp) (const_int))) */
753 code
= GET_CODE (src
);
754 if (! (code
== PLUS
|| code
== MINUS
)
755 || XEXP (src
, 0) != stack_pointer_rtx
756 || !CONST_INT_P (XEXP (src
, 1)))
760 *post
+= INTVAL (XEXP (src
, 1));
762 *post
-= INTVAL (XEXP (src
, 1));
765 HOST_WIDE_INT res
[2] = { 0, 0 };
766 for_each_inc_dec (pattern
, stack_adjust_offset_pre_post_cb
, res
);
771 /* Given an INSN, calculate the amount of stack adjustment it contains
772 PRE- and POST-modifying stack pointer. */
775 insn_stack_adjust_offset_pre_post (rtx_insn
*insn
, HOST_WIDE_INT
*pre
,
783 pattern
= PATTERN (insn
);
784 if (RTX_FRAME_RELATED_P (insn
))
786 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
788 pattern
= XEXP (expr
, 0);
791 if (GET_CODE (pattern
) == SET
)
792 stack_adjust_offset_pre_post (pattern
, pre
, post
);
793 else if (GET_CODE (pattern
) == PARALLEL
794 || GET_CODE (pattern
) == SEQUENCE
)
798 /* There may be stack adjustments inside compound insns. Search
800 for ( i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
801 if (GET_CODE (XVECEXP (pattern
, 0, i
)) == SET
)
802 stack_adjust_offset_pre_post (XVECEXP (pattern
, 0, i
), pre
, post
);
806 /* Compute stack adjustments for all blocks by traversing DFS tree.
807 Return true when the adjustments on all incoming edges are consistent.
808 Heavily borrowed from pre_and_rev_post_order_compute. */
811 vt_stack_adjustments (void)
813 edge_iterator
*stack
;
816 /* Initialize entry block. */
817 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->visited
= true;
818 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->in
.stack_adjust
819 = INCOMING_FRAME_SP_OFFSET
;
820 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
.stack_adjust
821 = INCOMING_FRAME_SP_OFFSET
;
823 /* Allocate stack for back-tracking up CFG. */
824 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
827 /* Push the first edge on to the stack. */
828 stack
[sp
++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
836 /* Look at the edge on the top of the stack. */
838 src
= ei_edge (ei
)->src
;
839 dest
= ei_edge (ei
)->dest
;
841 /* Check if the edge destination has been visited yet. */
842 if (!VTI (dest
)->visited
)
845 HOST_WIDE_INT pre
, post
, offset
;
846 VTI (dest
)->visited
= true;
847 VTI (dest
)->in
.stack_adjust
= offset
= VTI (src
)->out
.stack_adjust
;
849 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
850 for (insn
= BB_HEAD (dest
);
851 insn
!= NEXT_INSN (BB_END (dest
));
852 insn
= NEXT_INSN (insn
))
855 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
856 offset
+= pre
+ post
;
859 VTI (dest
)->out
.stack_adjust
= offset
;
861 if (EDGE_COUNT (dest
->succs
) > 0)
862 /* Since the DEST node has been visited for the first
863 time, check its successors. */
864 stack
[sp
++] = ei_start (dest
->succs
);
868 /* We can end up with different stack adjustments for the exit block
869 of a shrink-wrapped function if stack_adjust_offset_pre_post
870 doesn't understand the rtx pattern used to restore the stack
871 pointer in the epilogue. For example, on s390(x), the stack
872 pointer is often restored via a load-multiple instruction
873 and so no stack_adjust offset is recorded for it. This means
874 that the stack offset at the end of the epilogue block is the
875 same as the offset before the epilogue, whereas other paths
876 to the exit block will have the correct stack_adjust.
878 It is safe to ignore these differences because (a) we never
879 use the stack_adjust for the exit block in this pass and
880 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
881 function are correct.
883 We must check whether the adjustments on other edges are
885 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
886 && VTI (dest
)->in
.stack_adjust
!= VTI (src
)->out
.stack_adjust
)
892 if (! ei_one_before_end_p (ei
))
893 /* Go to the next edge. */
894 ei_next (&stack
[sp
- 1]);
896 /* Return to previous level if there are no more edges. */
905 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
906 hard_frame_pointer_rtx is being mapped to it and offset for it. */
907 static rtx cfa_base_rtx
;
908 static HOST_WIDE_INT cfa_base_offset
;
910 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
911 or hard_frame_pointer_rtx. */
914 compute_cfa_pointer (HOST_WIDE_INT adjustment
)
916 return plus_constant (Pmode
, cfa_base_rtx
, adjustment
+ cfa_base_offset
);
919 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
920 or -1 if the replacement shouldn't be done. */
921 static HOST_WIDE_INT hard_frame_pointer_adjustment
= -1;
923 /* Data for adjust_mems callback. */
925 struct adjust_mem_data
928 machine_mode mem_mode
;
929 HOST_WIDE_INT stack_adjust
;
930 auto_vec
<rtx
> side_effects
;
933 /* Helper for adjust_mems. Return true if X is suitable for
934 transformation of wider mode arithmetics to narrower mode. */
937 use_narrower_mode_test (rtx x
, const_rtx subreg
)
939 subrtx_var_iterator::array_type array
;
940 FOR_EACH_SUBRTX_VAR (iter
, array
, x
, NONCONST
)
944 iter
.skip_subrtxes ();
946 switch (GET_CODE (x
))
949 if (cselib_lookup (x
, GET_MODE (SUBREG_REG (subreg
)), 0, VOIDmode
))
951 if (!validate_subreg (GET_MODE (subreg
), GET_MODE (x
), x
,
952 subreg_lowpart_offset (GET_MODE (subreg
),
961 iter
.substitute (XEXP (x
, 0));
970 /* Transform X into narrower mode MODE from wider mode WMODE. */
973 use_narrower_mode (rtx x
, machine_mode mode
, machine_mode wmode
)
977 return lowpart_subreg (mode
, x
, wmode
);
978 switch (GET_CODE (x
))
981 return lowpart_subreg (mode
, x
, wmode
);
985 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
986 op1
= use_narrower_mode (XEXP (x
, 1), mode
, wmode
);
987 return simplify_gen_binary (GET_CODE (x
), mode
, op0
, op1
);
989 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
991 /* Ensure shift amount is not wider than mode. */
992 if (GET_MODE (op1
) == VOIDmode
)
993 op1
= lowpart_subreg (mode
, op1
, wmode
);
994 else if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (GET_MODE (op1
)))
995 op1
= lowpart_subreg (mode
, op1
, GET_MODE (op1
));
996 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
1002 /* Helper function for adjusting used MEMs. */
1005 adjust_mems (rtx loc
, const_rtx old_rtx
, void *data
)
1007 struct adjust_mem_data
*amd
= (struct adjust_mem_data
*) data
;
1008 rtx mem
, addr
= loc
, tem
;
1009 machine_mode mem_mode_save
;
1011 switch (GET_CODE (loc
))
1014 /* Don't do any sp or fp replacements outside of MEM addresses
1016 if (amd
->mem_mode
== VOIDmode
&& amd
->store
)
1018 if (loc
== stack_pointer_rtx
1019 && !frame_pointer_needed
1021 return compute_cfa_pointer (amd
->stack_adjust
);
1022 else if (loc
== hard_frame_pointer_rtx
1023 && frame_pointer_needed
1024 && hard_frame_pointer_adjustment
!= -1
1026 return compute_cfa_pointer (hard_frame_pointer_adjustment
);
1027 gcc_checking_assert (loc
!= virtual_incoming_args_rtx
);
1033 mem
= targetm
.delegitimize_address (mem
);
1034 if (mem
!= loc
&& !MEM_P (mem
))
1035 return simplify_replace_fn_rtx (mem
, old_rtx
, adjust_mems
, data
);
1038 addr
= XEXP (mem
, 0);
1039 mem_mode_save
= amd
->mem_mode
;
1040 amd
->mem_mode
= GET_MODE (mem
);
1041 store_save
= amd
->store
;
1043 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1044 amd
->store
= store_save
;
1045 amd
->mem_mode
= mem_mode_save
;
1047 addr
= targetm
.delegitimize_address (addr
);
1048 if (addr
!= XEXP (mem
, 0))
1049 mem
= replace_equiv_address_nv (mem
, addr
);
1051 mem
= avoid_constant_pool_reference (mem
);
1055 addr
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1056 gen_int_mode (GET_CODE (loc
) == PRE_INC
1057 ? GET_MODE_SIZE (amd
->mem_mode
)
1058 : -GET_MODE_SIZE (amd
->mem_mode
),
1064 addr
= XEXP (loc
, 0);
1065 gcc_assert (amd
->mem_mode
!= VOIDmode
&& amd
->mem_mode
!= BLKmode
);
1066 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1067 tem
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1068 gen_int_mode ((GET_CODE (loc
) == PRE_INC
1069 || GET_CODE (loc
) == POST_INC
)
1070 ? GET_MODE_SIZE (amd
->mem_mode
)
1071 : -GET_MODE_SIZE (amd
->mem_mode
),
1073 store_save
= amd
->store
;
1075 tem
= simplify_replace_fn_rtx (tem
, old_rtx
, adjust_mems
, data
);
1076 amd
->store
= store_save
;
1077 amd
->side_effects
.safe_push (gen_rtx_SET (XEXP (loc
, 0), tem
));
1080 addr
= XEXP (loc
, 1);
1084 addr
= XEXP (loc
, 0);
1085 gcc_assert (amd
->mem_mode
!= VOIDmode
);
1086 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1087 store_save
= amd
->store
;
1089 tem
= simplify_replace_fn_rtx (XEXP (loc
, 1), old_rtx
,
1091 amd
->store
= store_save
;
1092 amd
->side_effects
.safe_push (gen_rtx_SET (XEXP (loc
, 0), tem
));
1095 /* First try without delegitimization of whole MEMs and
1096 avoid_constant_pool_reference, which is more likely to succeed. */
1097 store_save
= amd
->store
;
1099 addr
= simplify_replace_fn_rtx (SUBREG_REG (loc
), old_rtx
, adjust_mems
,
1101 amd
->store
= store_save
;
1102 mem
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1103 if (mem
== SUBREG_REG (loc
))
1108 tem
= simplify_gen_subreg (GET_MODE (loc
), mem
,
1109 GET_MODE (SUBREG_REG (loc
)),
1113 tem
= simplify_gen_subreg (GET_MODE (loc
), addr
,
1114 GET_MODE (SUBREG_REG (loc
)),
1116 if (tem
== NULL_RTX
)
1117 tem
= gen_rtx_raw_SUBREG (GET_MODE (loc
), addr
, SUBREG_BYTE (loc
));
1119 if (MAY_HAVE_DEBUG_INSNS
1120 && GET_CODE (tem
) == SUBREG
1121 && (GET_CODE (SUBREG_REG (tem
)) == PLUS
1122 || GET_CODE (SUBREG_REG (tem
)) == MINUS
1123 || GET_CODE (SUBREG_REG (tem
)) == MULT
1124 || GET_CODE (SUBREG_REG (tem
)) == ASHIFT
)
1125 && (GET_MODE_CLASS (GET_MODE (tem
)) == MODE_INT
1126 || GET_MODE_CLASS (GET_MODE (tem
)) == MODE_PARTIAL_INT
)
1127 && (GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem
))) == MODE_INT
1128 || GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem
))) == MODE_PARTIAL_INT
)
1129 && GET_MODE_PRECISION (GET_MODE (tem
))
1130 < GET_MODE_PRECISION (GET_MODE (SUBREG_REG (tem
)))
1131 && subreg_lowpart_p (tem
)
1132 && use_narrower_mode_test (SUBREG_REG (tem
), tem
))
1133 return use_narrower_mode (SUBREG_REG (tem
), GET_MODE (tem
),
1134 GET_MODE (SUBREG_REG (tem
)));
1137 /* Don't do any replacements in second and following
1138 ASM_OPERANDS of inline-asm with multiple sets.
1139 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1140 and ASM_OPERANDS_LABEL_VEC need to be equal between
1141 all the ASM_OPERANDs in the insn and adjust_insn will
1143 if (ASM_OPERANDS_OUTPUT_IDX (loc
) != 0)
1152 /* Helper function for replacement of uses. */
1155 adjust_mem_uses (rtx
*x
, void *data
)
1157 rtx new_x
= simplify_replace_fn_rtx (*x
, NULL_RTX
, adjust_mems
, data
);
1159 validate_change (NULL_RTX
, x
, new_x
, true);
1162 /* Helper function for replacement of stores. */
1165 adjust_mem_stores (rtx loc
, const_rtx expr
, void *data
)
1169 rtx new_dest
= simplify_replace_fn_rtx (SET_DEST (expr
), NULL_RTX
,
1171 if (new_dest
!= SET_DEST (expr
))
1173 rtx xexpr
= CONST_CAST_RTX (expr
);
1174 validate_change (NULL_RTX
, &SET_DEST (xexpr
), new_dest
, true);
1179 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1180 replace them with their value in the insn and add the side-effects
1181 as other sets to the insn. */
1184 adjust_insn (basic_block bb
, rtx_insn
*insn
)
1188 #ifdef HAVE_window_save
1189 /* If the target machine has an explicit window save instruction, the
1190 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1191 if (RTX_FRAME_RELATED_P (insn
)
1192 && find_reg_note (insn
, REG_CFA_WINDOW_SAVE
, NULL_RTX
))
1194 unsigned int i
, nregs
= vec_safe_length (windowed_parm_regs
);
1195 rtx rtl
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (nregs
* 2));
1198 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs
, i
, p
)
1200 XVECEXP (rtl
, 0, i
* 2)
1201 = gen_rtx_SET (p
->incoming
, p
->outgoing
);
1202 /* Do not clobber the attached DECL, but only the REG. */
1203 XVECEXP (rtl
, 0, i
* 2 + 1)
1204 = gen_rtx_CLOBBER (GET_MODE (p
->outgoing
),
1205 gen_raw_REG (GET_MODE (p
->outgoing
),
1206 REGNO (p
->outgoing
)));
1209 validate_change (NULL_RTX
, &PATTERN (insn
), rtl
, true);
1214 adjust_mem_data amd
;
1215 amd
.mem_mode
= VOIDmode
;
1216 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
1219 note_stores (PATTERN (insn
), adjust_mem_stores
, &amd
);
1222 if (GET_CODE (PATTERN (insn
)) == PARALLEL
1223 && asm_noperands (PATTERN (insn
)) > 0
1224 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == SET
)
1229 /* inline-asm with multiple sets is tiny bit more complicated,
1230 because the 3 vectors in ASM_OPERANDS need to be shared between
1231 all ASM_OPERANDS in the instruction. adjust_mems will
1232 not touch ASM_OPERANDS other than the first one, asm_noperands
1233 test above needs to be called before that (otherwise it would fail)
1234 and afterwards this code fixes it up. */
1235 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1236 body
= PATTERN (insn
);
1237 set0
= XVECEXP (body
, 0, 0);
1238 gcc_checking_assert (GET_CODE (set0
) == SET
1239 && GET_CODE (SET_SRC (set0
)) == ASM_OPERANDS
1240 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0
)) == 0);
1241 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1242 if (GET_CODE (XVECEXP (body
, 0, i
)) != SET
)
1246 set
= XVECEXP (body
, 0, i
);
1247 gcc_checking_assert (GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
1248 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set
))
1250 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set
))
1251 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
))
1252 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set
))
1253 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
))
1254 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set
))
1255 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
)))
1257 rtx newsrc
= shallow_copy_rtx (SET_SRC (set
));
1258 ASM_OPERANDS_INPUT_VEC (newsrc
)
1259 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
));
1260 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc
)
1261 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
));
1262 ASM_OPERANDS_LABEL_VEC (newsrc
)
1263 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
));
1264 validate_change (NULL_RTX
, &SET_SRC (set
), newsrc
, true);
1269 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1271 /* For read-only MEMs containing some constant, prefer those
1273 set
= single_set (insn
);
1274 if (set
&& MEM_P (SET_SRC (set
)) && MEM_READONLY_P (SET_SRC (set
)))
1276 rtx note
= find_reg_equal_equiv_note (insn
);
1278 if (note
&& CONSTANT_P (XEXP (note
, 0)))
1279 validate_change (NULL_RTX
, &SET_SRC (set
), XEXP (note
, 0), true);
1282 if (!amd
.side_effects
.is_empty ())
1287 pat
= &PATTERN (insn
);
1288 if (GET_CODE (*pat
) == COND_EXEC
)
1289 pat
= &COND_EXEC_CODE (*pat
);
1290 if (GET_CODE (*pat
) == PARALLEL
)
1291 oldn
= XVECLEN (*pat
, 0);
1294 unsigned int newn
= amd
.side_effects
.length ();
1295 new_pat
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (oldn
+ newn
));
1296 if (GET_CODE (*pat
) == PARALLEL
)
1297 for (i
= 0; i
< oldn
; i
++)
1298 XVECEXP (new_pat
, 0, i
) = XVECEXP (*pat
, 0, i
);
1300 XVECEXP (new_pat
, 0, 0) = *pat
;
1304 FOR_EACH_VEC_ELT_REVERSE (amd
.side_effects
, j
, effect
)
1305 XVECEXP (new_pat
, 0, j
+ oldn
) = effect
;
1306 validate_change (NULL_RTX
, pat
, new_pat
, true);
1310 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1312 dv_as_rtx (decl_or_value dv
)
1316 if (dv_is_value_p (dv
))
1317 return dv_as_value (dv
);
1319 decl
= dv_as_decl (dv
);
1321 gcc_checking_assert (TREE_CODE (decl
) == DEBUG_EXPR_DECL
);
1322 return DECL_RTL_KNOWN_SET (decl
);
1325 /* Return nonzero if a decl_or_value must not have more than one
1326 variable part. The returned value discriminates among various
1327 kinds of one-part DVs ccording to enum onepart_enum. */
1328 static inline onepart_enum
1329 dv_onepart_p (decl_or_value dv
)
1333 if (!MAY_HAVE_DEBUG_INSNS
)
1336 if (dv_is_value_p (dv
))
1337 return ONEPART_VALUE
;
1339 decl
= dv_as_decl (dv
);
1341 if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
1342 return ONEPART_DEXPR
;
1344 if (target_for_debug_bind (decl
) != NULL_TREE
)
1345 return ONEPART_VDECL
;
1350 /* Return the variable pool to be used for a dv of type ONEPART. */
1351 static inline pool_allocator
&
1352 onepart_pool (onepart_enum onepart
)
1354 return onepart
? valvar_pool
: var_pool
;
1357 /* Allocate a variable_def from the corresponding variable pool. */
1358 static inline variable
*
1359 onepart_pool_allocate (onepart_enum onepart
)
1361 return (variable
*) onepart_pool (onepart
).allocate ();
1364 /* Build a decl_or_value out of a decl. */
1365 static inline decl_or_value
1366 dv_from_decl (tree decl
)
1370 gcc_checking_assert (dv_is_decl_p (dv
));
1374 /* Build a decl_or_value out of a value. */
1375 static inline decl_or_value
1376 dv_from_value (rtx value
)
1380 gcc_checking_assert (dv_is_value_p (dv
));
1384 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1385 static inline decl_or_value
1390 switch (GET_CODE (x
))
1393 dv
= dv_from_decl (DEBUG_EXPR_TREE_DECL (x
));
1394 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x
)) == x
);
1398 dv
= dv_from_value (x
);
1408 extern void debug_dv (decl_or_value dv
);
1411 debug_dv (decl_or_value dv
)
1413 if (dv_is_value_p (dv
))
1414 debug_rtx (dv_as_value (dv
));
1416 debug_generic_stmt (dv_as_decl (dv
));
1419 static void loc_exp_dep_clear (variable
*var
);
1421 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1424 variable_htab_free (void *elem
)
1427 variable
*var
= (variable
*) elem
;
1428 location_chain
*node
, *next
;
1430 gcc_checking_assert (var
->refcount
> 0);
1433 if (var
->refcount
> 0)
1436 for (i
= 0; i
< var
->n_var_parts
; i
++)
1438 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= next
)
1443 var
->var_part
[i
].loc_chain
= NULL
;
1445 if (var
->onepart
&& VAR_LOC_1PAUX (var
))
1447 loc_exp_dep_clear (var
);
1448 if (VAR_LOC_DEP_LST (var
))
1449 VAR_LOC_DEP_LST (var
)->pprev
= NULL
;
1450 XDELETE (VAR_LOC_1PAUX (var
));
1451 /* These may be reused across functions, so reset
1453 if (var
->onepart
== ONEPART_DEXPR
)
1454 set_dv_changed (var
->dv
, true);
1456 onepart_pool (var
->onepart
).remove (var
);
1459 /* Initialize the set (array) SET of attrs to empty lists. */
1462 init_attrs_list_set (attrs
**set
)
1466 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1470 /* Make the list *LISTP empty. */
1473 attrs_list_clear (attrs
**listp
)
1477 for (list
= *listp
; list
; list
= next
)
1485 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1488 attrs_list_member (attrs
*list
, decl_or_value dv
, HOST_WIDE_INT offset
)
1490 for (; list
; list
= list
->next
)
1491 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
) && list
->offset
== offset
)
1496 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1499 attrs_list_insert (attrs
**listp
, decl_or_value dv
,
1500 HOST_WIDE_INT offset
, rtx loc
)
1502 attrs
*list
= new attrs
;
1505 list
->offset
= offset
;
1506 list
->next
= *listp
;
1510 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1513 attrs_list_copy (attrs
**dstp
, attrs
*src
)
1515 attrs_list_clear (dstp
);
1516 for (; src
; src
= src
->next
)
1518 attrs
*n
= new attrs
;
1521 n
->offset
= src
->offset
;
1527 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1530 attrs_list_union (attrs
**dstp
, attrs
*src
)
1532 for (; src
; src
= src
->next
)
1534 if (!attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1535 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1539 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1543 attrs_list_mpdv_union (attrs
**dstp
, attrs
*src
, attrs
*src2
)
1545 gcc_assert (!*dstp
);
1546 for (; src
; src
= src
->next
)
1548 if (!dv_onepart_p (src
->dv
))
1549 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1551 for (src
= src2
; src
; src
= src
->next
)
1553 if (!dv_onepart_p (src
->dv
)
1554 && !attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1555 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1559 /* Shared hashtable support. */
1561 /* Return true if VARS is shared. */
1564 shared_hash_shared (shared_hash
*vars
)
1566 return vars
->refcount
> 1;
1569 /* Return the hash table for VARS. */
1571 static inline variable_table_type
*
1572 shared_hash_htab (shared_hash
*vars
)
1577 /* Return true if VAR is shared, or maybe because VARS is shared. */
1580 shared_var_p (variable
*var
, shared_hash
*vars
)
1582 /* Don't count an entry in the changed_variables table as a duplicate. */
1583 return ((var
->refcount
> 1 + (int) var
->in_changed_variables
)
1584 || shared_hash_shared (vars
));
1587 /* Copy variables into a new hash table. */
1589 static shared_hash
*
1590 shared_hash_unshare (shared_hash
*vars
)
1592 shared_hash
*new_vars
= new shared_hash
;
1593 gcc_assert (vars
->refcount
> 1);
1594 new_vars
->refcount
= 1;
1595 new_vars
->htab
= new variable_table_type (vars
->htab
->elements () + 3);
1596 vars_copy (new_vars
->htab
, vars
->htab
);
1601 /* Increment reference counter on VARS and return it. */
1603 static inline shared_hash
*
1604 shared_hash_copy (shared_hash
*vars
)
1610 /* Decrement reference counter and destroy hash table if not shared
1614 shared_hash_destroy (shared_hash
*vars
)
1616 gcc_checking_assert (vars
->refcount
> 0);
1617 if (--vars
->refcount
== 0)
1624 /* Unshare *PVARS if shared and return slot for DV. If INS is
1625 INSERT, insert it if not already present. */
1627 static inline variable
**
1628 shared_hash_find_slot_unshare_1 (shared_hash
**pvars
, decl_or_value dv
,
1629 hashval_t dvhash
, enum insert_option ins
)
1631 if (shared_hash_shared (*pvars
))
1632 *pvars
= shared_hash_unshare (*pvars
);
1633 return shared_hash_htab (*pvars
)->find_slot_with_hash (dv
, dvhash
, ins
);
1636 static inline variable
**
1637 shared_hash_find_slot_unshare (shared_hash
**pvars
, decl_or_value dv
,
1638 enum insert_option ins
)
1640 return shared_hash_find_slot_unshare_1 (pvars
, dv
, dv_htab_hash (dv
), ins
);
1643 /* Return slot for DV, if it is already present in the hash table.
1644 If it is not present, insert it only VARS is not shared, otherwise
1647 static inline variable
**
1648 shared_hash_find_slot_1 (shared_hash
*vars
, decl_or_value dv
, hashval_t dvhash
)
1650 return shared_hash_htab (vars
)->find_slot_with_hash (dv
, dvhash
,
1651 shared_hash_shared (vars
)
1652 ? NO_INSERT
: INSERT
);
1655 static inline variable
**
1656 shared_hash_find_slot (shared_hash
*vars
, decl_or_value dv
)
1658 return shared_hash_find_slot_1 (vars
, dv
, dv_htab_hash (dv
));
1661 /* Return slot for DV only if it is already present in the hash table. */
1663 static inline variable
**
1664 shared_hash_find_slot_noinsert_1 (shared_hash
*vars
, decl_or_value dv
,
1667 return shared_hash_htab (vars
)->find_slot_with_hash (dv
, dvhash
, NO_INSERT
);
1670 static inline variable
**
1671 shared_hash_find_slot_noinsert (shared_hash
*vars
, decl_or_value dv
)
1673 return shared_hash_find_slot_noinsert_1 (vars
, dv
, dv_htab_hash (dv
));
1676 /* Return variable for DV or NULL if not already present in the hash
1679 static inline variable
*
1680 shared_hash_find_1 (shared_hash
*vars
, decl_or_value dv
, hashval_t dvhash
)
1682 return shared_hash_htab (vars
)->find_with_hash (dv
, dvhash
);
1685 static inline variable
*
1686 shared_hash_find (shared_hash
*vars
, decl_or_value dv
)
1688 return shared_hash_find_1 (vars
, dv
, dv_htab_hash (dv
));
1691 /* Return true if TVAL is better than CVAL as a canonival value. We
1692 choose lowest-numbered VALUEs, using the RTX address as a
1693 tie-breaker. The idea is to arrange them into a star topology,
1694 such that all of them are at most one step away from the canonical
1695 value, and the canonical value has backlinks to all of them, in
1696 addition to all the actual locations. We don't enforce this
1697 topology throughout the entire dataflow analysis, though.
1701 canon_value_cmp (rtx tval
, rtx cval
)
1704 || CSELIB_VAL_PTR (tval
)->uid
< CSELIB_VAL_PTR (cval
)->uid
;
1707 static bool dst_can_be_shared
;
1709 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1712 unshare_variable (dataflow_set
*set
, variable
**slot
, variable
*var
,
1713 enum var_init_status initialized
)
1718 new_var
= onepart_pool_allocate (var
->onepart
);
1719 new_var
->dv
= var
->dv
;
1720 new_var
->refcount
= 1;
1722 new_var
->n_var_parts
= var
->n_var_parts
;
1723 new_var
->onepart
= var
->onepart
;
1724 new_var
->in_changed_variables
= false;
1726 if (! flag_var_tracking_uninit
)
1727 initialized
= VAR_INIT_STATUS_INITIALIZED
;
1729 for (i
= 0; i
< var
->n_var_parts
; i
++)
1731 location_chain
*node
;
1732 location_chain
**nextp
;
1734 if (i
== 0 && var
->onepart
)
1736 /* One-part auxiliary data is only used while emitting
1737 notes, so propagate it to the new variable in the active
1738 dataflow set. If we're not emitting notes, this will be
1740 gcc_checking_assert (!VAR_LOC_1PAUX (var
) || emit_notes
);
1741 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (var
);
1742 VAR_LOC_1PAUX (var
) = NULL
;
1745 VAR_PART_OFFSET (new_var
, i
) = VAR_PART_OFFSET (var
, i
);
1746 nextp
= &new_var
->var_part
[i
].loc_chain
;
1747 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
1749 location_chain
*new_lc
;
1751 new_lc
= new location_chain
;
1752 new_lc
->next
= NULL
;
1753 if (node
->init
> initialized
)
1754 new_lc
->init
= node
->init
;
1756 new_lc
->init
= initialized
;
1757 if (node
->set_src
&& !(MEM_P (node
->set_src
)))
1758 new_lc
->set_src
= node
->set_src
;
1760 new_lc
->set_src
= NULL
;
1761 new_lc
->loc
= node
->loc
;
1764 nextp
= &new_lc
->next
;
1767 new_var
->var_part
[i
].cur_loc
= var
->var_part
[i
].cur_loc
;
1770 dst_can_be_shared
= false;
1771 if (shared_hash_shared (set
->vars
))
1772 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
, NO_INSERT
);
1773 else if (set
->traversed_vars
&& set
->vars
!= set
->traversed_vars
)
1774 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
1776 if (var
->in_changed_variables
)
1779 = changed_variables
->find_slot_with_hash (var
->dv
,
1780 dv_htab_hash (var
->dv
),
1782 gcc_assert (*cslot
== (void *) var
);
1783 var
->in_changed_variables
= false;
1784 variable_htab_free (var
);
1786 new_var
->in_changed_variables
= true;
1791 /* Copy all variables from hash table SRC to hash table DST. */
1794 vars_copy (variable_table_type
*dst
, variable_table_type
*src
)
1796 variable_iterator_type hi
;
1799 FOR_EACH_HASH_TABLE_ELEMENT (*src
, var
, variable
, hi
)
1803 dstp
= dst
->find_slot_with_hash (var
->dv
, dv_htab_hash (var
->dv
),
1809 /* Map a decl to its main debug decl. */
1812 var_debug_decl (tree decl
)
1814 if (decl
&& VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
1816 tree debugdecl
= DECL_DEBUG_EXPR (decl
);
1817 if (DECL_P (debugdecl
))
1824 /* Set the register LOC to contain DV, OFFSET. */
1827 var_reg_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1828 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
1829 enum insert_option iopt
)
1832 bool decl_p
= dv_is_decl_p (dv
);
1835 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
1837 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
1838 if (dv_as_opaque (node
->dv
) == dv_as_opaque (dv
)
1839 && node
->offset
== offset
)
1842 attrs_list_insert (&set
->regs
[REGNO (loc
)], dv
, offset
, loc
);
1843 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
1846 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1849 var_reg_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1852 tree decl
= REG_EXPR (loc
);
1853 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1855 var_reg_decl_set (set
, loc
, initialized
,
1856 dv_from_decl (decl
), offset
, set_src
, INSERT
);
1859 static enum var_init_status
1860 get_init_value (dataflow_set
*set
, rtx loc
, decl_or_value dv
)
1864 enum var_init_status ret_val
= VAR_INIT_STATUS_UNKNOWN
;
1866 if (! flag_var_tracking_uninit
)
1867 return VAR_INIT_STATUS_INITIALIZED
;
1869 var
= shared_hash_find (set
->vars
, dv
);
1872 for (i
= 0; i
< var
->n_var_parts
&& ret_val
== VAR_INIT_STATUS_UNKNOWN
; i
++)
1874 location_chain
*nextp
;
1875 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
; nextp
= nextp
->next
)
1876 if (rtx_equal_p (nextp
->loc
, loc
))
1878 ret_val
= nextp
->init
;
1887 /* Delete current content of register LOC in dataflow set SET and set
1888 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1889 MODIFY is true, any other live copies of the same variable part are
1890 also deleted from the dataflow set, otherwise the variable part is
1891 assumed to be copied from another location holding the same
1895 var_reg_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
1896 enum var_init_status initialized
, rtx set_src
)
1898 tree decl
= REG_EXPR (loc
);
1899 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1903 decl
= var_debug_decl (decl
);
1905 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
1906 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
1908 nextp
= &set
->regs
[REGNO (loc
)];
1909 for (node
= *nextp
; node
; node
= next
)
1912 if (dv_as_opaque (node
->dv
) != decl
|| node
->offset
!= offset
)
1914 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1921 nextp
= &node
->next
;
1925 clobber_variable_part (set
, loc
, dv_from_decl (decl
), offset
, set_src
);
1926 var_reg_set (set
, loc
, initialized
, set_src
);
1929 /* Delete the association of register LOC in dataflow set SET with any
1930 variables that aren't onepart. If CLOBBER is true, also delete any
1931 other live copies of the same variable part, and delete the
1932 association with onepart dvs too. */
1935 var_reg_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
1937 attrs
**nextp
= &set
->regs
[REGNO (loc
)];
1942 tree decl
= REG_EXPR (loc
);
1943 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1945 decl
= var_debug_decl (decl
);
1947 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
1950 for (node
= *nextp
; node
; node
= next
)
1953 if (clobber
|| !dv_onepart_p (node
->dv
))
1955 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1960 nextp
= &node
->next
;
1964 /* Delete content of register with number REGNO in dataflow set SET. */
1967 var_regno_delete (dataflow_set
*set
, int regno
)
1969 attrs
**reg
= &set
->regs
[regno
];
1972 for (node
= *reg
; node
; node
= next
)
1975 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1981 /* Return true if I is the negated value of a power of two. */
1983 negative_power_of_two_p (HOST_WIDE_INT i
)
1985 unsigned HOST_WIDE_INT x
= -(unsigned HOST_WIDE_INT
)i
;
1986 return pow2_or_zerop (x
);
1989 /* Strip constant offsets and alignments off of LOC. Return the base
1993 vt_get_canonicalize_base (rtx loc
)
1995 while ((GET_CODE (loc
) == PLUS
1996 || GET_CODE (loc
) == AND
)
1997 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
1998 && (GET_CODE (loc
) != AND
1999 || negative_power_of_two_p (INTVAL (XEXP (loc
, 1)))))
2000 loc
= XEXP (loc
, 0);
2005 /* This caches canonicalized addresses for VALUEs, computed using
2006 information in the global cselib table. */
2007 static hash_map
<rtx
, rtx
> *global_get_addr_cache
;
2009 /* This caches canonicalized addresses for VALUEs, computed using
2010 information from the global cache and information pertaining to a
2011 basic block being analyzed. */
2012 static hash_map
<rtx
, rtx
> *local_get_addr_cache
;
2014 static rtx
vt_canonicalize_addr (dataflow_set
*, rtx
);
2016 /* Return the canonical address for LOC, that must be a VALUE, using a
2017 cached global equivalence or computing it and storing it in the
2021 get_addr_from_global_cache (rtx
const loc
)
2025 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2028 rtx
*slot
= &global_get_addr_cache
->get_or_insert (loc
, &existed
);
2032 x
= canon_rtx (get_addr (loc
));
2034 /* Tentative, avoiding infinite recursion. */
2039 rtx nx
= vt_canonicalize_addr (NULL
, x
);
2042 /* The table may have moved during recursion, recompute
2044 *global_get_addr_cache
->get (loc
) = x
= nx
;
2051 /* Return the canonical address for LOC, that must be a VALUE, using a
2052 cached local equivalence or computing it and storing it in the
2056 get_addr_from_local_cache (dataflow_set
*set
, rtx
const loc
)
2063 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2066 rtx
*slot
= &local_get_addr_cache
->get_or_insert (loc
, &existed
);
2070 x
= get_addr_from_global_cache (loc
);
2072 /* Tentative, avoiding infinite recursion. */
2075 /* Recurse to cache local expansion of X, or if we need to search
2076 for a VALUE in the expansion. */
2079 rtx nx
= vt_canonicalize_addr (set
, x
);
2082 slot
= local_get_addr_cache
->get (loc
);
2088 dv
= dv_from_rtx (x
);
2089 var
= shared_hash_find (set
->vars
, dv
);
2093 /* Look for an improved equivalent expression. */
2094 for (l
= var
->var_part
[0].loc_chain
; l
; l
= l
->next
)
2096 rtx base
= vt_get_canonicalize_base (l
->loc
);
2097 if (GET_CODE (base
) == VALUE
2098 && canon_value_cmp (base
, loc
))
2100 rtx nx
= vt_canonicalize_addr (set
, l
->loc
);
2103 slot
= local_get_addr_cache
->get (loc
);
2113 /* Canonicalize LOC using equivalences from SET in addition to those
2114 in the cselib static table. It expects a VALUE-based expression,
2115 and it will only substitute VALUEs with other VALUEs or
2116 function-global equivalences, so that, if two addresses have base
2117 VALUEs that are locally or globally related in ways that
2118 memrefs_conflict_p cares about, they will both canonicalize to
2119 expressions that have the same base VALUE.
2121 The use of VALUEs as canonical base addresses enables the canonical
2122 RTXs to remain unchanged globally, if they resolve to a constant,
2123 or throughout a basic block otherwise, so that they can be cached
2124 and the cache needs not be invalidated when REGs, MEMs or such
2128 vt_canonicalize_addr (dataflow_set
*set
, rtx oloc
)
2130 HOST_WIDE_INT ofst
= 0;
2131 machine_mode mode
= GET_MODE (oloc
);
2138 while (GET_CODE (loc
) == PLUS
2139 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2141 ofst
+= INTVAL (XEXP (loc
, 1));
2142 loc
= XEXP (loc
, 0);
2145 /* Alignment operations can't normally be combined, so just
2146 canonicalize the base and we're done. We'll normally have
2147 only one stack alignment anyway. */
2148 if (GET_CODE (loc
) == AND
2149 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
2150 && negative_power_of_two_p (INTVAL (XEXP (loc
, 1))))
2152 x
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2153 if (x
!= XEXP (loc
, 0))
2154 loc
= gen_rtx_AND (mode
, x
, XEXP (loc
, 1));
2158 if (GET_CODE (loc
) == VALUE
)
2161 loc
= get_addr_from_local_cache (set
, loc
);
2163 loc
= get_addr_from_global_cache (loc
);
2165 /* Consolidate plus_constants. */
2166 while (ofst
&& GET_CODE (loc
) == PLUS
2167 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2169 ofst
+= INTVAL (XEXP (loc
, 1));
2170 loc
= XEXP (loc
, 0);
2177 x
= canon_rtx (loc
);
2184 /* Add OFST back in. */
2187 /* Don't build new RTL if we can help it. */
2188 if (GET_CODE (oloc
) == PLUS
2189 && XEXP (oloc
, 0) == loc
2190 && INTVAL (XEXP (oloc
, 1)) == ofst
)
2193 loc
= plus_constant (mode
, loc
, ofst
);
2199 /* Return true iff there's a true dependence between MLOC and LOC.
2200 MADDR must be a canonicalized version of MLOC's address. */
2203 vt_canon_true_dep (dataflow_set
*set
, rtx mloc
, rtx maddr
, rtx loc
)
2205 if (GET_CODE (loc
) != MEM
)
2208 rtx addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2209 if (!canon_true_dependence (mloc
, GET_MODE (mloc
), maddr
, loc
, addr
))
2215 /* Hold parameters for the hashtab traversal function
2216 drop_overlapping_mem_locs, see below. */
2218 struct overlapping_mems
2224 /* Remove all MEMs that overlap with COMS->LOC from the location list
2225 of a hash table entry for a onepart variable. COMS->ADDR must be a
2226 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2227 canonicalized itself. */
2230 drop_overlapping_mem_locs (variable
**slot
, overlapping_mems
*coms
)
2232 dataflow_set
*set
= coms
->set
;
2233 rtx mloc
= coms
->loc
, addr
= coms
->addr
;
2234 variable
*var
= *slot
;
2236 if (var
->onepart
!= NOT_ONEPART
)
2238 location_chain
*loc
, **locp
;
2239 bool changed
= false;
2242 gcc_assert (var
->n_var_parts
== 1);
2244 if (shared_var_p (var
, set
->vars
))
2246 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
2247 if (vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2253 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
2255 gcc_assert (var
->n_var_parts
== 1);
2258 if (VAR_LOC_1PAUX (var
))
2259 cur_loc
= VAR_LOC_FROM (var
);
2261 cur_loc
= var
->var_part
[0].cur_loc
;
2263 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
2266 if (!vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2273 /* If we have deleted the location which was last emitted
2274 we have to emit new location so add the variable to set
2275 of changed variables. */
2276 if (cur_loc
== loc
->loc
)
2279 var
->var_part
[0].cur_loc
= NULL
;
2280 if (VAR_LOC_1PAUX (var
))
2281 VAR_LOC_FROM (var
) = NULL
;
2286 if (!var
->var_part
[0].loc_chain
)
2292 variable_was_changed (var
, set
);
2298 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2301 clobber_overlapping_mems (dataflow_set
*set
, rtx loc
)
2303 struct overlapping_mems coms
;
2305 gcc_checking_assert (GET_CODE (loc
) == MEM
);
2308 coms
.loc
= canon_rtx (loc
);
2309 coms
.addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2311 set
->traversed_vars
= set
->vars
;
2312 shared_hash_htab (set
->vars
)
2313 ->traverse
<overlapping_mems
*, drop_overlapping_mem_locs
> (&coms
);
2314 set
->traversed_vars
= NULL
;
2317 /* Set the location of DV, OFFSET as the MEM LOC. */
2320 var_mem_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2321 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
2322 enum insert_option iopt
)
2324 if (dv_is_decl_p (dv
))
2325 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
2327 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
2330 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2332 Adjust the address first if it is stack pointer based. */
2335 var_mem_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2338 tree decl
= MEM_EXPR (loc
);
2339 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2341 var_mem_decl_set (set
, loc
, initialized
,
2342 dv_from_decl (decl
), offset
, set_src
, INSERT
);
2345 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2346 dataflow set SET to LOC. If MODIFY is true, any other live copies
2347 of the same variable part are also deleted from the dataflow set,
2348 otherwise the variable part is assumed to be copied from another
2349 location holding the same part.
2350 Adjust the address first if it is stack pointer based. */
2353 var_mem_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
2354 enum var_init_status initialized
, rtx set_src
)
2356 tree decl
= MEM_EXPR (loc
);
2357 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2359 clobber_overlapping_mems (set
, loc
);
2360 decl
= var_debug_decl (decl
);
2362 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
2363 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
2366 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, set_src
);
2367 var_mem_set (set
, loc
, initialized
, set_src
);
2370 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2371 true, also delete any other live copies of the same variable part.
2372 Adjust the address first if it is stack pointer based. */
2375 var_mem_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
2377 tree decl
= MEM_EXPR (loc
);
2378 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2380 clobber_overlapping_mems (set
, loc
);
2381 decl
= var_debug_decl (decl
);
2383 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
2384 delete_variable_part (set
, loc
, dv_from_decl (decl
), offset
);
2387 /* Return true if LOC should not be expanded for location expressions,
2391 unsuitable_loc (rtx loc
)
2393 switch (GET_CODE (loc
))
2407 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2411 val_bind (dataflow_set
*set
, rtx val
, rtx loc
, bool modified
)
2416 var_regno_delete (set
, REGNO (loc
));
2417 var_reg_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2418 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2420 else if (MEM_P (loc
))
2422 struct elt_loc_list
*l
= CSELIB_VAL_PTR (val
)->locs
;
2425 clobber_overlapping_mems (set
, loc
);
2427 if (l
&& GET_CODE (l
->loc
) == VALUE
)
2428 l
= canonical_cselib_val (CSELIB_VAL_PTR (l
->loc
))->locs
;
2430 /* If this MEM is a global constant, we don't need it in the
2431 dynamic tables. ??? We should test this before emitting the
2432 micro-op in the first place. */
2434 if (GET_CODE (l
->loc
) == MEM
&& XEXP (l
->loc
, 0) == XEXP (loc
, 0))
2440 var_mem_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2441 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2445 /* Other kinds of equivalences are necessarily static, at least
2446 so long as we do not perform substitutions while merging
2449 set_variable_part (set
, loc
, dv_from_value (val
), 0,
2450 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2454 /* Bind a value to a location it was just stored in. If MODIFIED
2455 holds, assume the location was modified, detaching it from any
2456 values bound to it. */
2459 val_store (dataflow_set
*set
, rtx val
, rtx loc
, rtx_insn
*insn
,
2462 cselib_val
*v
= CSELIB_VAL_PTR (val
);
2464 gcc_assert (cselib_preserved_value_p (v
));
2468 fprintf (dump_file
, "%i: ", insn
? INSN_UID (insn
) : 0);
2469 print_inline_rtx (dump_file
, loc
, 0);
2470 fprintf (dump_file
, " evaluates to ");
2471 print_inline_rtx (dump_file
, val
, 0);
2474 struct elt_loc_list
*l
;
2475 for (l
= v
->locs
; l
; l
= l
->next
)
2477 fprintf (dump_file
, "\n%i: ", INSN_UID (l
->setting_insn
));
2478 print_inline_rtx (dump_file
, l
->loc
, 0);
2481 fprintf (dump_file
, "\n");
2484 gcc_checking_assert (!unsuitable_loc (loc
));
2486 val_bind (set
, val
, loc
, modified
);
2489 /* Clear (canonical address) slots that reference X. */
2492 local_get_addr_clear_given_value (rtx
const &, rtx
*slot
, rtx x
)
2494 if (vt_get_canonicalize_base (*slot
) == x
)
2499 /* Reset this node, detaching all its equivalences. Return the slot
2500 in the variable hash table that holds dv, if there is one. */
2503 val_reset (dataflow_set
*set
, decl_or_value dv
)
2505 variable
*var
= shared_hash_find (set
->vars
, dv
) ;
2506 location_chain
*node
;
2509 if (!var
|| !var
->n_var_parts
)
2512 gcc_assert (var
->n_var_parts
== 1);
2514 if (var
->onepart
== ONEPART_VALUE
)
2516 rtx x
= dv_as_value (dv
);
2518 /* Relationships in the global cache don't change, so reset the
2519 local cache entry only. */
2520 rtx
*slot
= local_get_addr_cache
->get (x
);
2523 /* If the value resolved back to itself, odds are that other
2524 values may have cached it too. These entries now refer
2525 to the old X, so detach them too. Entries that used the
2526 old X but resolved to something else remain ok as long as
2527 that something else isn't also reset. */
2529 local_get_addr_cache
2530 ->traverse
<rtx
, local_get_addr_clear_given_value
> (x
);
2536 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2537 if (GET_CODE (node
->loc
) == VALUE
2538 && canon_value_cmp (node
->loc
, cval
))
2541 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2542 if (GET_CODE (node
->loc
) == VALUE
&& cval
!= node
->loc
)
2544 /* Redirect the equivalence link to the new canonical
2545 value, or simply remove it if it would point at
2548 set_variable_part (set
, cval
, dv_from_value (node
->loc
),
2549 0, node
->init
, node
->set_src
, NO_INSERT
);
2550 delete_variable_part (set
, dv_as_value (dv
),
2551 dv_from_value (node
->loc
), 0);
2556 decl_or_value cdv
= dv_from_value (cval
);
2558 /* Keep the remaining values connected, accumulating links
2559 in the canonical value. */
2560 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2562 if (node
->loc
== cval
)
2564 else if (GET_CODE (node
->loc
) == REG
)
2565 var_reg_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2566 node
->set_src
, NO_INSERT
);
2567 else if (GET_CODE (node
->loc
) == MEM
)
2568 var_mem_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2569 node
->set_src
, NO_INSERT
);
2571 set_variable_part (set
, node
->loc
, cdv
, 0,
2572 node
->init
, node
->set_src
, NO_INSERT
);
2576 /* We remove this last, to make sure that the canonical value is not
2577 removed to the point of requiring reinsertion. */
2579 delete_variable_part (set
, dv_as_value (dv
), dv_from_value (cval
), 0);
2581 clobber_variable_part (set
, NULL
, dv
, 0, NULL
);
2584 /* Find the values in a given location and map the val to another
2585 value, if it is unique, or add the location as one holding the
2589 val_resolve (dataflow_set
*set
, rtx val
, rtx loc
, rtx_insn
*insn
)
2591 decl_or_value dv
= dv_from_value (val
);
2593 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2596 fprintf (dump_file
, "%i: ", INSN_UID (insn
));
2598 fprintf (dump_file
, "head: ");
2599 print_inline_rtx (dump_file
, val
, 0);
2600 fputs (" is at ", dump_file
);
2601 print_inline_rtx (dump_file
, loc
, 0);
2602 fputc ('\n', dump_file
);
2605 val_reset (set
, dv
);
2607 gcc_checking_assert (!unsuitable_loc (loc
));
2611 attrs
*node
, *found
= NULL
;
2613 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
2614 if (dv_is_value_p (node
->dv
)
2615 && GET_MODE (dv_as_value (node
->dv
)) == GET_MODE (loc
))
2619 /* Map incoming equivalences. ??? Wouldn't it be nice if
2620 we just started sharing the location lists? Maybe a
2621 circular list ending at the value itself or some
2623 set_variable_part (set
, dv_as_value (node
->dv
),
2624 dv_from_value (val
), node
->offset
,
2625 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2626 set_variable_part (set
, val
, node
->dv
, node
->offset
,
2627 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2630 /* If we didn't find any equivalence, we need to remember that
2631 this value is held in the named register. */
2635 /* ??? Attempt to find and merge equivalent MEMs or other
2638 val_bind (set
, val
, loc
, false);
2641 /* Initialize dataflow set SET to be empty.
2642 VARS_SIZE is the initial size of hash table VARS. */
2645 dataflow_set_init (dataflow_set
*set
)
2647 init_attrs_list_set (set
->regs
);
2648 set
->vars
= shared_hash_copy (empty_shared_hash
);
2649 set
->stack_adjust
= 0;
2650 set
->traversed_vars
= NULL
;
2653 /* Delete the contents of dataflow set SET. */
2656 dataflow_set_clear (dataflow_set
*set
)
2660 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2661 attrs_list_clear (&set
->regs
[i
]);
2663 shared_hash_destroy (set
->vars
);
2664 set
->vars
= shared_hash_copy (empty_shared_hash
);
2667 /* Copy the contents of dataflow set SRC to DST. */
2670 dataflow_set_copy (dataflow_set
*dst
, dataflow_set
*src
)
2674 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2675 attrs_list_copy (&dst
->regs
[i
], src
->regs
[i
]);
2677 shared_hash_destroy (dst
->vars
);
2678 dst
->vars
= shared_hash_copy (src
->vars
);
2679 dst
->stack_adjust
= src
->stack_adjust
;
2682 /* Information for merging lists of locations for a given offset of variable.
2684 struct variable_union_info
2686 /* Node of the location chain. */
2689 /* The sum of positions in the input chains. */
2692 /* The position in the chain of DST dataflow set. */
2696 /* Buffer for location list sorting and its allocated size. */
2697 static struct variable_union_info
*vui_vec
;
2698 static int vui_allocated
;
2700 /* Compare function for qsort, order the structures by POS element. */
2703 variable_union_info_cmp_pos (const void *n1
, const void *n2
)
2705 const struct variable_union_info
*const i1
=
2706 (const struct variable_union_info
*) n1
;
2707 const struct variable_union_info
*const i2
=
2708 ( const struct variable_union_info
*) n2
;
2710 if (i1
->pos
!= i2
->pos
)
2711 return i1
->pos
- i2
->pos
;
2713 return (i1
->pos_dst
- i2
->pos_dst
);
2716 /* Compute union of location parts of variable *SLOT and the same variable
2717 from hash table DATA. Compute "sorted" union of the location chains
2718 for common offsets, i.e. the locations of a variable part are sorted by
2719 a priority where the priority is the sum of the positions in the 2 chains
2720 (if a location is only in one list the position in the second list is
2721 defined to be larger than the length of the chains).
2722 When we are updating the location parts the newest location is in the
2723 beginning of the chain, so when we do the described "sorted" union
2724 we keep the newest locations in the beginning. */
2727 variable_union (variable
*src
, dataflow_set
*set
)
2733 dstp
= shared_hash_find_slot (set
->vars
, src
->dv
);
2734 if (!dstp
|| !*dstp
)
2738 dst_can_be_shared
= false;
2740 dstp
= shared_hash_find_slot_unshare (&set
->vars
, src
->dv
, INSERT
);
2744 /* Continue traversing the hash table. */
2750 gcc_assert (src
->n_var_parts
);
2751 gcc_checking_assert (src
->onepart
== dst
->onepart
);
2753 /* We can combine one-part variables very efficiently, because their
2754 entries are in canonical order. */
2757 location_chain
**nodep
, *dnode
, *snode
;
2759 gcc_assert (src
->n_var_parts
== 1
2760 && dst
->n_var_parts
== 1);
2762 snode
= src
->var_part
[0].loc_chain
;
2765 restart_onepart_unshared
:
2766 nodep
= &dst
->var_part
[0].loc_chain
;
2772 int r
= dnode
? loc_cmp (dnode
->loc
, snode
->loc
) : 1;
2776 location_chain
*nnode
;
2778 if (shared_var_p (dst
, set
->vars
))
2780 dstp
= unshare_variable (set
, dstp
, dst
,
2781 VAR_INIT_STATUS_INITIALIZED
);
2783 goto restart_onepart_unshared
;
2786 *nodep
= nnode
= new location_chain
;
2787 nnode
->loc
= snode
->loc
;
2788 nnode
->init
= snode
->init
;
2789 if (!snode
->set_src
|| MEM_P (snode
->set_src
))
2790 nnode
->set_src
= NULL
;
2792 nnode
->set_src
= snode
->set_src
;
2793 nnode
->next
= dnode
;
2797 gcc_checking_assert (rtx_equal_p (dnode
->loc
, snode
->loc
));
2800 snode
= snode
->next
;
2802 nodep
= &dnode
->next
;
2809 gcc_checking_assert (!src
->onepart
);
2811 /* Count the number of location parts, result is K. */
2812 for (i
= 0, j
= 0, k
= 0;
2813 i
< src
->n_var_parts
&& j
< dst
->n_var_parts
; k
++)
2815 if (VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2820 else if (VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
2825 k
+= src
->n_var_parts
- i
;
2826 k
+= dst
->n_var_parts
- j
;
2828 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2829 thus there are at most MAX_VAR_PARTS different offsets. */
2830 gcc_checking_assert (dst
->onepart
? k
== 1 : k
<= MAX_VAR_PARTS
);
2832 if (dst
->n_var_parts
!= k
&& shared_var_p (dst
, set
->vars
))
2834 dstp
= unshare_variable (set
, dstp
, dst
, VAR_INIT_STATUS_UNKNOWN
);
2838 i
= src
->n_var_parts
- 1;
2839 j
= dst
->n_var_parts
- 1;
2840 dst
->n_var_parts
= k
;
2842 for (k
--; k
>= 0; k
--)
2844 location_chain
*node
, *node2
;
2846 if (i
>= 0 && j
>= 0
2847 && VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2849 /* Compute the "sorted" union of the chains, i.e. the locations which
2850 are in both chains go first, they are sorted by the sum of
2851 positions in the chains. */
2854 struct variable_union_info
*vui
;
2856 /* If DST is shared compare the location chains.
2857 If they are different we will modify the chain in DST with
2858 high probability so make a copy of DST. */
2859 if (shared_var_p (dst
, set
->vars
))
2861 for (node
= src
->var_part
[i
].loc_chain
,
2862 node2
= dst
->var_part
[j
].loc_chain
; node
&& node2
;
2863 node
= node
->next
, node2
= node2
->next
)
2865 if (!((REG_P (node2
->loc
)
2866 && REG_P (node
->loc
)
2867 && REGNO (node2
->loc
) == REGNO (node
->loc
))
2868 || rtx_equal_p (node2
->loc
, node
->loc
)))
2870 if (node2
->init
< node
->init
)
2871 node2
->init
= node
->init
;
2877 dstp
= unshare_variable (set
, dstp
, dst
,
2878 VAR_INIT_STATUS_UNKNOWN
);
2879 dst
= (variable
*)*dstp
;
2884 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2887 for (node
= dst
->var_part
[j
].loc_chain
; node
; node
= node
->next
)
2892 /* The most common case, much simpler, no qsort is needed. */
2893 location_chain
*dstnode
= dst
->var_part
[j
].loc_chain
;
2894 dst
->var_part
[k
].loc_chain
= dstnode
;
2895 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
2897 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2898 if (!((REG_P (dstnode
->loc
)
2899 && REG_P (node
->loc
)
2900 && REGNO (dstnode
->loc
) == REGNO (node
->loc
))
2901 || rtx_equal_p (dstnode
->loc
, node
->loc
)))
2903 location_chain
*new_node
;
2905 /* Copy the location from SRC. */
2906 new_node
= new location_chain
;
2907 new_node
->loc
= node
->loc
;
2908 new_node
->init
= node
->init
;
2909 if (!node
->set_src
|| MEM_P (node
->set_src
))
2910 new_node
->set_src
= NULL
;
2912 new_node
->set_src
= node
->set_src
;
2913 node2
->next
= new_node
;
2920 if (src_l
+ dst_l
> vui_allocated
)
2922 vui_allocated
= MAX (vui_allocated
* 2, src_l
+ dst_l
);
2923 vui_vec
= XRESIZEVEC (struct variable_union_info
, vui_vec
,
2928 /* Fill in the locations from DST. */
2929 for (node
= dst
->var_part
[j
].loc_chain
, jj
= 0; node
;
2930 node
= node
->next
, jj
++)
2933 vui
[jj
].pos_dst
= jj
;
2935 /* Pos plus value larger than a sum of 2 valid positions. */
2936 vui
[jj
].pos
= jj
+ src_l
+ dst_l
;
2939 /* Fill in the locations from SRC. */
2941 for (node
= src
->var_part
[i
].loc_chain
, ii
= 0; node
;
2942 node
= node
->next
, ii
++)
2944 /* Find location from NODE. */
2945 for (jj
= 0; jj
< dst_l
; jj
++)
2947 if ((REG_P (vui
[jj
].lc
->loc
)
2948 && REG_P (node
->loc
)
2949 && REGNO (vui
[jj
].lc
->loc
) == REGNO (node
->loc
))
2950 || rtx_equal_p (vui
[jj
].lc
->loc
, node
->loc
))
2952 vui
[jj
].pos
= jj
+ ii
;
2956 if (jj
>= dst_l
) /* The location has not been found. */
2958 location_chain
*new_node
;
2960 /* Copy the location from SRC. */
2961 new_node
= new location_chain
;
2962 new_node
->loc
= node
->loc
;
2963 new_node
->init
= node
->init
;
2964 if (!node
->set_src
|| MEM_P (node
->set_src
))
2965 new_node
->set_src
= NULL
;
2967 new_node
->set_src
= node
->set_src
;
2968 vui
[n
].lc
= new_node
;
2969 vui
[n
].pos_dst
= src_l
+ dst_l
;
2970 vui
[n
].pos
= ii
+ src_l
+ dst_l
;
2977 /* Special case still very common case. For dst_l == 2
2978 all entries dst_l ... n-1 are sorted, with for i >= dst_l
2979 vui[i].pos == i + src_l + dst_l. */
2980 if (vui
[0].pos
> vui
[1].pos
)
2982 /* Order should be 1, 0, 2... */
2983 dst
->var_part
[k
].loc_chain
= vui
[1].lc
;
2984 vui
[1].lc
->next
= vui
[0].lc
;
2987 vui
[0].lc
->next
= vui
[2].lc
;
2988 vui
[n
- 1].lc
->next
= NULL
;
2991 vui
[0].lc
->next
= NULL
;
2996 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
2997 if (n
>= 3 && vui
[2].pos
< vui
[1].pos
)
2999 /* Order should be 0, 2, 1, 3... */
3000 vui
[0].lc
->next
= vui
[2].lc
;
3001 vui
[2].lc
->next
= vui
[1].lc
;
3004 vui
[1].lc
->next
= vui
[3].lc
;
3005 vui
[n
- 1].lc
->next
= NULL
;
3008 vui
[1].lc
->next
= NULL
;
3013 /* Order should be 0, 1, 2... */
3015 vui
[n
- 1].lc
->next
= NULL
;
3018 for (; ii
< n
; ii
++)
3019 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3023 qsort (vui
, n
, sizeof (struct variable_union_info
),
3024 variable_union_info_cmp_pos
);
3026 /* Reconnect the nodes in sorted order. */
3027 for (ii
= 1; ii
< n
; ii
++)
3028 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3029 vui
[n
- 1].lc
->next
= NULL
;
3030 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
3033 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
3038 else if ((i
>= 0 && j
>= 0
3039 && VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
3042 dst
->var_part
[k
] = dst
->var_part
[j
];
3045 else if ((i
>= 0 && j
>= 0
3046 && VAR_PART_OFFSET (src
, i
) > VAR_PART_OFFSET (dst
, j
))
3049 location_chain
**nextp
;
3051 /* Copy the chain from SRC. */
3052 nextp
= &dst
->var_part
[k
].loc_chain
;
3053 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3055 location_chain
*new_lc
;
3057 new_lc
= new location_chain
;
3058 new_lc
->next
= NULL
;
3059 new_lc
->init
= node
->init
;
3060 if (!node
->set_src
|| MEM_P (node
->set_src
))
3061 new_lc
->set_src
= NULL
;
3063 new_lc
->set_src
= node
->set_src
;
3064 new_lc
->loc
= node
->loc
;
3067 nextp
= &new_lc
->next
;
3070 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (src
, i
);
3073 dst
->var_part
[k
].cur_loc
= NULL
;
3076 if (flag_var_tracking_uninit
)
3077 for (i
= 0; i
< src
->n_var_parts
&& i
< dst
->n_var_parts
; i
++)
3079 location_chain
*node
, *node2
;
3080 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3081 for (node2
= dst
->var_part
[i
].loc_chain
; node2
; node2
= node2
->next
)
3082 if (rtx_equal_p (node
->loc
, node2
->loc
))
3084 if (node
->init
> node2
->init
)
3085 node2
->init
= node
->init
;
3089 /* Continue traversing the hash table. */
3093 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3096 dataflow_set_union (dataflow_set
*dst
, dataflow_set
*src
)
3100 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3101 attrs_list_union (&dst
->regs
[i
], src
->regs
[i
]);
3103 if (dst
->vars
== empty_shared_hash
)
3105 shared_hash_destroy (dst
->vars
);
3106 dst
->vars
= shared_hash_copy (src
->vars
);
3110 variable_iterator_type hi
;
3113 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src
->vars
),
3115 variable_union (var
, dst
);
3119 /* Whether the value is currently being expanded. */
3120 #define VALUE_RECURSED_INTO(x) \
3121 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3123 /* Whether no expansion was found, saving useless lookups.
3124 It must only be set when VALUE_CHANGED is clear. */
3125 #define NO_LOC_P(x) \
3126 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3128 /* Whether cur_loc in the value needs to be (re)computed. */
3129 #define VALUE_CHANGED(x) \
3130 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3131 /* Whether cur_loc in the decl needs to be (re)computed. */
3132 #define DECL_CHANGED(x) TREE_VISITED (x)
3134 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3135 user DECLs, this means they're in changed_variables. Values and
3136 debug exprs may be left with this flag set if no user variable
3137 requires them to be evaluated. */
3140 set_dv_changed (decl_or_value dv
, bool newv
)
3142 switch (dv_onepart_p (dv
))
3146 NO_LOC_P (dv_as_value (dv
)) = false;
3147 VALUE_CHANGED (dv_as_value (dv
)) = newv
;
3152 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv
))) = false;
3156 DECL_CHANGED (dv_as_decl (dv
)) = newv
;
3161 /* Return true if DV needs to have its cur_loc recomputed. */
3164 dv_changed_p (decl_or_value dv
)
3166 return (dv_is_value_p (dv
)
3167 ? VALUE_CHANGED (dv_as_value (dv
))
3168 : DECL_CHANGED (dv_as_decl (dv
)));
3171 /* Return a location list node whose loc is rtx_equal to LOC, in the
3172 location list of a one-part variable or value VAR, or in that of
3173 any values recursively mentioned in the location lists. VARS must
3174 be in star-canonical form. */
3176 static location_chain
*
3177 find_loc_in_1pdv (rtx loc
, variable
*var
, variable_table_type
*vars
)
3179 location_chain
*node
;
3180 enum rtx_code loc_code
;
3185 gcc_checking_assert (var
->onepart
);
3187 if (!var
->n_var_parts
)
3190 gcc_checking_assert (loc
!= dv_as_opaque (var
->dv
));
3192 loc_code
= GET_CODE (loc
);
3193 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3198 if (GET_CODE (node
->loc
) != loc_code
)
3200 if (GET_CODE (node
->loc
) != VALUE
)
3203 else if (loc
== node
->loc
)
3205 else if (loc_code
!= VALUE
)
3207 if (rtx_equal_p (loc
, node
->loc
))
3212 /* Since we're in star-canonical form, we don't need to visit
3213 non-canonical nodes: one-part variables and non-canonical
3214 values would only point back to the canonical node. */
3215 if (dv_is_value_p (var
->dv
)
3216 && !canon_value_cmp (node
->loc
, dv_as_value (var
->dv
)))
3218 /* Skip all subsequent VALUEs. */
3219 while (node
->next
&& GET_CODE (node
->next
->loc
) == VALUE
)
3222 gcc_checking_assert (!canon_value_cmp (node
->loc
,
3223 dv_as_value (var
->dv
)));
3224 if (loc
== node
->loc
)
3230 gcc_checking_assert (node
== var
->var_part
[0].loc_chain
);
3231 gcc_checking_assert (!node
->next
);
3233 dv
= dv_from_value (node
->loc
);
3234 rvar
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
3235 return find_loc_in_1pdv (loc
, rvar
, vars
);
3238 /* ??? Gotta look in cselib_val locations too. */
3243 /* Hash table iteration argument passed to variable_merge. */
3246 /* The set in which the merge is to be inserted. */
3248 /* The set that we're iterating in. */
3250 /* The set that may contain the other dv we are to merge with. */
3252 /* Number of onepart dvs in src. */
3253 int src_onepart_cnt
;
3256 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3257 loc_cmp order, and it is maintained as such. */
3260 insert_into_intersection (location_chain
**nodep
, rtx loc
,
3261 enum var_init_status status
)
3263 location_chain
*node
;
3266 for (node
= *nodep
; node
; nodep
= &node
->next
, node
= *nodep
)
3267 if ((r
= loc_cmp (node
->loc
, loc
)) == 0)
3269 node
->init
= MIN (node
->init
, status
);
3275 node
= new location_chain
;
3278 node
->set_src
= NULL
;
3279 node
->init
= status
;
3280 node
->next
= *nodep
;
3284 /* Insert in DEST the intersection of the locations present in both
3285 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3286 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3290 intersect_loc_chains (rtx val
, location_chain
**dest
, struct dfset_merge
*dsm
,
3291 location_chain
*s1node
, variable
*s2var
)
3293 dataflow_set
*s1set
= dsm
->cur
;
3294 dataflow_set
*s2set
= dsm
->src
;
3295 location_chain
*found
;
3299 location_chain
*s2node
;
3301 gcc_checking_assert (s2var
->onepart
);
3303 if (s2var
->n_var_parts
)
3305 s2node
= s2var
->var_part
[0].loc_chain
;
3307 for (; s1node
&& s2node
;
3308 s1node
= s1node
->next
, s2node
= s2node
->next
)
3309 if (s1node
->loc
!= s2node
->loc
)
3311 else if (s1node
->loc
== val
)
3314 insert_into_intersection (dest
, s1node
->loc
,
3315 MIN (s1node
->init
, s2node
->init
));
3319 for (; s1node
; s1node
= s1node
->next
)
3321 if (s1node
->loc
== val
)
3324 if ((found
= find_loc_in_1pdv (s1node
->loc
, s2var
,
3325 shared_hash_htab (s2set
->vars
))))
3327 insert_into_intersection (dest
, s1node
->loc
,
3328 MIN (s1node
->init
, found
->init
));
3332 if (GET_CODE (s1node
->loc
) == VALUE
3333 && !VALUE_RECURSED_INTO (s1node
->loc
))
3335 decl_or_value dv
= dv_from_value (s1node
->loc
);
3336 variable
*svar
= shared_hash_find (s1set
->vars
, dv
);
3339 if (svar
->n_var_parts
== 1)
3341 VALUE_RECURSED_INTO (s1node
->loc
) = true;
3342 intersect_loc_chains (val
, dest
, dsm
,
3343 svar
->var_part
[0].loc_chain
,
3345 VALUE_RECURSED_INTO (s1node
->loc
) = false;
3350 /* ??? gotta look in cselib_val locations too. */
3352 /* ??? if the location is equivalent to any location in src,
3353 searched recursively
3355 add to dst the values needed to represent the equivalence
3357 telling whether locations S is equivalent to another dv's
3360 for each location D in the list
3362 if S and D satisfy rtx_equal_p, then it is present
3364 else if D is a value, recurse without cycles
3366 else if S and D have the same CODE and MODE
3368 for each operand oS and the corresponding oD
3370 if oS and oD are not equivalent, then S an D are not equivalent
3372 else if they are RTX vectors
3374 if any vector oS element is not equivalent to its respective oD,
3375 then S and D are not equivalent
3383 /* Return -1 if X should be before Y in a location list for a 1-part
3384 variable, 1 if Y should be before X, and 0 if they're equivalent
3385 and should not appear in the list. */
3388 loc_cmp (rtx x
, rtx y
)
3391 RTX_CODE code
= GET_CODE (x
);
3401 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3402 if (REGNO (x
) == REGNO (y
))
3404 else if (REGNO (x
) < REGNO (y
))
3417 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3418 return loc_cmp (XEXP (x
, 0), XEXP (y
, 0));
3424 if (GET_CODE (x
) == VALUE
)
3426 if (GET_CODE (y
) != VALUE
)
3428 /* Don't assert the modes are the same, that is true only
3429 when not recursing. (subreg:QI (value:SI 1:1) 0)
3430 and (subreg:QI (value:DI 2:2) 0) can be compared,
3431 even when the modes are different. */
3432 if (canon_value_cmp (x
, y
))
3438 if (GET_CODE (y
) == VALUE
)
3441 /* Entry value is the least preferable kind of expression. */
3442 if (GET_CODE (x
) == ENTRY_VALUE
)
3444 if (GET_CODE (y
) != ENTRY_VALUE
)
3446 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3447 return loc_cmp (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
3450 if (GET_CODE (y
) == ENTRY_VALUE
)
3453 if (GET_CODE (x
) == GET_CODE (y
))
3454 /* Compare operands below. */;
3455 else if (GET_CODE (x
) < GET_CODE (y
))
3460 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3462 if (GET_CODE (x
) == DEBUG_EXPR
)
3464 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3465 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)))
3467 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3468 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)));
3472 fmt
= GET_RTX_FORMAT (code
);
3473 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
3477 if (XWINT (x
, i
) == XWINT (y
, i
))
3479 else if (XWINT (x
, i
) < XWINT (y
, i
))
3486 if (XINT (x
, i
) == XINT (y
, i
))
3488 else if (XINT (x
, i
) < XINT (y
, i
))
3495 /* Compare the vector length first. */
3496 if (XVECLEN (x
, i
) == XVECLEN (y
, i
))
3497 /* Compare the vectors elements. */;
3498 else if (XVECLEN (x
, i
) < XVECLEN (y
, i
))
3503 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3504 if ((r
= loc_cmp (XVECEXP (x
, i
, j
),
3505 XVECEXP (y
, i
, j
))))
3510 if ((r
= loc_cmp (XEXP (x
, i
), XEXP (y
, i
))))
3516 if (XSTR (x
, i
) == XSTR (y
, i
))
3522 if ((r
= strcmp (XSTR (x
, i
), XSTR (y
, i
))) == 0)
3530 /* These are just backpointers, so they don't matter. */
3537 /* It is believed that rtx's at this level will never
3538 contain anything but integers and other rtx's,
3539 except for within LABEL_REFs and SYMBOL_REFs. */
3543 if (CONST_WIDE_INT_P (x
))
3545 /* Compare the vector length first. */
3546 if (CONST_WIDE_INT_NUNITS (x
) >= CONST_WIDE_INT_NUNITS (y
))
3548 else if (CONST_WIDE_INT_NUNITS (x
) < CONST_WIDE_INT_NUNITS (y
))
3551 /* Compare the vectors elements. */;
3552 for (j
= CONST_WIDE_INT_NUNITS (x
) - 1; j
>= 0 ; j
--)
3554 if (CONST_WIDE_INT_ELT (x
, j
) < CONST_WIDE_INT_ELT (y
, j
))
3556 if (CONST_WIDE_INT_ELT (x
, j
) > CONST_WIDE_INT_ELT (y
, j
))
3564 /* Check the order of entries in one-part variables. */
3567 canonicalize_loc_order_check (variable
**slot
,
3568 dataflow_set
*data ATTRIBUTE_UNUSED
)
3570 variable
*var
= *slot
;
3571 location_chain
*node
, *next
;
3573 #ifdef ENABLE_RTL_CHECKING
3575 for (i
= 0; i
< var
->n_var_parts
; i
++)
3576 gcc_assert (var
->var_part
[0].cur_loc
== NULL
);
3577 gcc_assert (!var
->in_changed_variables
);
3583 gcc_assert (var
->n_var_parts
== 1);
3584 node
= var
->var_part
[0].loc_chain
;
3587 while ((next
= node
->next
))
3589 gcc_assert (loc_cmp (node
->loc
, next
->loc
) < 0);
3596 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3597 more likely to be chosen as canonical for an equivalence set.
3598 Ensure less likely values can reach more likely neighbors, making
3599 the connections bidirectional. */
3602 canonicalize_values_mark (variable
**slot
, dataflow_set
*set
)
3604 variable
*var
= *slot
;
3605 decl_or_value dv
= var
->dv
;
3607 location_chain
*node
;
3609 if (!dv_is_value_p (dv
))
3612 gcc_checking_assert (var
->n_var_parts
== 1);
3614 val
= dv_as_value (dv
);
3616 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3617 if (GET_CODE (node
->loc
) == VALUE
)
3619 if (canon_value_cmp (node
->loc
, val
))
3620 VALUE_RECURSED_INTO (val
) = true;
3623 decl_or_value odv
= dv_from_value (node
->loc
);
3625 oslot
= shared_hash_find_slot_noinsert (set
->vars
, odv
);
3627 set_slot_part (set
, val
, oslot
, odv
, 0,
3628 node
->init
, NULL_RTX
);
3630 VALUE_RECURSED_INTO (node
->loc
) = true;
3637 /* Remove redundant entries from equivalence lists in onepart
3638 variables, canonicalizing equivalence sets into star shapes. */
3641 canonicalize_values_star (variable
**slot
, dataflow_set
*set
)
3643 variable
*var
= *slot
;
3644 decl_or_value dv
= var
->dv
;
3645 location_chain
*node
;
3655 gcc_checking_assert (var
->n_var_parts
== 1);
3657 if (dv_is_value_p (dv
))
3659 cval
= dv_as_value (dv
);
3660 if (!VALUE_RECURSED_INTO (cval
))
3662 VALUE_RECURSED_INTO (cval
) = false;
3672 gcc_assert (var
->n_var_parts
== 1);
3674 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3675 if (GET_CODE (node
->loc
) == VALUE
)
3678 if (VALUE_RECURSED_INTO (node
->loc
))
3680 if (canon_value_cmp (node
->loc
, cval
))
3689 if (!has_marks
|| dv_is_decl_p (dv
))
3692 /* Keep it marked so that we revisit it, either after visiting a
3693 child node, or after visiting a new parent that might be
3695 VALUE_RECURSED_INTO (val
) = true;
3697 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3698 if (GET_CODE (node
->loc
) == VALUE
3699 && VALUE_RECURSED_INTO (node
->loc
))
3703 VALUE_RECURSED_INTO (cval
) = false;
3704 dv
= dv_from_value (cval
);
3705 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
3708 gcc_assert (dv_is_decl_p (var
->dv
));
3709 /* The canonical value was reset and dropped.
3711 clobber_variable_part (set
, NULL
, var
->dv
, 0, NULL
);
3715 gcc_assert (dv_is_value_p (var
->dv
));
3716 if (var
->n_var_parts
== 0)
3718 gcc_assert (var
->n_var_parts
== 1);
3722 VALUE_RECURSED_INTO (val
) = false;
3727 /* Push values to the canonical one. */
3728 cdv
= dv_from_value (cval
);
3729 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3731 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3732 if (node
->loc
!= cval
)
3734 cslot
= set_slot_part (set
, node
->loc
, cslot
, cdv
, 0,
3735 node
->init
, NULL_RTX
);
3736 if (GET_CODE (node
->loc
) == VALUE
)
3738 decl_or_value ndv
= dv_from_value (node
->loc
);
3740 set_variable_part (set
, cval
, ndv
, 0, node
->init
, NULL_RTX
,
3743 if (canon_value_cmp (node
->loc
, val
))
3745 /* If it could have been a local minimum, it's not any more,
3746 since it's now neighbor to cval, so it may have to push
3747 to it. Conversely, if it wouldn't have prevailed over
3748 val, then whatever mark it has is fine: if it was to
3749 push, it will now push to a more canonical node, but if
3750 it wasn't, then it has already pushed any values it might
3752 VALUE_RECURSED_INTO (node
->loc
) = true;
3753 /* Make sure we visit node->loc by ensuring we cval is
3755 VALUE_RECURSED_INTO (cval
) = true;
3757 else if (!VALUE_RECURSED_INTO (node
->loc
))
3758 /* If we have no need to "recurse" into this node, it's
3759 already "canonicalized", so drop the link to the old
3761 clobber_variable_part (set
, cval
, ndv
, 0, NULL
);
3763 else if (GET_CODE (node
->loc
) == REG
)
3765 attrs
*list
= set
->regs
[REGNO (node
->loc
)], **listp
;
3767 /* Change an existing attribute referring to dv so that it
3768 refers to cdv, removing any duplicate this might
3769 introduce, and checking that no previous duplicates
3770 existed, all in a single pass. */
3774 if (list
->offset
== 0
3775 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3776 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3783 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3786 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3791 if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3793 *listp
= list
->next
;
3799 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (dv
));
3802 else if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3804 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3809 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3811 *listp
= list
->next
;
3817 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (cdv
));
3826 if (list
->offset
== 0
3827 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3828 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3837 set_slot_part (set
, val
, cslot
, cdv
, 0,
3838 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
);
3840 slot
= clobber_slot_part (set
, cval
, slot
, 0, NULL
);
3842 /* Variable may have been unshared. */
3844 gcc_checking_assert (var
->n_var_parts
&& var
->var_part
[0].loc_chain
->loc
== cval
3845 && var
->var_part
[0].loc_chain
->next
== NULL
);
3847 if (VALUE_RECURSED_INTO (cval
))
3848 goto restart_with_cval
;
3853 /* Bind one-part variables to the canonical value in an equivalence
3854 set. Not doing this causes dataflow convergence failure in rare
3855 circumstances, see PR42873. Unfortunately we can't do this
3856 efficiently as part of canonicalize_values_star, since we may not
3857 have determined or even seen the canonical value of a set when we
3858 get to a variable that references another member of the set. */
3861 canonicalize_vars_star (variable
**slot
, dataflow_set
*set
)
3863 variable
*var
= *slot
;
3864 decl_or_value dv
= var
->dv
;
3865 location_chain
*node
;
3870 location_chain
*cnode
;
3872 if (!var
->onepart
|| var
->onepart
== ONEPART_VALUE
)
3875 gcc_assert (var
->n_var_parts
== 1);
3877 node
= var
->var_part
[0].loc_chain
;
3879 if (GET_CODE (node
->loc
) != VALUE
)
3882 gcc_assert (!node
->next
);
3885 /* Push values to the canonical one. */
3886 cdv
= dv_from_value (cval
);
3887 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3891 gcc_assert (cvar
->n_var_parts
== 1);
3893 cnode
= cvar
->var_part
[0].loc_chain
;
3895 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3896 that are not “more canonical” than it. */
3897 if (GET_CODE (cnode
->loc
) != VALUE
3898 || !canon_value_cmp (cnode
->loc
, cval
))
3901 /* CVAL was found to be non-canonical. Change the variable to point
3902 to the canonical VALUE. */
3903 gcc_assert (!cnode
->next
);
3906 slot
= set_slot_part (set
, cval
, slot
, dv
, 0,
3907 node
->init
, node
->set_src
);
3908 clobber_slot_part (set
, cval
, slot
, 0, node
->set_src
);
3913 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3914 corresponding entry in DSM->src. Multi-part variables are combined
3915 with variable_union, whereas onepart dvs are combined with
3919 variable_merge_over_cur (variable
*s1var
, struct dfset_merge
*dsm
)
3921 dataflow_set
*dst
= dsm
->dst
;
3923 variable
*s2var
, *dvar
= NULL
;
3924 decl_or_value dv
= s1var
->dv
;
3925 onepart_enum onepart
= s1var
->onepart
;
3928 location_chain
*node
, **nodep
;
3930 /* If the incoming onepart variable has an empty location list, then
3931 the intersection will be just as empty. For other variables,
3932 it's always union. */
3933 gcc_checking_assert (s1var
->n_var_parts
3934 && s1var
->var_part
[0].loc_chain
);
3937 return variable_union (s1var
, dst
);
3939 gcc_checking_assert (s1var
->n_var_parts
== 1);
3941 dvhash
= dv_htab_hash (dv
);
3942 if (dv_is_value_p (dv
))
3943 val
= dv_as_value (dv
);
3947 s2var
= shared_hash_find_1 (dsm
->src
->vars
, dv
, dvhash
);
3950 dst_can_be_shared
= false;
3954 dsm
->src_onepart_cnt
--;
3955 gcc_assert (s2var
->var_part
[0].loc_chain
3956 && s2var
->onepart
== onepart
3957 && s2var
->n_var_parts
== 1);
3959 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
3963 gcc_assert (dvar
->refcount
== 1
3964 && dvar
->onepart
== onepart
3965 && dvar
->n_var_parts
== 1);
3966 nodep
= &dvar
->var_part
[0].loc_chain
;
3974 if (!dstslot
&& !onepart_variable_different_p (s1var
, s2var
))
3976 dstslot
= shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
,
3978 *dstslot
= dvar
= s2var
;
3983 dst_can_be_shared
= false;
3985 intersect_loc_chains (val
, nodep
, dsm
,
3986 s1var
->var_part
[0].loc_chain
, s2var
);
3992 dvar
= onepart_pool_allocate (onepart
);
3995 dvar
->n_var_parts
= 1;
3996 dvar
->onepart
= onepart
;
3997 dvar
->in_changed_variables
= false;
3998 dvar
->var_part
[0].loc_chain
= node
;
3999 dvar
->var_part
[0].cur_loc
= NULL
;
4001 VAR_LOC_1PAUX (dvar
) = NULL
;
4003 VAR_PART_OFFSET (dvar
, 0) = 0;
4006 = shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
, dvhash
,
4008 gcc_assert (!*dstslot
);
4016 nodep
= &dvar
->var_part
[0].loc_chain
;
4017 while ((node
= *nodep
))
4019 location_chain
**nextp
= &node
->next
;
4021 if (GET_CODE (node
->loc
) == REG
)
4025 for (list
= dst
->regs
[REGNO (node
->loc
)]; list
; list
= list
->next
)
4026 if (GET_MODE (node
->loc
) == GET_MODE (list
->loc
)
4027 && dv_is_value_p (list
->dv
))
4031 attrs_list_insert (&dst
->regs
[REGNO (node
->loc
)],
4033 /* If this value became canonical for another value that had
4034 this register, we want to leave it alone. */
4035 else if (dv_as_value (list
->dv
) != val
)
4037 dstslot
= set_slot_part (dst
, dv_as_value (list
->dv
),
4039 node
->init
, NULL_RTX
);
4040 dstslot
= delete_slot_part (dst
, node
->loc
, dstslot
, 0);
4042 /* Since nextp points into the removed node, we can't
4043 use it. The pointer to the next node moved to nodep.
4044 However, if the variable we're walking is unshared
4045 during our walk, we'll keep walking the location list
4046 of the previously-shared variable, in which case the
4047 node won't have been removed, and we'll want to skip
4048 it. That's why we test *nodep here. */
4054 /* Canonicalization puts registers first, so we don't have to
4060 if (dvar
!= *dstslot
)
4062 nodep
= &dvar
->var_part
[0].loc_chain
;
4066 /* Mark all referenced nodes for canonicalization, and make sure
4067 we have mutual equivalence links. */
4068 VALUE_RECURSED_INTO (val
) = true;
4069 for (node
= *nodep
; node
; node
= node
->next
)
4070 if (GET_CODE (node
->loc
) == VALUE
)
4072 VALUE_RECURSED_INTO (node
->loc
) = true;
4073 set_variable_part (dst
, val
, dv_from_value (node
->loc
), 0,
4074 node
->init
, NULL
, INSERT
);
4077 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4078 gcc_assert (*dstslot
== dvar
);
4079 canonicalize_values_star (dstslot
, dst
);
4080 gcc_checking_assert (dstslot
4081 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4087 bool has_value
= false, has_other
= false;
4089 /* If we have one value and anything else, we're going to
4090 canonicalize this, so make sure all values have an entry in
4091 the table and are marked for canonicalization. */
4092 for (node
= *nodep
; node
; node
= node
->next
)
4094 if (GET_CODE (node
->loc
) == VALUE
)
4096 /* If this was marked during register canonicalization,
4097 we know we have to canonicalize values. */
4112 if (has_value
&& has_other
)
4114 for (node
= *nodep
; node
; node
= node
->next
)
4116 if (GET_CODE (node
->loc
) == VALUE
)
4118 decl_or_value dv
= dv_from_value (node
->loc
);
4119 variable
**slot
= NULL
;
4121 if (shared_hash_shared (dst
->vars
))
4122 slot
= shared_hash_find_slot_noinsert (dst
->vars
, dv
);
4124 slot
= shared_hash_find_slot_unshare (&dst
->vars
, dv
,
4128 variable
*var
= onepart_pool_allocate (ONEPART_VALUE
);
4131 var
->n_var_parts
= 1;
4132 var
->onepart
= ONEPART_VALUE
;
4133 var
->in_changed_variables
= false;
4134 var
->var_part
[0].loc_chain
= NULL
;
4135 var
->var_part
[0].cur_loc
= NULL
;
4136 VAR_LOC_1PAUX (var
) = NULL
;
4140 VALUE_RECURSED_INTO (node
->loc
) = true;
4144 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4145 gcc_assert (*dstslot
== dvar
);
4146 canonicalize_values_star (dstslot
, dst
);
4147 gcc_checking_assert (dstslot
4148 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4154 if (!onepart_variable_different_p (dvar
, s2var
))
4156 variable_htab_free (dvar
);
4157 *dstslot
= dvar
= s2var
;
4160 else if (s2var
!= s1var
&& !onepart_variable_different_p (dvar
, s1var
))
4162 variable_htab_free (dvar
);
4163 *dstslot
= dvar
= s1var
;
4165 dst_can_be_shared
= false;
4168 dst_can_be_shared
= false;
4173 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4174 multi-part variable. Unions of multi-part variables and
4175 intersections of one-part ones will be handled in
4176 variable_merge_over_cur(). */
4179 variable_merge_over_src (variable
*s2var
, struct dfset_merge
*dsm
)
4181 dataflow_set
*dst
= dsm
->dst
;
4182 decl_or_value dv
= s2var
->dv
;
4184 if (!s2var
->onepart
)
4186 variable
**dstp
= shared_hash_find_slot (dst
->vars
, dv
);
4192 dsm
->src_onepart_cnt
++;
4196 /* Combine dataflow set information from SRC2 into DST, using PDST
4197 to carry over information across passes. */
4200 dataflow_set_merge (dataflow_set
*dst
, dataflow_set
*src2
)
4202 dataflow_set cur
= *dst
;
4203 dataflow_set
*src1
= &cur
;
4204 struct dfset_merge dsm
;
4206 size_t src1_elems
, src2_elems
;
4207 variable_iterator_type hi
;
4210 src1_elems
= shared_hash_htab (src1
->vars
)->elements ();
4211 src2_elems
= shared_hash_htab (src2
->vars
)->elements ();
4212 dataflow_set_init (dst
);
4213 dst
->stack_adjust
= cur
.stack_adjust
;
4214 shared_hash_destroy (dst
->vars
);
4215 dst
->vars
= new shared_hash
;
4216 dst
->vars
->refcount
= 1;
4217 dst
->vars
->htab
= new variable_table_type (MAX (src1_elems
, src2_elems
));
4219 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4220 attrs_list_mpdv_union (&dst
->regs
[i
], src1
->regs
[i
], src2
->regs
[i
]);
4225 dsm
.src_onepart_cnt
= 0;
4227 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm
.src
->vars
),
4229 variable_merge_over_src (var
, &dsm
);
4230 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm
.cur
->vars
),
4232 variable_merge_over_cur (var
, &dsm
);
4234 if (dsm
.src_onepart_cnt
)
4235 dst_can_be_shared
= false;
4237 dataflow_set_destroy (src1
);
4240 /* Mark register equivalences. */
4243 dataflow_set_equiv_regs (dataflow_set
*set
)
4246 attrs
*list
, **listp
;
4248 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4250 rtx canon
[NUM_MACHINE_MODES
];
4252 /* If the list is empty or one entry, no need to canonicalize
4254 if (set
->regs
[i
] == NULL
|| set
->regs
[i
]->next
== NULL
)
4257 memset (canon
, 0, sizeof (canon
));
4259 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4260 if (list
->offset
== 0 && dv_is_value_p (list
->dv
))
4262 rtx val
= dv_as_value (list
->dv
);
4263 rtx
*cvalp
= &canon
[(int)GET_MODE (val
)];
4266 if (canon_value_cmp (val
, cval
))
4270 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4271 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4273 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4278 if (dv_is_value_p (list
->dv
))
4280 rtx val
= dv_as_value (list
->dv
);
4285 VALUE_RECURSED_INTO (val
) = true;
4286 set_variable_part (set
, val
, dv_from_value (cval
), 0,
4287 VAR_INIT_STATUS_INITIALIZED
,
4291 VALUE_RECURSED_INTO (cval
) = true;
4292 set_variable_part (set
, cval
, list
->dv
, 0,
4293 VAR_INIT_STATUS_INITIALIZED
, NULL
, NO_INSERT
);
4296 for (listp
= &set
->regs
[i
]; (list
= *listp
);
4297 listp
= list
? &list
->next
: listp
)
4298 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4300 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4306 if (dv_is_value_p (list
->dv
))
4308 rtx val
= dv_as_value (list
->dv
);
4309 if (!VALUE_RECURSED_INTO (val
))
4313 slot
= shared_hash_find_slot_noinsert (set
->vars
, list
->dv
);
4314 canonicalize_values_star (slot
, set
);
4321 /* Remove any redundant values in the location list of VAR, which must
4322 be unshared and 1-part. */
4325 remove_duplicate_values (variable
*var
)
4327 location_chain
*node
, **nodep
;
4329 gcc_assert (var
->onepart
);
4330 gcc_assert (var
->n_var_parts
== 1);
4331 gcc_assert (var
->refcount
== 1);
4333 for (nodep
= &var
->var_part
[0].loc_chain
; (node
= *nodep
); )
4335 if (GET_CODE (node
->loc
) == VALUE
)
4337 if (VALUE_RECURSED_INTO (node
->loc
))
4339 /* Remove duplicate value node. */
4340 *nodep
= node
->next
;
4345 VALUE_RECURSED_INTO (node
->loc
) = true;
4347 nodep
= &node
->next
;
4350 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4351 if (GET_CODE (node
->loc
) == VALUE
)
4353 gcc_assert (VALUE_RECURSED_INTO (node
->loc
));
4354 VALUE_RECURSED_INTO (node
->loc
) = false;
4359 /* Hash table iteration argument passed to variable_post_merge. */
4360 struct dfset_post_merge
4362 /* The new input set for the current block. */
4364 /* Pointer to the permanent input set for the current block, or
4366 dataflow_set
**permp
;
4369 /* Create values for incoming expressions associated with one-part
4370 variables that don't have value numbers for them. */
4373 variable_post_merge_new_vals (variable
**slot
, dfset_post_merge
*dfpm
)
4375 dataflow_set
*set
= dfpm
->set
;
4376 variable
*var
= *slot
;
4377 location_chain
*node
;
4379 if (!var
->onepart
|| !var
->n_var_parts
)
4382 gcc_assert (var
->n_var_parts
== 1);
4384 if (dv_is_decl_p (var
->dv
))
4386 bool check_dupes
= false;
4389 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4391 if (GET_CODE (node
->loc
) == VALUE
)
4392 gcc_assert (!VALUE_RECURSED_INTO (node
->loc
));
4393 else if (GET_CODE (node
->loc
) == REG
)
4395 attrs
*att
, **attp
, **curp
= NULL
;
4397 if (var
->refcount
!= 1)
4399 slot
= unshare_variable (set
, slot
, var
,
4400 VAR_INIT_STATUS_INITIALIZED
);
4405 for (attp
= &set
->regs
[REGNO (node
->loc
)]; (att
= *attp
);
4407 if (att
->offset
== 0
4408 && GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4410 if (dv_is_value_p (att
->dv
))
4412 rtx cval
= dv_as_value (att
->dv
);
4417 else if (dv_as_opaque (att
->dv
) == dv_as_opaque (var
->dv
))
4425 if ((*curp
)->offset
== 0
4426 && GET_MODE ((*curp
)->loc
) == GET_MODE (node
->loc
)
4427 && dv_as_opaque ((*curp
)->dv
) == dv_as_opaque (var
->dv
))
4430 curp
= &(*curp
)->next
;
4441 *dfpm
->permp
= XNEW (dataflow_set
);
4442 dataflow_set_init (*dfpm
->permp
);
4445 for (att
= (*dfpm
->permp
)->regs
[REGNO (node
->loc
)];
4446 att
; att
= att
->next
)
4447 if (GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4449 gcc_assert (att
->offset
== 0
4450 && dv_is_value_p (att
->dv
));
4451 val_reset (set
, att
->dv
);
4458 cval
= dv_as_value (cdv
);
4462 /* Create a unique value to hold this register,
4463 that ought to be found and reused in
4464 subsequent rounds. */
4466 gcc_assert (!cselib_lookup (node
->loc
,
4467 GET_MODE (node
->loc
), 0,
4469 v
= cselib_lookup (node
->loc
, GET_MODE (node
->loc
), 1,
4471 cselib_preserve_value (v
);
4472 cselib_invalidate_rtx (node
->loc
);
4474 cdv
= dv_from_value (cval
);
4477 "Created new value %u:%u for reg %i\n",
4478 v
->uid
, v
->hash
, REGNO (node
->loc
));
4481 var_reg_decl_set (*dfpm
->permp
, node
->loc
,
4482 VAR_INIT_STATUS_INITIALIZED
,
4483 cdv
, 0, NULL
, INSERT
);
4489 /* Remove attribute referring to the decl, which now
4490 uses the value for the register, already existing or
4491 to be added when we bring perm in. */
4499 remove_duplicate_values (var
);
4505 /* Reset values in the permanent set that are not associated with the
4506 chosen expression. */
4509 variable_post_merge_perm_vals (variable
**pslot
, dfset_post_merge
*dfpm
)
4511 dataflow_set
*set
= dfpm
->set
;
4512 variable
*pvar
= *pslot
, *var
;
4513 location_chain
*pnode
;
4517 gcc_assert (dv_is_value_p (pvar
->dv
)
4518 && pvar
->n_var_parts
== 1);
4519 pnode
= pvar
->var_part
[0].loc_chain
;
4522 && REG_P (pnode
->loc
));
4526 var
= shared_hash_find (set
->vars
, dv
);
4529 /* Although variable_post_merge_new_vals may have made decls
4530 non-star-canonical, values that pre-existed in canonical form
4531 remain canonical, and newly-created values reference a single
4532 REG, so they are canonical as well. Since VAR has the
4533 location list for a VALUE, using find_loc_in_1pdv for it is
4534 fine, since VALUEs don't map back to DECLs. */
4535 if (find_loc_in_1pdv (pnode
->loc
, var
, shared_hash_htab (set
->vars
)))
4537 val_reset (set
, dv
);
4540 for (att
= set
->regs
[REGNO (pnode
->loc
)]; att
; att
= att
->next
)
4541 if (att
->offset
== 0
4542 && GET_MODE (att
->loc
) == GET_MODE (pnode
->loc
)
4543 && dv_is_value_p (att
->dv
))
4546 /* If there is a value associated with this register already, create
4548 if (att
&& dv_as_value (att
->dv
) != dv_as_value (dv
))
4550 rtx cval
= dv_as_value (att
->dv
);
4551 set_variable_part (set
, cval
, dv
, 0, pnode
->init
, NULL
, INSERT
);
4552 set_variable_part (set
, dv_as_value (dv
), att
->dv
, 0, pnode
->init
,
4557 attrs_list_insert (&set
->regs
[REGNO (pnode
->loc
)],
4559 variable_union (pvar
, set
);
4565 /* Just checking stuff and registering register attributes for
4569 dataflow_post_merge_adjust (dataflow_set
*set
, dataflow_set
**permp
)
4571 struct dfset_post_merge dfpm
;
4576 shared_hash_htab (set
->vars
)
4577 ->traverse
<dfset_post_merge
*, variable_post_merge_new_vals
> (&dfpm
);
4579 shared_hash_htab ((*permp
)->vars
)
4580 ->traverse
<dfset_post_merge
*, variable_post_merge_perm_vals
> (&dfpm
);
4581 shared_hash_htab (set
->vars
)
4582 ->traverse
<dataflow_set
*, canonicalize_values_star
> (set
);
4583 shared_hash_htab (set
->vars
)
4584 ->traverse
<dataflow_set
*, canonicalize_vars_star
> (set
);
4587 /* Return a node whose loc is a MEM that refers to EXPR in the
4588 location list of a one-part variable or value VAR, or in that of
4589 any values recursively mentioned in the location lists. */
4591 static location_chain
*
4592 find_mem_expr_in_1pdv (tree expr
, rtx val
, variable_table_type
*vars
)
4594 location_chain
*node
;
4597 location_chain
*where
= NULL
;
4602 gcc_assert (GET_CODE (val
) == VALUE
4603 && !VALUE_RECURSED_INTO (val
));
4605 dv
= dv_from_value (val
);
4606 var
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
4611 gcc_assert (var
->onepart
);
4613 if (!var
->n_var_parts
)
4616 VALUE_RECURSED_INTO (val
) = true;
4618 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4619 if (MEM_P (node
->loc
)
4620 && MEM_EXPR (node
->loc
) == expr
4621 && INT_MEM_OFFSET (node
->loc
) == 0)
4626 else if (GET_CODE (node
->loc
) == VALUE
4627 && !VALUE_RECURSED_INTO (node
->loc
)
4628 && (where
= find_mem_expr_in_1pdv (expr
, node
->loc
, vars
)))
4631 VALUE_RECURSED_INTO (val
) = false;
4636 /* Return TRUE if the value of MEM may vary across a call. */
4639 mem_dies_at_call (rtx mem
)
4641 tree expr
= MEM_EXPR (mem
);
4647 decl
= get_base_address (expr
);
4655 return (may_be_aliased (decl
)
4656 || (!TREE_READONLY (decl
) && is_global_var (decl
)));
4659 /* Remove all MEMs from the location list of a hash table entry for a
4660 one-part variable, except those whose MEM attributes map back to
4661 the variable itself, directly or within a VALUE. */
4664 dataflow_set_preserve_mem_locs (variable
**slot
, dataflow_set
*set
)
4666 variable
*var
= *slot
;
4668 if (var
->onepart
== ONEPART_VDECL
|| var
->onepart
== ONEPART_DEXPR
)
4670 tree decl
= dv_as_decl (var
->dv
);
4671 location_chain
*loc
, **locp
;
4672 bool changed
= false;
4674 if (!var
->n_var_parts
)
4677 gcc_assert (var
->n_var_parts
== 1);
4679 if (shared_var_p (var
, set
->vars
))
4681 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4683 /* We want to remove dying MEMs that don't refer to DECL. */
4684 if (GET_CODE (loc
->loc
) == MEM
4685 && (MEM_EXPR (loc
->loc
) != decl
4686 || INT_MEM_OFFSET (loc
->loc
) != 0)
4687 && mem_dies_at_call (loc
->loc
))
4689 /* We want to move here MEMs that do refer to DECL. */
4690 else if (GET_CODE (loc
->loc
) == VALUE
4691 && find_mem_expr_in_1pdv (decl
, loc
->loc
,
4692 shared_hash_htab (set
->vars
)))
4699 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4701 gcc_assert (var
->n_var_parts
== 1);
4704 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4707 rtx old_loc
= loc
->loc
;
4708 if (GET_CODE (old_loc
) == VALUE
)
4710 location_chain
*mem_node
4711 = find_mem_expr_in_1pdv (decl
, loc
->loc
,
4712 shared_hash_htab (set
->vars
));
4714 /* ??? This picks up only one out of multiple MEMs that
4715 refer to the same variable. Do we ever need to be
4716 concerned about dealing with more than one, or, given
4717 that they should all map to the same variable
4718 location, their addresses will have been merged and
4719 they will be regarded as equivalent? */
4722 loc
->loc
= mem_node
->loc
;
4723 loc
->set_src
= mem_node
->set_src
;
4724 loc
->init
= MIN (loc
->init
, mem_node
->init
);
4728 if (GET_CODE (loc
->loc
) != MEM
4729 || (MEM_EXPR (loc
->loc
) == decl
4730 && INT_MEM_OFFSET (loc
->loc
) == 0)
4731 || !mem_dies_at_call (loc
->loc
))
4733 if (old_loc
!= loc
->loc
&& emit_notes
)
4735 if (old_loc
== var
->var_part
[0].cur_loc
)
4738 var
->var_part
[0].cur_loc
= NULL
;
4747 if (old_loc
== var
->var_part
[0].cur_loc
)
4750 var
->var_part
[0].cur_loc
= NULL
;
4757 if (!var
->var_part
[0].loc_chain
)
4763 variable_was_changed (var
, set
);
4769 /* Remove all MEMs from the location list of a hash table entry for a
4770 onepart variable. */
4773 dataflow_set_remove_mem_locs (variable
**slot
, dataflow_set
*set
)
4775 variable
*var
= *slot
;
4777 if (var
->onepart
!= NOT_ONEPART
)
4779 location_chain
*loc
, **locp
;
4780 bool changed
= false;
4783 gcc_assert (var
->n_var_parts
== 1);
4785 if (shared_var_p (var
, set
->vars
))
4787 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4788 if (GET_CODE (loc
->loc
) == MEM
4789 && mem_dies_at_call (loc
->loc
))
4795 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4797 gcc_assert (var
->n_var_parts
== 1);
4800 if (VAR_LOC_1PAUX (var
))
4801 cur_loc
= VAR_LOC_FROM (var
);
4803 cur_loc
= var
->var_part
[0].cur_loc
;
4805 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4808 if (GET_CODE (loc
->loc
) != MEM
4809 || !mem_dies_at_call (loc
->loc
))
4816 /* If we have deleted the location which was last emitted
4817 we have to emit new location so add the variable to set
4818 of changed variables. */
4819 if (cur_loc
== loc
->loc
)
4822 var
->var_part
[0].cur_loc
= NULL
;
4823 if (VAR_LOC_1PAUX (var
))
4824 VAR_LOC_FROM (var
) = NULL
;
4829 if (!var
->var_part
[0].loc_chain
)
4835 variable_was_changed (var
, set
);
4841 /* Remove all variable-location information about call-clobbered
4842 registers, as well as associations between MEMs and VALUEs. */
4845 dataflow_set_clear_at_call (dataflow_set
*set
, rtx_insn
*call_insn
)
4848 hard_reg_set_iterator hrsi
;
4849 HARD_REG_SET invalidated_regs
;
4851 get_call_reg_set_usage (call_insn
, &invalidated_regs
,
4852 regs_invalidated_by_call
);
4854 EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs
, 0, r
, hrsi
)
4855 var_regno_delete (set
, r
);
4857 if (MAY_HAVE_DEBUG_INSNS
)
4859 set
->traversed_vars
= set
->vars
;
4860 shared_hash_htab (set
->vars
)
4861 ->traverse
<dataflow_set
*, dataflow_set_preserve_mem_locs
> (set
);
4862 set
->traversed_vars
= set
->vars
;
4863 shared_hash_htab (set
->vars
)
4864 ->traverse
<dataflow_set
*, dataflow_set_remove_mem_locs
> (set
);
4865 set
->traversed_vars
= NULL
;
4870 variable_part_different_p (variable_part
*vp1
, variable_part
*vp2
)
4872 location_chain
*lc1
, *lc2
;
4874 for (lc1
= vp1
->loc_chain
; lc1
; lc1
= lc1
->next
)
4876 for (lc2
= vp2
->loc_chain
; lc2
; lc2
= lc2
->next
)
4878 if (REG_P (lc1
->loc
) && REG_P (lc2
->loc
))
4880 if (REGNO (lc1
->loc
) == REGNO (lc2
->loc
))
4883 if (rtx_equal_p (lc1
->loc
, lc2
->loc
))
4892 /* Return true if one-part variables VAR1 and VAR2 are different.
4893 They must be in canonical order. */
4896 onepart_variable_different_p (variable
*var1
, variable
*var2
)
4898 location_chain
*lc1
, *lc2
;
4903 gcc_assert (var1
->n_var_parts
== 1
4904 && var2
->n_var_parts
== 1);
4906 lc1
= var1
->var_part
[0].loc_chain
;
4907 lc2
= var2
->var_part
[0].loc_chain
;
4909 gcc_assert (lc1
&& lc2
);
4913 if (loc_cmp (lc1
->loc
, lc2
->loc
))
4922 /* Return true if one-part variables VAR1 and VAR2 are different.
4923 They must be in canonical order. */
4926 dump_onepart_variable_differences (variable
*var1
, variable
*var2
)
4928 location_chain
*lc1
, *lc2
;
4930 gcc_assert (var1
!= var2
);
4931 gcc_assert (dump_file
);
4932 gcc_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
));
4933 gcc_assert (var1
->n_var_parts
== 1
4934 && var2
->n_var_parts
== 1);
4936 lc1
= var1
->var_part
[0].loc_chain
;
4937 lc2
= var2
->var_part
[0].loc_chain
;
4939 gcc_assert (lc1
&& lc2
);
4943 switch (loc_cmp (lc1
->loc
, lc2
->loc
))
4946 fprintf (dump_file
, "removed: ");
4947 print_rtl_single (dump_file
, lc1
->loc
);
4953 fprintf (dump_file
, "added: ");
4954 print_rtl_single (dump_file
, lc2
->loc
);
4966 fprintf (dump_file
, "removed: ");
4967 print_rtl_single (dump_file
, lc1
->loc
);
4973 fprintf (dump_file
, "added: ");
4974 print_rtl_single (dump_file
, lc2
->loc
);
4979 /* Return true if variables VAR1 and VAR2 are different. */
4982 variable_different_p (variable
*var1
, variable
*var2
)
4989 if (var1
->onepart
!= var2
->onepart
)
4992 if (var1
->n_var_parts
!= var2
->n_var_parts
)
4995 if (var1
->onepart
&& var1
->n_var_parts
)
4997 gcc_checking_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
)
4998 && var1
->n_var_parts
== 1);
4999 /* One-part values have locations in a canonical order. */
5000 return onepart_variable_different_p (var1
, var2
);
5003 for (i
= 0; i
< var1
->n_var_parts
; i
++)
5005 if (VAR_PART_OFFSET (var1
, i
) != VAR_PART_OFFSET (var2
, i
))
5007 if (variable_part_different_p (&var1
->var_part
[i
], &var2
->var_part
[i
]))
5009 if (variable_part_different_p (&var2
->var_part
[i
], &var1
->var_part
[i
]))
5015 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5018 dataflow_set_different (dataflow_set
*old_set
, dataflow_set
*new_set
)
5020 variable_iterator_type hi
;
5022 bool diffound
= false;
5023 bool details
= (dump_file
&& (dump_flags
& TDF_DETAILS
));
5035 if (old_set
->vars
== new_set
->vars
)
5038 if (shared_hash_htab (old_set
->vars
)->elements ()
5039 != shared_hash_htab (new_set
->vars
)->elements ())
5042 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set
->vars
),
5045 variable_table_type
*htab
= shared_hash_htab (new_set
->vars
);
5046 variable
*var2
= htab
->find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
5050 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5052 fprintf (dump_file
, "dataflow difference found: removal of:\n");
5057 else if (variable_different_p (var1
, var2
))
5061 fprintf (dump_file
, "dataflow difference found: "
5062 "old and new follow:\n");
5064 if (dv_onepart_p (var1
->dv
))
5065 dump_onepart_variable_differences (var1
, var2
);
5072 /* There's no need to traverse the second hashtab unless we want to
5073 print the details. If both have the same number of elements and
5074 the second one had all entries found in the first one, then the
5075 second can't have any extra entries. */
5079 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set
->vars
),
5082 variable_table_type
*htab
= shared_hash_htab (old_set
->vars
);
5083 variable
*var2
= htab
->find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
5088 fprintf (dump_file
, "dataflow difference found: addition of:\n");
5100 /* Free the contents of dataflow set SET. */
5103 dataflow_set_destroy (dataflow_set
*set
)
5107 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
5108 attrs_list_clear (&set
->regs
[i
]);
5110 shared_hash_destroy (set
->vars
);
5114 /* Return true if T is a tracked parameter with non-degenerate record type. */
5117 tracked_record_parameter_p (tree t
)
5119 if (TREE_CODE (t
) != PARM_DECL
)
5122 if (DECL_MODE (t
) == BLKmode
)
5125 tree type
= TREE_TYPE (t
);
5126 if (TREE_CODE (type
) != RECORD_TYPE
)
5129 if (TYPE_FIELDS (type
) == NULL_TREE
5130 || DECL_CHAIN (TYPE_FIELDS (type
)) == NULL_TREE
)
5136 /* Shall EXPR be tracked? */
5139 track_expr_p (tree expr
, bool need_rtl
)
5144 if (TREE_CODE (expr
) == DEBUG_EXPR_DECL
)
5145 return DECL_RTL_SET_P (expr
);
5147 /* If EXPR is not a parameter or a variable do not track it. */
5148 if (!VAR_P (expr
) && TREE_CODE (expr
) != PARM_DECL
)
5151 /* It also must have a name... */
5152 if (!DECL_NAME (expr
) && need_rtl
)
5155 /* ... and a RTL assigned to it. */
5156 decl_rtl
= DECL_RTL_IF_SET (expr
);
5157 if (!decl_rtl
&& need_rtl
)
5160 /* If this expression is really a debug alias of some other declaration, we
5161 don't need to track this expression if the ultimate declaration is
5164 if (VAR_P (realdecl
) && DECL_HAS_DEBUG_EXPR_P (realdecl
))
5166 realdecl
= DECL_DEBUG_EXPR (realdecl
);
5167 if (!DECL_P (realdecl
))
5169 if (handled_component_p (realdecl
)
5170 || (TREE_CODE (realdecl
) == MEM_REF
5171 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5173 HOST_WIDE_INT bitsize
, bitpos
, maxsize
;
5176 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
,
5177 &maxsize
, &reverse
);
5178 if (!DECL_P (innerdecl
)
5179 || DECL_IGNORED_P (innerdecl
)
5180 /* Do not track declarations for parts of tracked record
5181 parameters since we want to track them as a whole. */
5182 || tracked_record_parameter_p (innerdecl
)
5183 || TREE_STATIC (innerdecl
)
5185 || bitpos
+ bitsize
> 256
5186 || bitsize
!= maxsize
)
5196 /* Do not track EXPR if REALDECL it should be ignored for debugging
5198 if (DECL_IGNORED_P (realdecl
))
5201 /* Do not track global variables until we are able to emit correct location
5203 if (TREE_STATIC (realdecl
))
5206 /* When the EXPR is a DECL for alias of some variable (see example)
5207 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5208 DECL_RTL contains SYMBOL_REF.
5211 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5214 if (decl_rtl
&& MEM_P (decl_rtl
)
5215 && contains_symbol_ref_p (XEXP (decl_rtl
, 0)))
5218 /* If RTX is a memory it should not be very large (because it would be
5219 an array or struct). */
5220 if (decl_rtl
&& MEM_P (decl_rtl
))
5222 /* Do not track structures and arrays. */
5223 if ((GET_MODE (decl_rtl
) == BLKmode
5224 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl
)))
5225 && !tracked_record_parameter_p (realdecl
))
5227 if (MEM_SIZE_KNOWN_P (decl_rtl
)
5228 && MEM_SIZE (decl_rtl
) > MAX_VAR_PARTS
)
5232 DECL_CHANGED (expr
) = 0;
5233 DECL_CHANGED (realdecl
) = 0;
5237 /* Determine whether a given LOC refers to the same variable part as
5241 same_variable_part_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
)
5244 HOST_WIDE_INT offset2
;
5246 if (! DECL_P (expr
))
5251 expr2
= REG_EXPR (loc
);
5252 offset2
= REG_OFFSET (loc
);
5254 else if (MEM_P (loc
))
5256 expr2
= MEM_EXPR (loc
);
5257 offset2
= INT_MEM_OFFSET (loc
);
5262 if (! expr2
|| ! DECL_P (expr2
))
5265 expr
= var_debug_decl (expr
);
5266 expr2
= var_debug_decl (expr2
);
5268 return (expr
== expr2
&& offset
== offset2
);
5271 /* LOC is a REG or MEM that we would like to track if possible.
5272 If EXPR is null, we don't know what expression LOC refers to,
5273 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5274 LOC is an lvalue register.
5276 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5277 is something we can track. When returning true, store the mode of
5278 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5279 from EXPR in *OFFSET_OUT (if nonnull). */
5282 track_loc_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
, bool store_reg_p
,
5283 machine_mode
*mode_out
, HOST_WIDE_INT
*offset_out
)
5287 if (expr
== NULL
|| !track_expr_p (expr
, true))
5290 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5291 whole subreg, but only the old inner part is really relevant. */
5292 mode
= GET_MODE (loc
);
5293 if (REG_P (loc
) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc
)))
5295 machine_mode pseudo_mode
;
5297 pseudo_mode
= PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc
));
5298 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (pseudo_mode
))
5300 offset
+= byte_lowpart_offset (pseudo_mode
, mode
);
5305 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5306 Do the same if we are storing to a register and EXPR occupies
5307 the whole of register LOC; in that case, the whole of EXPR is
5308 being changed. We exclude complex modes from the second case
5309 because the real and imaginary parts are represented as separate
5310 pseudo registers, even if the whole complex value fits into one
5312 if ((GET_MODE_SIZE (mode
) > GET_MODE_SIZE (DECL_MODE (expr
))
5314 && !COMPLEX_MODE_P (DECL_MODE (expr
))
5315 && hard_regno_nregs
[REGNO (loc
)][DECL_MODE (expr
)] == 1))
5316 && offset
+ byte_lowpart_offset (DECL_MODE (expr
), mode
) == 0)
5318 mode
= DECL_MODE (expr
);
5322 if (offset
< 0 || offset
>= MAX_VAR_PARTS
)
5328 *offset_out
= offset
;
5332 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5333 want to track. When returning nonnull, make sure that the attributes
5334 on the returned value are updated. */
5337 var_lowpart (machine_mode mode
, rtx loc
)
5339 unsigned int offset
, reg_offset
, regno
;
5341 if (GET_MODE (loc
) == mode
)
5344 if (!REG_P (loc
) && !MEM_P (loc
))
5347 offset
= byte_lowpart_offset (mode
, GET_MODE (loc
));
5350 return adjust_address_nv (loc
, mode
, offset
);
5352 reg_offset
= subreg_lowpart_offset (mode
, GET_MODE (loc
));
5353 regno
= REGNO (loc
) + subreg_regno_offset (REGNO (loc
), GET_MODE (loc
),
5355 return gen_rtx_REG_offset (loc
, mode
, regno
, offset
);
5358 /* Carry information about uses and stores while walking rtx. */
5360 struct count_use_info
5362 /* The insn where the RTX is. */
5365 /* The basic block where insn is. */
5368 /* The array of n_sets sets in the insn, as determined by cselib. */
5369 struct cselib_set
*sets
;
5372 /* True if we're counting stores, false otherwise. */
5376 /* Find a VALUE corresponding to X. */
5378 static inline cselib_val
*
5379 find_use_val (rtx x
, machine_mode mode
, struct count_use_info
*cui
)
5385 /* This is called after uses are set up and before stores are
5386 processed by cselib, so it's safe to look up srcs, but not
5387 dsts. So we look up expressions that appear in srcs or in
5388 dest expressions, but we search the sets array for dests of
5392 /* Some targets represent memset and memcpy patterns
5393 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5394 (set (mem:BLK ...) (const_int ...)) or
5395 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5396 in that case, otherwise we end up with mode mismatches. */
5397 if (mode
== BLKmode
&& MEM_P (x
))
5399 for (i
= 0; i
< cui
->n_sets
; i
++)
5400 if (cui
->sets
[i
].dest
== x
)
5401 return cui
->sets
[i
].src_elt
;
5404 return cselib_lookup (x
, mode
, 0, VOIDmode
);
5410 /* Replace all registers and addresses in an expression with VALUE
5411 expressions that map back to them, unless the expression is a
5412 register. If no mapping is or can be performed, returns NULL. */
5415 replace_expr_with_values (rtx loc
)
5417 if (REG_P (loc
) || GET_CODE (loc
) == ENTRY_VALUE
)
5419 else if (MEM_P (loc
))
5421 cselib_val
*addr
= cselib_lookup (XEXP (loc
, 0),
5422 get_address_mode (loc
), 0,
5425 return replace_equiv_address_nv (loc
, addr
->val_rtx
);
5430 return cselib_subst_to_values (loc
, VOIDmode
);
5433 /* Return true if X contains a DEBUG_EXPR. */
5436 rtx_debug_expr_p (const_rtx x
)
5438 subrtx_iterator::array_type array
;
5439 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
5440 if (GET_CODE (*iter
) == DEBUG_EXPR
)
5445 /* Determine what kind of micro operation to choose for a USE. Return
5446 MO_CLOBBER if no micro operation is to be generated. */
5448 static enum micro_operation_type
5449 use_type (rtx loc
, struct count_use_info
*cui
, machine_mode
*modep
)
5453 if (cui
&& cui
->sets
)
5455 if (GET_CODE (loc
) == VAR_LOCATION
)
5457 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc
), false))
5459 rtx ploc
= PAT_VAR_LOCATION_LOC (loc
);
5460 if (! VAR_LOC_UNKNOWN_P (ploc
))
5462 cselib_val
*val
= cselib_lookup (ploc
, GET_MODE (loc
), 1,
5465 /* ??? flag_float_store and volatile mems are never
5466 given values, but we could in theory use them for
5468 gcc_assert (val
|| 1);
5476 if (REG_P (loc
) || MEM_P (loc
))
5479 *modep
= GET_MODE (loc
);
5483 || (find_use_val (loc
, GET_MODE (loc
), cui
)
5484 && cselib_lookup (XEXP (loc
, 0),
5485 get_address_mode (loc
), 0,
5491 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5493 if (val
&& !cselib_preserved_value_p (val
))
5501 gcc_assert (REGNO (loc
) < FIRST_PSEUDO_REGISTER
);
5503 if (loc
== cfa_base_rtx
)
5505 expr
= REG_EXPR (loc
);
5508 return MO_USE_NO_VAR
;
5509 else if (target_for_debug_bind (var_debug_decl (expr
)))
5511 else if (track_loc_p (loc
, expr
, REG_OFFSET (loc
),
5512 false, modep
, NULL
))
5515 return MO_USE_NO_VAR
;
5517 else if (MEM_P (loc
))
5519 expr
= MEM_EXPR (loc
);
5523 else if (target_for_debug_bind (var_debug_decl (expr
)))
5525 else if (track_loc_p (loc
, expr
, INT_MEM_OFFSET (loc
),
5527 /* Multi-part variables shouldn't refer to one-part
5528 variable names such as VALUEs (never happens) or
5529 DEBUG_EXPRs (only happens in the presence of debug
5531 && (!MAY_HAVE_DEBUG_INSNS
5532 || !rtx_debug_expr_p (XEXP (loc
, 0))))
5541 /* Log to OUT information about micro-operation MOPT involving X in
5545 log_op_type (rtx x
, basic_block bb
, rtx_insn
*insn
,
5546 enum micro_operation_type mopt
, FILE *out
)
5548 fprintf (out
, "bb %i op %i insn %i %s ",
5549 bb
->index
, VTI (bb
)->mos
.length (),
5550 INSN_UID (insn
), micro_operation_type_name
[mopt
]);
5551 print_inline_rtx (out
, x
, 2);
5555 /* Tell whether the CONCAT used to holds a VALUE and its location
5556 needs value resolution, i.e., an attempt of mapping the location
5557 back to other incoming values. */
5558 #define VAL_NEEDS_RESOLUTION(x) \
5559 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5560 /* Whether the location in the CONCAT is a tracked expression, that
5561 should also be handled like a MO_USE. */
5562 #define VAL_HOLDS_TRACK_EXPR(x) \
5563 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5564 /* Whether the location in the CONCAT should be handled like a MO_COPY
5566 #define VAL_EXPR_IS_COPIED(x) \
5567 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5568 /* Whether the location in the CONCAT should be handled like a
5569 MO_CLOBBER as well. */
5570 #define VAL_EXPR_IS_CLOBBERED(x) \
5571 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5573 /* All preserved VALUEs. */
5574 static vec
<rtx
> preserved_values
;
5576 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5579 preserve_value (cselib_val
*val
)
5581 cselib_preserve_value (val
);
5582 preserved_values
.safe_push (val
->val_rtx
);
5585 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5586 any rtxes not suitable for CONST use not replaced by VALUEs
5590 non_suitable_const (const_rtx x
)
5592 subrtx_iterator::array_type array
;
5593 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
5595 const_rtx x
= *iter
;
5596 switch (GET_CODE (x
))
5607 if (!MEM_READONLY_P (x
))
5617 /* Add uses (register and memory references) LOC which will be tracked
5618 to VTI (bb)->mos. */
5621 add_uses (rtx loc
, struct count_use_info
*cui
)
5623 machine_mode mode
= VOIDmode
;
5624 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5626 if (type
!= MO_CLOBBER
)
5628 basic_block bb
= cui
->bb
;
5632 mo
.u
.loc
= type
== MO_USE
? var_lowpart (mode
, loc
) : loc
;
5633 mo
.insn
= cui
->insn
;
5635 if (type
== MO_VAL_LOC
)
5638 rtx vloc
= PAT_VAR_LOCATION_LOC (oloc
);
5641 gcc_assert (cui
->sets
);
5644 && !REG_P (XEXP (vloc
, 0))
5645 && !MEM_P (XEXP (vloc
, 0)))
5648 machine_mode address_mode
= get_address_mode (mloc
);
5650 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5653 if (val
&& !cselib_preserved_value_p (val
))
5654 preserve_value (val
);
5657 if (CONSTANT_P (vloc
)
5658 && (GET_CODE (vloc
) != CONST
|| non_suitable_const (vloc
)))
5659 /* For constants don't look up any value. */;
5660 else if (!VAR_LOC_UNKNOWN_P (vloc
) && !unsuitable_loc (vloc
)
5661 && (val
= find_use_val (vloc
, GET_MODE (oloc
), cui
)))
5664 enum micro_operation_type type2
;
5666 bool resolvable
= REG_P (vloc
) || MEM_P (vloc
);
5669 nloc
= replace_expr_with_values (vloc
);
5673 oloc
= shallow_copy_rtx (oloc
);
5674 PAT_VAR_LOCATION_LOC (oloc
) = nloc
;
5677 oloc
= gen_rtx_CONCAT (mode
, val
->val_rtx
, oloc
);
5679 type2
= use_type (vloc
, 0, &mode2
);
5681 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5682 || type2
== MO_CLOBBER
);
5684 if (type2
== MO_CLOBBER
5685 && !cselib_preserved_value_p (val
))
5687 VAL_NEEDS_RESOLUTION (oloc
) = resolvable
;
5688 preserve_value (val
);
5691 else if (!VAR_LOC_UNKNOWN_P (vloc
))
5693 oloc
= shallow_copy_rtx (oloc
);
5694 PAT_VAR_LOCATION_LOC (oloc
) = gen_rtx_UNKNOWN_VAR_LOC ();
5699 else if (type
== MO_VAL_USE
)
5701 machine_mode mode2
= VOIDmode
;
5702 enum micro_operation_type type2
;
5703 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5704 rtx vloc
, oloc
= loc
, nloc
;
5706 gcc_assert (cui
->sets
);
5709 && !REG_P (XEXP (oloc
, 0))
5710 && !MEM_P (XEXP (oloc
, 0)))
5713 machine_mode address_mode
= get_address_mode (mloc
);
5715 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5718 if (val
&& !cselib_preserved_value_p (val
))
5719 preserve_value (val
);
5722 type2
= use_type (loc
, 0, &mode2
);
5724 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5725 || type2
== MO_CLOBBER
);
5727 if (type2
== MO_USE
)
5728 vloc
= var_lowpart (mode2
, loc
);
5732 /* The loc of a MO_VAL_USE may have two forms:
5734 (concat val src): val is at src, a value-based
5737 (concat (concat val use) src): same as above, with use as
5738 the MO_USE tracked value, if it differs from src.
5742 gcc_checking_assert (REG_P (loc
) || MEM_P (loc
));
5743 nloc
= replace_expr_with_values (loc
);
5748 oloc
= gen_rtx_CONCAT (mode2
, val
->val_rtx
, vloc
);
5750 oloc
= val
->val_rtx
;
5752 mo
.u
.loc
= gen_rtx_CONCAT (mode
, oloc
, nloc
);
5754 if (type2
== MO_USE
)
5755 VAL_HOLDS_TRACK_EXPR (mo
.u
.loc
) = 1;
5756 if (!cselib_preserved_value_p (val
))
5758 VAL_NEEDS_RESOLUTION (mo
.u
.loc
) = 1;
5759 preserve_value (val
);
5763 gcc_assert (type
== MO_USE
|| type
== MO_USE_NO_VAR
);
5765 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5766 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
5767 VTI (bb
)->mos
.safe_push (mo
);
5771 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5774 add_uses_1 (rtx
*x
, void *cui
)
5776 subrtx_var_iterator::array_type array
;
5777 FOR_EACH_SUBRTX_VAR (iter
, array
, *x
, NONCONST
)
5778 add_uses (*iter
, (struct count_use_info
*) cui
);
5781 /* This is the value used during expansion of locations. We want it
5782 to be unbounded, so that variables expanded deep in a recursion
5783 nest are fully evaluated, so that their values are cached
5784 correctly. We avoid recursion cycles through other means, and we
5785 don't unshare RTL, so excess complexity is not a problem. */
5786 #define EXPR_DEPTH (INT_MAX)
5787 /* We use this to keep too-complex expressions from being emitted as
5788 location notes, and then to debug information. Users can trade
5789 compile time for ridiculously complex expressions, although they're
5790 seldom useful, and they may often have to be discarded as not
5791 representable anyway. */
5792 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5794 /* Attempt to reverse the EXPR operation in the debug info and record
5795 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5796 no longer live we can express its value as VAL - 6. */
5799 reverse_op (rtx val
, const_rtx expr
, rtx_insn
*insn
)
5803 struct elt_loc_list
*l
;
5807 if (GET_CODE (expr
) != SET
)
5810 if (!REG_P (SET_DEST (expr
)) || GET_MODE (val
) != GET_MODE (SET_DEST (expr
)))
5813 src
= SET_SRC (expr
);
5814 switch (GET_CODE (src
))
5821 if (!REG_P (XEXP (src
, 0)))
5826 if (!REG_P (XEXP (src
, 0)) && !MEM_P (XEXP (src
, 0)))
5833 if (!SCALAR_INT_MODE_P (GET_MODE (src
)) || XEXP (src
, 0) == cfa_base_rtx
)
5836 v
= cselib_lookup (XEXP (src
, 0), GET_MODE (XEXP (src
, 0)), 0, VOIDmode
);
5837 if (!v
|| !cselib_preserved_value_p (v
))
5840 /* Use canonical V to avoid creating multiple redundant expressions
5841 for different VALUES equivalent to V. */
5842 v
= canonical_cselib_val (v
);
5844 /* Adding a reverse op isn't useful if V already has an always valid
5845 location. Ignore ENTRY_VALUE, while it is always constant, we should
5846 prefer non-ENTRY_VALUE locations whenever possible. */
5847 for (l
= v
->locs
, count
= 0; l
; l
= l
->next
, count
++)
5848 if (CONSTANT_P (l
->loc
)
5849 && (GET_CODE (l
->loc
) != CONST
|| !references_value_p (l
->loc
, 0)))
5851 /* Avoid creating too large locs lists. */
5852 else if (count
== PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE
))
5855 switch (GET_CODE (src
))
5859 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5861 ret
= gen_rtx_fmt_e (GET_CODE (src
), GET_MODE (val
), val
);
5865 ret
= gen_lowpart_SUBREG (GET_MODE (v
->val_rtx
), val
);
5877 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5879 arg
= XEXP (src
, 1);
5880 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5882 arg
= cselib_expand_value_rtx (arg
, scratch_regs
, 5);
5883 if (arg
== NULL_RTX
)
5885 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5888 ret
= simplify_gen_binary (code
, GET_MODE (val
), val
, arg
);
5894 cselib_add_permanent_equiv (v
, ret
, insn
);
5897 /* Add stores (register and memory references) LOC which will be tracked
5898 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5899 CUIP->insn is instruction which the LOC is part of. */
5902 add_stores (rtx loc
, const_rtx expr
, void *cuip
)
5904 machine_mode mode
= VOIDmode
, mode2
;
5905 struct count_use_info
*cui
= (struct count_use_info
*)cuip
;
5906 basic_block bb
= cui
->bb
;
5908 rtx oloc
= loc
, nloc
, src
= NULL
;
5909 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5910 bool track_p
= false;
5912 bool resolve
, preserve
;
5914 if (type
== MO_CLOBBER
)
5921 gcc_assert (loc
!= cfa_base_rtx
);
5922 if ((GET_CODE (expr
) == CLOBBER
&& type
!= MO_VAL_SET
)
5923 || !(track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5924 || GET_CODE (expr
) == CLOBBER
)
5926 mo
.type
= MO_CLOBBER
;
5928 if (GET_CODE (expr
) == SET
5929 && SET_DEST (expr
) == loc
5930 && !unsuitable_loc (SET_SRC (expr
))
5931 && find_use_val (loc
, mode
, cui
))
5933 gcc_checking_assert (type
== MO_VAL_SET
);
5934 mo
.u
.loc
= gen_rtx_SET (loc
, SET_SRC (expr
));
5939 if (GET_CODE (expr
) == SET
5940 && SET_DEST (expr
) == loc
5941 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5942 src
= var_lowpart (mode2
, SET_SRC (expr
));
5943 loc
= var_lowpart (mode2
, loc
);
5952 rtx xexpr
= gen_rtx_SET (loc
, src
);
5953 if (same_variable_part_p (src
, REG_EXPR (loc
), REG_OFFSET (loc
)))
5955 /* If this is an instruction copying (part of) a parameter
5956 passed by invisible reference to its register location,
5957 pretend it's a SET so that the initial memory location
5958 is discarded, as the parameter register can be reused
5959 for other purposes and we do not track locations based
5960 on generic registers. */
5963 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5964 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5965 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5966 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0)
5977 mo
.insn
= cui
->insn
;
5979 else if (MEM_P (loc
)
5980 && ((track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5983 if (MEM_P (loc
) && type
== MO_VAL_SET
5984 && !REG_P (XEXP (loc
, 0))
5985 && !MEM_P (XEXP (loc
, 0)))
5988 machine_mode address_mode
= get_address_mode (mloc
);
5989 cselib_val
*val
= cselib_lookup (XEXP (mloc
, 0),
5993 if (val
&& !cselib_preserved_value_p (val
))
5994 preserve_value (val
);
5997 if (GET_CODE (expr
) == CLOBBER
|| !track_p
)
5999 mo
.type
= MO_CLOBBER
;
6000 mo
.u
.loc
= track_p
? var_lowpart (mode2
, loc
) : loc
;
6004 if (GET_CODE (expr
) == SET
6005 && SET_DEST (expr
) == loc
6006 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
6007 src
= var_lowpart (mode2
, SET_SRC (expr
));
6008 loc
= var_lowpart (mode2
, loc
);
6017 rtx xexpr
= gen_rtx_SET (loc
, src
);
6018 if (same_variable_part_p (SET_SRC (xexpr
),
6020 INT_MEM_OFFSET (loc
)))
6027 mo
.insn
= cui
->insn
;
6032 if (type
!= MO_VAL_SET
)
6033 goto log_and_return
;
6035 v
= find_use_val (oloc
, mode
, cui
);
6038 goto log_and_return
;
6040 resolve
= preserve
= !cselib_preserved_value_p (v
);
6042 /* We cannot track values for multiple-part variables, so we track only
6043 locations for tracked record parameters. */
6047 && tracked_record_parameter_p (REG_EXPR (loc
)))
6049 /* Although we don't use the value here, it could be used later by the
6050 mere virtue of its existence as the operand of the reverse operation
6051 that gave rise to it (typically extension/truncation). Make sure it
6052 is preserved as required by vt_expand_var_loc_chain. */
6055 goto log_and_return
;
6058 if (loc
== stack_pointer_rtx
6059 && hard_frame_pointer_adjustment
!= -1
6061 cselib_set_value_sp_based (v
);
6063 nloc
= replace_expr_with_values (oloc
);
6067 if (GET_CODE (PATTERN (cui
->insn
)) == COND_EXEC
)
6069 cselib_val
*oval
= cselib_lookup (oloc
, GET_MODE (oloc
), 0, VOIDmode
);
6073 gcc_assert (REG_P (oloc
) || MEM_P (oloc
));
6075 if (oval
&& !cselib_preserved_value_p (oval
))
6077 micro_operation moa
;
6079 preserve_value (oval
);
6081 moa
.type
= MO_VAL_USE
;
6082 moa
.u
.loc
= gen_rtx_CONCAT (mode
, oval
->val_rtx
, oloc
);
6083 VAL_NEEDS_RESOLUTION (moa
.u
.loc
) = 1;
6084 moa
.insn
= cui
->insn
;
6086 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6087 log_op_type (moa
.u
.loc
, cui
->bb
, cui
->insn
,
6088 moa
.type
, dump_file
);
6089 VTI (bb
)->mos
.safe_push (moa
);
6094 else if (resolve
&& GET_CODE (mo
.u
.loc
) == SET
)
6096 if (REG_P (SET_SRC (expr
)) || MEM_P (SET_SRC (expr
)))
6097 nloc
= replace_expr_with_values (SET_SRC (expr
));
6101 /* Avoid the mode mismatch between oexpr and expr. */
6102 if (!nloc
&& mode
!= mode2
)
6104 nloc
= SET_SRC (expr
);
6105 gcc_assert (oloc
== SET_DEST (expr
));
6108 if (nloc
&& nloc
!= SET_SRC (mo
.u
.loc
))
6109 oloc
= gen_rtx_SET (oloc
, nloc
);
6112 if (oloc
== SET_DEST (mo
.u
.loc
))
6113 /* No point in duplicating. */
6115 if (!REG_P (SET_SRC (mo
.u
.loc
)))
6121 if (GET_CODE (mo
.u
.loc
) == SET
6122 && oloc
== SET_DEST (mo
.u
.loc
))
6123 /* No point in duplicating. */
6129 loc
= gen_rtx_CONCAT (mode
, v
->val_rtx
, oloc
);
6131 if (mo
.u
.loc
!= oloc
)
6132 loc
= gen_rtx_CONCAT (GET_MODE (mo
.u
.loc
), loc
, mo
.u
.loc
);
6134 /* The loc of a MO_VAL_SET may have various forms:
6136 (concat val dst): dst now holds val
6138 (concat val (set dst src)): dst now holds val, copied from src
6140 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6141 after replacing mems and non-top-level regs with values.
6143 (concat (concat val dstv) (set dst src)): dst now holds val,
6144 copied from src. dstv is a value-based representation of dst, if
6145 it differs from dst. If resolution is needed, src is a REG, and
6146 its mode is the same as that of val.
6148 (concat (concat val (set dstv srcv)) (set dst src)): src
6149 copied to dst, holding val. dstv and srcv are value-based
6150 representations of dst and src, respectively.
6154 if (GET_CODE (PATTERN (cui
->insn
)) != COND_EXEC
)
6155 reverse_op (v
->val_rtx
, expr
, cui
->insn
);
6160 VAL_HOLDS_TRACK_EXPR (loc
) = 1;
6163 VAL_NEEDS_RESOLUTION (loc
) = resolve
;
6166 if (mo
.type
== MO_CLOBBER
)
6167 VAL_EXPR_IS_CLOBBERED (loc
) = 1;
6168 if (mo
.type
== MO_COPY
)
6169 VAL_EXPR_IS_COPIED (loc
) = 1;
6171 mo
.type
= MO_VAL_SET
;
6174 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6175 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
6176 VTI (bb
)->mos
.safe_push (mo
);
6179 /* Arguments to the call. */
6180 static rtx call_arguments
;
6182 /* Compute call_arguments. */
6185 prepare_call_arguments (basic_block bb
, rtx_insn
*insn
)
6188 rtx prev
, cur
, next
;
6189 rtx this_arg
= NULL_RTX
;
6190 tree type
= NULL_TREE
, t
, fndecl
= NULL_TREE
;
6191 tree obj_type_ref
= NULL_TREE
;
6192 CUMULATIVE_ARGS args_so_far_v
;
6193 cumulative_args_t args_so_far
;
6195 memset (&args_so_far_v
, 0, sizeof (args_so_far_v
));
6196 args_so_far
= pack_cumulative_args (&args_so_far_v
);
6197 call
= get_call_rtx_from (insn
);
6200 if (GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
6202 rtx symbol
= XEXP (XEXP (call
, 0), 0);
6203 if (SYMBOL_REF_DECL (symbol
))
6204 fndecl
= SYMBOL_REF_DECL (symbol
);
6206 if (fndecl
== NULL_TREE
)
6207 fndecl
= MEM_EXPR (XEXP (call
, 0));
6209 && TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
6210 && TREE_CODE (TREE_TYPE (fndecl
)) != METHOD_TYPE
)
6212 if (fndecl
&& TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6213 type
= TREE_TYPE (fndecl
);
6214 if (fndecl
&& TREE_CODE (fndecl
) != FUNCTION_DECL
)
6216 if (TREE_CODE (fndecl
) == INDIRECT_REF
6217 && TREE_CODE (TREE_OPERAND (fndecl
, 0)) == OBJ_TYPE_REF
)
6218 obj_type_ref
= TREE_OPERAND (fndecl
, 0);
6223 for (t
= TYPE_ARG_TYPES (type
); t
&& t
!= void_list_node
;
6225 if (TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
6226 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t
))))
6228 if ((t
== NULL
|| t
== void_list_node
) && obj_type_ref
== NULL_TREE
)
6232 int nargs ATTRIBUTE_UNUSED
= list_length (TYPE_ARG_TYPES (type
));
6233 link
= CALL_INSN_FUNCTION_USAGE (insn
);
6234 #ifndef PCC_STATIC_STRUCT_RETURN
6235 if (aggregate_value_p (TREE_TYPE (type
), type
)
6236 && targetm
.calls
.struct_value_rtx (type
, 0) == 0)
6238 tree struct_addr
= build_pointer_type (TREE_TYPE (type
));
6239 machine_mode mode
= TYPE_MODE (struct_addr
);
6241 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6243 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6245 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6247 if (reg
== NULL_RTX
)
6249 for (; link
; link
= XEXP (link
, 1))
6250 if (GET_CODE (XEXP (link
, 0)) == USE
6251 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6253 link
= XEXP (link
, 1);
6260 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6262 if (obj_type_ref
&& TYPE_ARG_TYPES (type
) != void_list_node
)
6265 t
= TYPE_ARG_TYPES (type
);
6266 mode
= TYPE_MODE (TREE_VALUE (t
));
6267 this_arg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6268 TREE_VALUE (t
), true);
6269 if (this_arg
&& !REG_P (this_arg
))
6270 this_arg
= NULL_RTX
;
6271 else if (this_arg
== NULL_RTX
)
6273 for (; link
; link
= XEXP (link
, 1))
6274 if (GET_CODE (XEXP (link
, 0)) == USE
6275 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6277 this_arg
= XEXP (XEXP (link
, 0), 0);
6285 t
= type
? TYPE_ARG_TYPES (type
) : NULL_TREE
;
6287 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
6288 if (GET_CODE (XEXP (link
, 0)) == USE
)
6290 rtx item
= NULL_RTX
;
6291 x
= XEXP (XEXP (link
, 0), 0);
6292 if (GET_MODE (link
) == VOIDmode
6293 || GET_MODE (link
) == BLKmode
6294 || (GET_MODE (link
) != GET_MODE (x
)
6295 && ((GET_MODE_CLASS (GET_MODE (link
)) != MODE_INT
6296 && GET_MODE_CLASS (GET_MODE (link
)) != MODE_PARTIAL_INT
)
6297 || (GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
6298 && GET_MODE_CLASS (GET_MODE (x
)) != MODE_PARTIAL_INT
))))
6299 /* Can't do anything for these, if the original type mode
6300 isn't known or can't be converted. */;
6303 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6304 if (val
&& cselib_preserved_value_p (val
))
6305 item
= val
->val_rtx
;
6306 else if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_INT
6307 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_PARTIAL_INT
)
6309 machine_mode mode
= GET_MODE (x
);
6311 while ((mode
= GET_MODE_WIDER_MODE (mode
)) != VOIDmode
6312 && GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
6314 rtx reg
= simplify_subreg (mode
, x
, GET_MODE (x
), 0);
6316 if (reg
== NULL_RTX
|| !REG_P (reg
))
6318 val
= cselib_lookup (reg
, mode
, 0, VOIDmode
);
6319 if (val
&& cselib_preserved_value_p (val
))
6321 item
= val
->val_rtx
;
6332 if (!frame_pointer_needed
)
6334 struct adjust_mem_data amd
;
6335 amd
.mem_mode
= VOIDmode
;
6336 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
6338 mem
= simplify_replace_fn_rtx (mem
, NULL_RTX
, adjust_mems
,
6340 gcc_assert (amd
.side_effects
.is_empty ());
6342 val
= cselib_lookup (mem
, GET_MODE (mem
), 0, VOIDmode
);
6343 if (val
&& cselib_preserved_value_p (val
))
6344 item
= val
->val_rtx
;
6345 else if (GET_MODE_CLASS (GET_MODE (mem
)) != MODE_INT
6346 && GET_MODE_CLASS (GET_MODE (mem
)) != MODE_PARTIAL_INT
)
6348 /* For non-integer stack argument see also if they weren't
6349 initialized by integers. */
6350 machine_mode imode
= int_mode_for_mode (GET_MODE (mem
));
6351 if (imode
!= GET_MODE (mem
) && imode
!= BLKmode
)
6353 val
= cselib_lookup (adjust_address_nv (mem
, imode
, 0),
6354 imode
, 0, VOIDmode
);
6355 if (val
&& cselib_preserved_value_p (val
))
6356 item
= lowpart_subreg (GET_MODE (x
), val
->val_rtx
,
6364 if (GET_MODE (item
) != GET_MODE (link
))
6365 item
= lowpart_subreg (GET_MODE (link
), item
, GET_MODE (item
));
6366 if (GET_MODE (x2
) != GET_MODE (link
))
6367 x2
= lowpart_subreg (GET_MODE (link
), x2
, GET_MODE (x2
));
6368 item
= gen_rtx_CONCAT (GET_MODE (link
), x2
, item
);
6370 = gen_rtx_EXPR_LIST (VOIDmode
, item
, call_arguments
);
6372 if (t
&& t
!= void_list_node
)
6374 tree argtype
= TREE_VALUE (t
);
6375 machine_mode mode
= TYPE_MODE (argtype
);
6377 if (pass_by_reference (&args_so_far_v
, mode
, argtype
, true))
6379 argtype
= build_pointer_type (argtype
);
6380 mode
= TYPE_MODE (argtype
);
6382 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6384 if (TREE_CODE (argtype
) == REFERENCE_TYPE
6385 && INTEGRAL_TYPE_P (TREE_TYPE (argtype
))
6388 && GET_MODE (reg
) == mode
6389 && (GET_MODE_CLASS (mode
) == MODE_INT
6390 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
6392 && REGNO (x
) == REGNO (reg
)
6393 && GET_MODE (x
) == mode
6396 machine_mode indmode
6397 = TYPE_MODE (TREE_TYPE (argtype
));
6398 rtx mem
= gen_rtx_MEM (indmode
, x
);
6399 cselib_val
*val
= cselib_lookup (mem
, indmode
, 0, VOIDmode
);
6400 if (val
&& cselib_preserved_value_p (val
))
6402 item
= gen_rtx_CONCAT (indmode
, mem
, val
->val_rtx
);
6403 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6408 struct elt_loc_list
*l
;
6411 /* Try harder, when passing address of a constant
6412 pool integer it can be easily read back. */
6413 item
= XEXP (item
, 1);
6414 if (GET_CODE (item
) == SUBREG
)
6415 item
= SUBREG_REG (item
);
6416 gcc_assert (GET_CODE (item
) == VALUE
);
6417 val
= CSELIB_VAL_PTR (item
);
6418 for (l
= val
->locs
; l
; l
= l
->next
)
6419 if (GET_CODE (l
->loc
) == SYMBOL_REF
6420 && TREE_CONSTANT_POOL_ADDRESS_P (l
->loc
)
6421 && SYMBOL_REF_DECL (l
->loc
)
6422 && DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
)))
6424 initial
= DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
));
6425 if (tree_fits_shwi_p (initial
))
6427 item
= GEN_INT (tree_to_shwi (initial
));
6428 item
= gen_rtx_CONCAT (indmode
, mem
, item
);
6430 = gen_rtx_EXPR_LIST (VOIDmode
, item
,
6437 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6443 /* Add debug arguments. */
6445 && TREE_CODE (fndecl
) == FUNCTION_DECL
6446 && DECL_HAS_DEBUG_ARGS_P (fndecl
))
6448 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (fndecl
);
6453 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, ¶m
); ix
+= 2)
6456 tree dtemp
= (**debug_args
)[ix
+ 1];
6457 machine_mode mode
= DECL_MODE (dtemp
);
6458 item
= gen_rtx_DEBUG_PARAMETER_REF (mode
, param
);
6459 item
= gen_rtx_CONCAT (mode
, item
, DECL_RTL_KNOWN_SET (dtemp
));
6460 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6466 /* Reverse call_arguments chain. */
6468 for (cur
= call_arguments
; cur
; cur
= next
)
6470 next
= XEXP (cur
, 1);
6471 XEXP (cur
, 1) = prev
;
6474 call_arguments
= prev
;
6476 x
= get_call_rtx_from (insn
);
6479 x
= XEXP (XEXP (x
, 0), 0);
6480 if (GET_CODE (x
) == SYMBOL_REF
)
6481 /* Don't record anything. */;
6482 else if (CONSTANT_P (x
))
6484 x
= gen_rtx_CONCAT (GET_MODE (x
) == VOIDmode
? Pmode
: GET_MODE (x
),
6487 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6491 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6492 if (val
&& cselib_preserved_value_p (val
))
6494 x
= gen_rtx_CONCAT (GET_MODE (x
), pc_rtx
, val
->val_rtx
);
6496 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6503 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref
)));
6504 rtx clobbered
= gen_rtx_MEM (mode
, this_arg
);
6506 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref
));
6508 clobbered
= plus_constant (mode
, clobbered
,
6509 token
* GET_MODE_SIZE (mode
));
6510 clobbered
= gen_rtx_MEM (mode
, clobbered
);
6511 x
= gen_rtx_CONCAT (mode
, gen_rtx_CLOBBER (VOIDmode
, pc_rtx
), clobbered
);
6513 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6517 /* Callback for cselib_record_sets_hook, that records as micro
6518 operations uses and stores in an insn after cselib_record_sets has
6519 analyzed the sets in an insn, but before it modifies the stored
6520 values in the internal tables, unless cselib_record_sets doesn't
6521 call it directly (perhaps because we're not doing cselib in the
6522 first place, in which case sets and n_sets will be 0). */
6525 add_with_sets (rtx_insn
*insn
, struct cselib_set
*sets
, int n_sets
)
6527 basic_block bb
= BLOCK_FOR_INSN (insn
);
6529 struct count_use_info cui
;
6530 micro_operation
*mos
;
6532 cselib_hook_called
= true;
6537 cui
.n_sets
= n_sets
;
6539 n1
= VTI (bb
)->mos
.length ();
6540 cui
.store_p
= false;
6541 note_uses (&PATTERN (insn
), add_uses_1
, &cui
);
6542 n2
= VTI (bb
)->mos
.length () - 1;
6543 mos
= VTI (bb
)->mos
.address ();
6545 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6549 while (n1
< n2
&& mos
[n1
].type
== MO_USE
)
6551 while (n1
< n2
&& mos
[n2
].type
!= MO_USE
)
6554 std::swap (mos
[n1
], mos
[n2
]);
6557 n2
= VTI (bb
)->mos
.length () - 1;
6560 while (n1
< n2
&& mos
[n1
].type
!= MO_VAL_LOC
)
6562 while (n1
< n2
&& mos
[n2
].type
== MO_VAL_LOC
)
6565 std::swap (mos
[n1
], mos
[n2
]);
6574 mo
.u
.loc
= call_arguments
;
6575 call_arguments
= NULL_RTX
;
6577 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6578 log_op_type (PATTERN (insn
), bb
, insn
, mo
.type
, dump_file
);
6579 VTI (bb
)->mos
.safe_push (mo
);
6582 n1
= VTI (bb
)->mos
.length ();
6583 /* This will record NEXT_INSN (insn), such that we can
6584 insert notes before it without worrying about any
6585 notes that MO_USEs might emit after the insn. */
6587 note_stores (PATTERN (insn
), add_stores
, &cui
);
6588 n2
= VTI (bb
)->mos
.length () - 1;
6589 mos
= VTI (bb
)->mos
.address ();
6591 /* Order the MO_VAL_USEs first (note_stores does nothing
6592 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6593 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6596 while (n1
< n2
&& mos
[n1
].type
== MO_VAL_USE
)
6598 while (n1
< n2
&& mos
[n2
].type
!= MO_VAL_USE
)
6601 std::swap (mos
[n1
], mos
[n2
]);
6604 n2
= VTI (bb
)->mos
.length () - 1;
6607 while (n1
< n2
&& mos
[n1
].type
== MO_CLOBBER
)
6609 while (n1
< n2
&& mos
[n2
].type
!= MO_CLOBBER
)
6612 std::swap (mos
[n1
], mos
[n2
]);
6616 static enum var_init_status
6617 find_src_status (dataflow_set
*in
, rtx src
)
6619 tree decl
= NULL_TREE
;
6620 enum var_init_status status
= VAR_INIT_STATUS_UNINITIALIZED
;
6622 if (! flag_var_tracking_uninit
)
6623 status
= VAR_INIT_STATUS_INITIALIZED
;
6625 if (src
&& REG_P (src
))
6626 decl
= var_debug_decl (REG_EXPR (src
));
6627 else if (src
&& MEM_P (src
))
6628 decl
= var_debug_decl (MEM_EXPR (src
));
6631 status
= get_init_value (in
, src
, dv_from_decl (decl
));
6636 /* SRC is the source of an assignment. Use SET to try to find what
6637 was ultimately assigned to SRC. Return that value if known,
6638 otherwise return SRC itself. */
6641 find_src_set_src (dataflow_set
*set
, rtx src
)
6643 tree decl
= NULL_TREE
; /* The variable being copied around. */
6644 rtx set_src
= NULL_RTX
; /* The value for "decl" stored in "src". */
6646 location_chain
*nextp
;
6650 if (src
&& REG_P (src
))
6651 decl
= var_debug_decl (REG_EXPR (src
));
6652 else if (src
&& MEM_P (src
))
6653 decl
= var_debug_decl (MEM_EXPR (src
));
6657 decl_or_value dv
= dv_from_decl (decl
);
6659 var
= shared_hash_find (set
->vars
, dv
);
6663 for (i
= 0; i
< var
->n_var_parts
&& !found
; i
++)
6664 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
&& !found
;
6665 nextp
= nextp
->next
)
6666 if (rtx_equal_p (nextp
->loc
, src
))
6668 set_src
= nextp
->set_src
;
6678 /* Compute the changes of variable locations in the basic block BB. */
6681 compute_bb_dataflow (basic_block bb
)
6684 micro_operation
*mo
;
6686 dataflow_set old_out
;
6687 dataflow_set
*in
= &VTI (bb
)->in
;
6688 dataflow_set
*out
= &VTI (bb
)->out
;
6690 dataflow_set_init (&old_out
);
6691 dataflow_set_copy (&old_out
, out
);
6692 dataflow_set_copy (out
, in
);
6694 if (MAY_HAVE_DEBUG_INSNS
)
6695 local_get_addr_cache
= new hash_map
<rtx
, rtx
>;
6697 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
6699 rtx_insn
*insn
= mo
->insn
;
6704 dataflow_set_clear_at_call (out
, insn
);
6709 rtx loc
= mo
->u
.loc
;
6712 var_reg_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6713 else if (MEM_P (loc
))
6714 var_mem_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6720 rtx loc
= mo
->u
.loc
;
6724 if (GET_CODE (loc
) == CONCAT
)
6726 val
= XEXP (loc
, 0);
6727 vloc
= XEXP (loc
, 1);
6735 var
= PAT_VAR_LOCATION_DECL (vloc
);
6737 clobber_variable_part (out
, NULL_RTX
,
6738 dv_from_decl (var
), 0, NULL_RTX
);
6741 if (VAL_NEEDS_RESOLUTION (loc
))
6742 val_resolve (out
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
6743 set_variable_part (out
, val
, dv_from_decl (var
), 0,
6744 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6747 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
6748 set_variable_part (out
, PAT_VAR_LOCATION_LOC (vloc
),
6749 dv_from_decl (var
), 0,
6750 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6757 rtx loc
= mo
->u
.loc
;
6758 rtx val
, vloc
, uloc
;
6760 vloc
= uloc
= XEXP (loc
, 1);
6761 val
= XEXP (loc
, 0);
6763 if (GET_CODE (val
) == CONCAT
)
6765 uloc
= XEXP (val
, 1);
6766 val
= XEXP (val
, 0);
6769 if (VAL_NEEDS_RESOLUTION (loc
))
6770 val_resolve (out
, val
, vloc
, insn
);
6772 val_store (out
, val
, uloc
, insn
, false);
6774 if (VAL_HOLDS_TRACK_EXPR (loc
))
6776 if (GET_CODE (uloc
) == REG
)
6777 var_reg_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6779 else if (GET_CODE (uloc
) == MEM
)
6780 var_mem_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6788 rtx loc
= mo
->u
.loc
;
6789 rtx val
, vloc
, uloc
;
6793 uloc
= XEXP (vloc
, 1);
6794 val
= XEXP (vloc
, 0);
6797 if (GET_CODE (uloc
) == SET
)
6799 dstv
= SET_DEST (uloc
);
6800 srcv
= SET_SRC (uloc
);
6808 if (GET_CODE (val
) == CONCAT
)
6810 dstv
= vloc
= XEXP (val
, 1);
6811 val
= XEXP (val
, 0);
6814 if (GET_CODE (vloc
) == SET
)
6816 srcv
= SET_SRC (vloc
);
6818 gcc_assert (val
!= srcv
);
6819 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
6821 dstv
= vloc
= SET_DEST (vloc
);
6823 if (VAL_NEEDS_RESOLUTION (loc
))
6824 val_resolve (out
, val
, srcv
, insn
);
6826 else if (VAL_NEEDS_RESOLUTION (loc
))
6828 gcc_assert (GET_CODE (uloc
) == SET
6829 && GET_CODE (SET_SRC (uloc
)) == REG
);
6830 val_resolve (out
, val
, SET_SRC (uloc
), insn
);
6833 if (VAL_HOLDS_TRACK_EXPR (loc
))
6835 if (VAL_EXPR_IS_CLOBBERED (loc
))
6838 var_reg_delete (out
, uloc
, true);
6839 else if (MEM_P (uloc
))
6841 gcc_assert (MEM_P (dstv
));
6842 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
6843 var_mem_delete (out
, dstv
, true);
6848 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
6849 rtx src
= NULL
, dst
= uloc
;
6850 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
6852 if (GET_CODE (uloc
) == SET
)
6854 src
= SET_SRC (uloc
);
6855 dst
= SET_DEST (uloc
);
6860 if (flag_var_tracking_uninit
)
6862 status
= find_src_status (in
, src
);
6864 if (status
== VAR_INIT_STATUS_UNKNOWN
)
6865 status
= find_src_status (out
, src
);
6868 src
= find_src_set_src (in
, src
);
6872 var_reg_delete_and_set (out
, dst
, !copied_p
,
6874 else if (MEM_P (dst
))
6876 gcc_assert (MEM_P (dstv
));
6877 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
6878 var_mem_delete_and_set (out
, dstv
, !copied_p
,
6883 else if (REG_P (uloc
))
6884 var_regno_delete (out
, REGNO (uloc
));
6885 else if (MEM_P (uloc
))
6887 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
6888 gcc_checking_assert (dstv
== vloc
);
6890 clobber_overlapping_mems (out
, vloc
);
6893 val_store (out
, val
, dstv
, insn
, true);
6899 rtx loc
= mo
->u
.loc
;
6902 if (GET_CODE (loc
) == SET
)
6904 set_src
= SET_SRC (loc
);
6905 loc
= SET_DEST (loc
);
6909 var_reg_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6911 else if (MEM_P (loc
))
6912 var_mem_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6919 rtx loc
= mo
->u
.loc
;
6920 enum var_init_status src_status
;
6923 if (GET_CODE (loc
) == SET
)
6925 set_src
= SET_SRC (loc
);
6926 loc
= SET_DEST (loc
);
6929 if (! flag_var_tracking_uninit
)
6930 src_status
= VAR_INIT_STATUS_INITIALIZED
;
6933 src_status
= find_src_status (in
, set_src
);
6935 if (src_status
== VAR_INIT_STATUS_UNKNOWN
)
6936 src_status
= find_src_status (out
, set_src
);
6939 set_src
= find_src_set_src (in
, set_src
);
6942 var_reg_delete_and_set (out
, loc
, false, src_status
, set_src
);
6943 else if (MEM_P (loc
))
6944 var_mem_delete_and_set (out
, loc
, false, src_status
, set_src
);
6950 rtx loc
= mo
->u
.loc
;
6953 var_reg_delete (out
, loc
, false);
6954 else if (MEM_P (loc
))
6955 var_mem_delete (out
, loc
, false);
6961 rtx loc
= mo
->u
.loc
;
6964 var_reg_delete (out
, loc
, true);
6965 else if (MEM_P (loc
))
6966 var_mem_delete (out
, loc
, true);
6971 out
->stack_adjust
+= mo
->u
.adjust
;
6976 if (MAY_HAVE_DEBUG_INSNS
)
6978 delete local_get_addr_cache
;
6979 local_get_addr_cache
= NULL
;
6981 dataflow_set_equiv_regs (out
);
6982 shared_hash_htab (out
->vars
)
6983 ->traverse
<dataflow_set
*, canonicalize_values_mark
> (out
);
6984 shared_hash_htab (out
->vars
)
6985 ->traverse
<dataflow_set
*, canonicalize_values_star
> (out
);
6987 shared_hash_htab (out
->vars
)
6988 ->traverse
<dataflow_set
*, canonicalize_loc_order_check
> (out
);
6990 changed
= dataflow_set_different (&old_out
, out
);
6991 dataflow_set_destroy (&old_out
);
6995 /* Find the locations of variables in the whole function. */
6998 vt_find_locations (void)
7000 bb_heap_t
*worklist
= new bb_heap_t (LONG_MIN
);
7001 bb_heap_t
*pending
= new bb_heap_t (LONG_MIN
);
7002 sbitmap in_worklist
, in_pending
;
7009 int htabmax
= PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE
);
7010 bool success
= true;
7012 timevar_push (TV_VAR_TRACKING_DATAFLOW
);
7013 /* Compute reverse completion order of depth first search of the CFG
7014 so that the data-flow runs faster. */
7015 rc_order
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
7016 bb_order
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
7017 pre_and_rev_post_order_compute (NULL
, rc_order
, false);
7018 for (i
= 0; i
< n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
; i
++)
7019 bb_order
[rc_order
[i
]] = i
;
7022 auto_sbitmap
visited (last_basic_block_for_fn (cfun
));
7023 in_worklist
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
7024 in_pending
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
7025 bitmap_clear (in_worklist
);
7027 FOR_EACH_BB_FN (bb
, cfun
)
7028 pending
->insert (bb_order
[bb
->index
], bb
);
7029 bitmap_ones (in_pending
);
7031 while (success
&& !pending
->empty ())
7033 std::swap (worklist
, pending
);
7034 std::swap (in_worklist
, in_pending
);
7036 bitmap_clear (visited
);
7038 while (!worklist
->empty ())
7040 bb
= worklist
->extract_min ();
7041 bitmap_clear_bit (in_worklist
, bb
->index
);
7042 gcc_assert (!bitmap_bit_p (visited
, bb
->index
));
7043 if (!bitmap_bit_p (visited
, bb
->index
))
7047 int oldinsz
, oldoutsz
;
7049 bitmap_set_bit (visited
, bb
->index
);
7051 if (VTI (bb
)->in
.vars
)
7054 -= shared_hash_htab (VTI (bb
)->in
.vars
)->size ()
7055 + shared_hash_htab (VTI (bb
)->out
.vars
)->size ();
7056 oldinsz
= shared_hash_htab (VTI (bb
)->in
.vars
)->elements ();
7058 = shared_hash_htab (VTI (bb
)->out
.vars
)->elements ();
7061 oldinsz
= oldoutsz
= 0;
7063 if (MAY_HAVE_DEBUG_INSNS
)
7065 dataflow_set
*in
= &VTI (bb
)->in
, *first_out
= NULL
;
7066 bool first
= true, adjust
= false;
7068 /* Calculate the IN set as the intersection of
7069 predecessor OUT sets. */
7071 dataflow_set_clear (in
);
7072 dst_can_be_shared
= true;
7074 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7075 if (!VTI (e
->src
)->flooded
)
7076 gcc_assert (bb_order
[bb
->index
]
7077 <= bb_order
[e
->src
->index
]);
7080 dataflow_set_copy (in
, &VTI (e
->src
)->out
);
7081 first_out
= &VTI (e
->src
)->out
;
7086 dataflow_set_merge (in
, &VTI (e
->src
)->out
);
7092 dataflow_post_merge_adjust (in
, &VTI (bb
)->permp
);
7095 /* Merge and merge_adjust should keep entries in
7097 shared_hash_htab (in
->vars
)
7098 ->traverse
<dataflow_set
*,
7099 canonicalize_loc_order_check
> (in
);
7101 if (dst_can_be_shared
)
7103 shared_hash_destroy (in
->vars
);
7104 in
->vars
= shared_hash_copy (first_out
->vars
);
7108 VTI (bb
)->flooded
= true;
7112 /* Calculate the IN set as union of predecessor OUT sets. */
7113 dataflow_set_clear (&VTI (bb
)->in
);
7114 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7115 dataflow_set_union (&VTI (bb
)->in
, &VTI (e
->src
)->out
);
7118 changed
= compute_bb_dataflow (bb
);
7119 htabsz
+= shared_hash_htab (VTI (bb
)->in
.vars
)->size ()
7120 + shared_hash_htab (VTI (bb
)->out
.vars
)->size ();
7122 if (htabmax
&& htabsz
> htabmax
)
7124 if (MAY_HAVE_DEBUG_INSNS
)
7125 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7126 "variable tracking size limit exceeded with "
7127 "-fvar-tracking-assignments, retrying without");
7129 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7130 "variable tracking size limit exceeded");
7137 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7139 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7142 if (bitmap_bit_p (visited
, e
->dest
->index
))
7144 if (!bitmap_bit_p (in_pending
, e
->dest
->index
))
7146 /* Send E->DEST to next round. */
7147 bitmap_set_bit (in_pending
, e
->dest
->index
);
7148 pending
->insert (bb_order
[e
->dest
->index
],
7152 else if (!bitmap_bit_p (in_worklist
, e
->dest
->index
))
7154 /* Add E->DEST to current round. */
7155 bitmap_set_bit (in_worklist
, e
->dest
->index
);
7156 worklist
->insert (bb_order
[e
->dest
->index
],
7164 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7166 (int)shared_hash_htab (VTI (bb
)->in
.vars
)->size (),
7168 (int)shared_hash_htab (VTI (bb
)->out
.vars
)->size (),
7170 (int)worklist
->nodes (), (int)pending
->nodes (),
7173 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7175 fprintf (dump_file
, "BB %i IN:\n", bb
->index
);
7176 dump_dataflow_set (&VTI (bb
)->in
);
7177 fprintf (dump_file
, "BB %i OUT:\n", bb
->index
);
7178 dump_dataflow_set (&VTI (bb
)->out
);
7184 if (success
&& MAY_HAVE_DEBUG_INSNS
)
7185 FOR_EACH_BB_FN (bb
, cfun
)
7186 gcc_assert (VTI (bb
)->flooded
);
7191 sbitmap_free (in_worklist
);
7192 sbitmap_free (in_pending
);
7194 timevar_pop (TV_VAR_TRACKING_DATAFLOW
);
7198 /* Print the content of the LIST to dump file. */
7201 dump_attrs_list (attrs
*list
)
7203 for (; list
; list
= list
->next
)
7205 if (dv_is_decl_p (list
->dv
))
7206 print_mem_expr (dump_file
, dv_as_decl (list
->dv
));
7208 print_rtl_single (dump_file
, dv_as_value (list
->dv
));
7209 fprintf (dump_file
, "+" HOST_WIDE_INT_PRINT_DEC
, list
->offset
);
7211 fprintf (dump_file
, "\n");
7214 /* Print the information about variable *SLOT to dump file. */
7217 dump_var_tracking_slot (variable
**slot
, void *data ATTRIBUTE_UNUSED
)
7219 variable
*var
= *slot
;
7223 /* Continue traversing the hash table. */
7227 /* Print the information about variable VAR to dump file. */
7230 dump_var (variable
*var
)
7233 location_chain
*node
;
7235 if (dv_is_decl_p (var
->dv
))
7237 const_tree decl
= dv_as_decl (var
->dv
);
7239 if (DECL_NAME (decl
))
7241 fprintf (dump_file
, " name: %s",
7242 IDENTIFIER_POINTER (DECL_NAME (decl
)));
7243 if (dump_flags
& TDF_UID
)
7244 fprintf (dump_file
, "D.%u", DECL_UID (decl
));
7246 else if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
7247 fprintf (dump_file
, " name: D#%u", DEBUG_TEMP_UID (decl
));
7249 fprintf (dump_file
, " name: D.%u", DECL_UID (decl
));
7250 fprintf (dump_file
, "\n");
7254 fputc (' ', dump_file
);
7255 print_rtl_single (dump_file
, dv_as_value (var
->dv
));
7258 for (i
= 0; i
< var
->n_var_parts
; i
++)
7260 fprintf (dump_file
, " offset %ld\n",
7261 (long)(var
->onepart
? 0 : VAR_PART_OFFSET (var
, i
)));
7262 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
7264 fprintf (dump_file
, " ");
7265 if (node
->init
== VAR_INIT_STATUS_UNINITIALIZED
)
7266 fprintf (dump_file
, "[uninit]");
7267 print_rtl_single (dump_file
, node
->loc
);
7272 /* Print the information about variables from hash table VARS to dump file. */
7275 dump_vars (variable_table_type
*vars
)
7277 if (vars
->elements () > 0)
7279 fprintf (dump_file
, "Variables:\n");
7280 vars
->traverse
<void *, dump_var_tracking_slot
> (NULL
);
7284 /* Print the dataflow set SET to dump file. */
7287 dump_dataflow_set (dataflow_set
*set
)
7291 fprintf (dump_file
, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC
"\n",
7293 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
7297 fprintf (dump_file
, "Reg %d:", i
);
7298 dump_attrs_list (set
->regs
[i
]);
7301 dump_vars (shared_hash_htab (set
->vars
));
7302 fprintf (dump_file
, "\n");
7305 /* Print the IN and OUT sets for each basic block to dump file. */
7308 dump_dataflow_sets (void)
7312 FOR_EACH_BB_FN (bb
, cfun
)
7314 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
7315 fprintf (dump_file
, "IN:\n");
7316 dump_dataflow_set (&VTI (bb
)->in
);
7317 fprintf (dump_file
, "OUT:\n");
7318 dump_dataflow_set (&VTI (bb
)->out
);
7322 /* Return the variable for DV in dropped_values, inserting one if
7323 requested with INSERT. */
7325 static inline variable
*
7326 variable_from_dropped (decl_or_value dv
, enum insert_option insert
)
7329 variable
*empty_var
;
7330 onepart_enum onepart
;
7332 slot
= dropped_values
->find_slot_with_hash (dv
, dv_htab_hash (dv
), insert
);
7340 gcc_checking_assert (insert
== INSERT
);
7342 onepart
= dv_onepart_p (dv
);
7344 gcc_checking_assert (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
);
7346 empty_var
= onepart_pool_allocate (onepart
);
7348 empty_var
->refcount
= 1;
7349 empty_var
->n_var_parts
= 0;
7350 empty_var
->onepart
= onepart
;
7351 empty_var
->in_changed_variables
= false;
7352 empty_var
->var_part
[0].loc_chain
= NULL
;
7353 empty_var
->var_part
[0].cur_loc
= NULL
;
7354 VAR_LOC_1PAUX (empty_var
) = NULL
;
7355 set_dv_changed (dv
, true);
7362 /* Recover the one-part aux from dropped_values. */
7364 static struct onepart_aux
*
7365 recover_dropped_1paux (variable
*var
)
7369 gcc_checking_assert (var
->onepart
);
7371 if (VAR_LOC_1PAUX (var
))
7372 return VAR_LOC_1PAUX (var
);
7374 if (var
->onepart
== ONEPART_VDECL
)
7377 dvar
= variable_from_dropped (var
->dv
, NO_INSERT
);
7382 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (dvar
);
7383 VAR_LOC_1PAUX (dvar
) = NULL
;
7385 return VAR_LOC_1PAUX (var
);
7388 /* Add variable VAR to the hash table of changed variables and
7389 if it has no locations delete it from SET's hash table. */
7392 variable_was_changed (variable
*var
, dataflow_set
*set
)
7394 hashval_t hash
= dv_htab_hash (var
->dv
);
7400 /* Remember this decl or VALUE has been added to changed_variables. */
7401 set_dv_changed (var
->dv
, true);
7403 slot
= changed_variables
->find_slot_with_hash (var
->dv
, hash
, INSERT
);
7407 variable
*old_var
= *slot
;
7408 gcc_assert (old_var
->in_changed_variables
);
7409 old_var
->in_changed_variables
= false;
7410 if (var
!= old_var
&& var
->onepart
)
7412 /* Restore the auxiliary info from an empty variable
7413 previously created for changed_variables, so it is
7415 gcc_checking_assert (!VAR_LOC_1PAUX (var
));
7416 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (old_var
);
7417 VAR_LOC_1PAUX (old_var
) = NULL
;
7419 variable_htab_free (*slot
);
7422 if (set
&& var
->n_var_parts
== 0)
7424 onepart_enum onepart
= var
->onepart
;
7425 variable
*empty_var
= NULL
;
7426 variable
**dslot
= NULL
;
7428 if (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
)
7430 dslot
= dropped_values
->find_slot_with_hash (var
->dv
,
7431 dv_htab_hash (var
->dv
),
7437 gcc_checking_assert (!empty_var
->in_changed_variables
);
7438 if (!VAR_LOC_1PAUX (var
))
7440 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (empty_var
);
7441 VAR_LOC_1PAUX (empty_var
) = NULL
;
7444 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
7450 empty_var
= onepart_pool_allocate (onepart
);
7451 empty_var
->dv
= var
->dv
;
7452 empty_var
->refcount
= 1;
7453 empty_var
->n_var_parts
= 0;
7454 empty_var
->onepart
= onepart
;
7457 empty_var
->refcount
++;
7462 empty_var
->refcount
++;
7463 empty_var
->in_changed_variables
= true;
7467 empty_var
->var_part
[0].loc_chain
= NULL
;
7468 empty_var
->var_part
[0].cur_loc
= NULL
;
7469 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (var
);
7470 VAR_LOC_1PAUX (var
) = NULL
;
7476 if (var
->onepart
&& !VAR_LOC_1PAUX (var
))
7477 recover_dropped_1paux (var
);
7479 var
->in_changed_variables
= true;
7486 if (var
->n_var_parts
== 0)
7491 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
7494 if (shared_hash_shared (set
->vars
))
7495 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
,
7497 shared_hash_htab (set
->vars
)->clear_slot (slot
);
7503 /* Look for the index in VAR->var_part corresponding to OFFSET.
7504 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7505 referenced int will be set to the index that the part has or should
7506 have, if it should be inserted. */
7509 find_variable_location_part (variable
*var
, HOST_WIDE_INT offset
,
7510 int *insertion_point
)
7519 if (insertion_point
)
7520 *insertion_point
= 0;
7522 return var
->n_var_parts
- 1;
7525 /* Find the location part. */
7527 high
= var
->n_var_parts
;
7530 pos
= (low
+ high
) / 2;
7531 if (VAR_PART_OFFSET (var
, pos
) < offset
)
7538 if (insertion_point
)
7539 *insertion_point
= pos
;
7541 if (pos
< var
->n_var_parts
&& VAR_PART_OFFSET (var
, pos
) == offset
)
7548 set_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7549 decl_or_value dv
, HOST_WIDE_INT offset
,
7550 enum var_init_status initialized
, rtx set_src
)
7553 location_chain
*node
, *next
;
7554 location_chain
**nextp
;
7556 onepart_enum onepart
;
7561 onepart
= var
->onepart
;
7563 onepart
= dv_onepart_p (dv
);
7565 gcc_checking_assert (offset
== 0 || !onepart
);
7566 gcc_checking_assert (loc
!= dv_as_opaque (dv
));
7568 if (! flag_var_tracking_uninit
)
7569 initialized
= VAR_INIT_STATUS_INITIALIZED
;
7573 /* Create new variable information. */
7574 var
= onepart_pool_allocate (onepart
);
7577 var
->n_var_parts
= 1;
7578 var
->onepart
= onepart
;
7579 var
->in_changed_variables
= false;
7581 VAR_LOC_1PAUX (var
) = NULL
;
7583 VAR_PART_OFFSET (var
, 0) = offset
;
7584 var
->var_part
[0].loc_chain
= NULL
;
7585 var
->var_part
[0].cur_loc
= NULL
;
7588 nextp
= &var
->var_part
[0].loc_chain
;
7594 gcc_assert (dv_as_opaque (var
->dv
) == dv_as_opaque (dv
));
7598 if (GET_CODE (loc
) == VALUE
)
7600 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7601 nextp
= &node
->next
)
7602 if (GET_CODE (node
->loc
) == VALUE
)
7604 if (node
->loc
== loc
)
7609 if (canon_value_cmp (node
->loc
, loc
))
7617 else if (REG_P (node
->loc
) || MEM_P (node
->loc
))
7625 else if (REG_P (loc
))
7627 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7628 nextp
= &node
->next
)
7629 if (REG_P (node
->loc
))
7631 if (REGNO (node
->loc
) < REGNO (loc
))
7635 if (REGNO (node
->loc
) == REGNO (loc
))
7648 else if (MEM_P (loc
))
7650 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7651 nextp
= &node
->next
)
7652 if (REG_P (node
->loc
))
7654 else if (MEM_P (node
->loc
))
7656 if ((r
= loc_cmp (XEXP (node
->loc
, 0), XEXP (loc
, 0))) >= 0)
7668 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7669 nextp
= &node
->next
)
7670 if ((r
= loc_cmp (node
->loc
, loc
)) >= 0)
7678 if (shared_var_p (var
, set
->vars
))
7680 slot
= unshare_variable (set
, slot
, var
, initialized
);
7682 for (nextp
= &var
->var_part
[0].loc_chain
; c
;
7683 nextp
= &(*nextp
)->next
)
7685 gcc_assert ((!node
&& !*nextp
) || node
->loc
== (*nextp
)->loc
);
7692 gcc_assert (dv_as_decl (var
->dv
) == dv_as_decl (dv
));
7694 pos
= find_variable_location_part (var
, offset
, &inspos
);
7698 node
= var
->var_part
[pos
].loc_chain
;
7701 && ((REG_P (node
->loc
) && REG_P (loc
)
7702 && REGNO (node
->loc
) == REGNO (loc
))
7703 || rtx_equal_p (node
->loc
, loc
)))
7705 /* LOC is in the beginning of the chain so we have nothing
7707 if (node
->init
< initialized
)
7708 node
->init
= initialized
;
7709 if (set_src
!= NULL
)
7710 node
->set_src
= set_src
;
7716 /* We have to make a copy of a shared variable. */
7717 if (shared_var_p (var
, set
->vars
))
7719 slot
= unshare_variable (set
, slot
, var
, initialized
);
7726 /* We have not found the location part, new one will be created. */
7728 /* We have to make a copy of the shared variable. */
7729 if (shared_var_p (var
, set
->vars
))
7731 slot
= unshare_variable (set
, slot
, var
, initialized
);
7735 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7736 thus there are at most MAX_VAR_PARTS different offsets. */
7737 gcc_assert (var
->n_var_parts
< MAX_VAR_PARTS
7738 && (!var
->n_var_parts
|| !onepart
));
7740 /* We have to move the elements of array starting at index
7741 inspos to the next position. */
7742 for (pos
= var
->n_var_parts
; pos
> inspos
; pos
--)
7743 var
->var_part
[pos
] = var
->var_part
[pos
- 1];
7746 gcc_checking_assert (!onepart
);
7747 VAR_PART_OFFSET (var
, pos
) = offset
;
7748 var
->var_part
[pos
].loc_chain
= NULL
;
7749 var
->var_part
[pos
].cur_loc
= NULL
;
7752 /* Delete the location from the list. */
7753 nextp
= &var
->var_part
[pos
].loc_chain
;
7754 for (node
= var
->var_part
[pos
].loc_chain
; node
; node
= next
)
7757 if ((REG_P (node
->loc
) && REG_P (loc
)
7758 && REGNO (node
->loc
) == REGNO (loc
))
7759 || rtx_equal_p (node
->loc
, loc
))
7761 /* Save these values, to assign to the new node, before
7762 deleting this one. */
7763 if (node
->init
> initialized
)
7764 initialized
= node
->init
;
7765 if (node
->set_src
!= NULL
&& set_src
== NULL
)
7766 set_src
= node
->set_src
;
7767 if (var
->var_part
[pos
].cur_loc
== node
->loc
)
7768 var
->var_part
[pos
].cur_loc
= NULL
;
7774 nextp
= &node
->next
;
7777 nextp
= &var
->var_part
[pos
].loc_chain
;
7780 /* Add the location to the beginning. */
7781 node
= new location_chain
;
7783 node
->init
= initialized
;
7784 node
->set_src
= set_src
;
7785 node
->next
= *nextp
;
7788 /* If no location was emitted do so. */
7789 if (var
->var_part
[pos
].cur_loc
== NULL
)
7790 variable_was_changed (var
, set
);
7795 /* Set the part of variable's location in the dataflow set SET. The
7796 variable part is specified by variable's declaration in DV and
7797 offset OFFSET and the part's location by LOC. IOPT should be
7798 NO_INSERT if the variable is known to be in SET already and the
7799 variable hash table must not be resized, and INSERT otherwise. */
7802 set_variable_part (dataflow_set
*set
, rtx loc
,
7803 decl_or_value dv
, HOST_WIDE_INT offset
,
7804 enum var_init_status initialized
, rtx set_src
,
7805 enum insert_option iopt
)
7809 if (iopt
== NO_INSERT
)
7810 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7813 slot
= shared_hash_find_slot (set
->vars
, dv
);
7815 slot
= shared_hash_find_slot_unshare (&set
->vars
, dv
, iopt
);
7817 set_slot_part (set
, loc
, slot
, dv
, offset
, initialized
, set_src
);
7820 /* Remove all recorded register locations for the given variable part
7821 from dataflow set SET, except for those that are identical to loc.
7822 The variable part is specified by variable's declaration or value
7823 DV and offset OFFSET. */
7826 clobber_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7827 HOST_WIDE_INT offset
, rtx set_src
)
7829 variable
*var
= *slot
;
7830 int pos
= find_variable_location_part (var
, offset
, NULL
);
7834 location_chain
*node
, *next
;
7836 /* Remove the register locations from the dataflow set. */
7837 next
= var
->var_part
[pos
].loc_chain
;
7838 for (node
= next
; node
; node
= next
)
7841 if (node
->loc
!= loc
7842 && (!flag_var_tracking_uninit
7845 || !rtx_equal_p (set_src
, node
->set_src
)))
7847 if (REG_P (node
->loc
))
7849 attrs
*anode
, *anext
;
7852 /* Remove the variable part from the register's
7853 list, but preserve any other variable parts
7854 that might be regarded as live in that same
7856 anextp
= &set
->regs
[REGNO (node
->loc
)];
7857 for (anode
= *anextp
; anode
; anode
= anext
)
7859 anext
= anode
->next
;
7860 if (dv_as_opaque (anode
->dv
) == dv_as_opaque (var
->dv
)
7861 && anode
->offset
== offset
)
7867 anextp
= &anode
->next
;
7871 slot
= delete_slot_part (set
, node
->loc
, slot
, offset
);
7879 /* Remove all recorded register locations for the given variable part
7880 from dataflow set SET, except for those that are identical to loc.
7881 The variable part is specified by variable's declaration or value
7882 DV and offset OFFSET. */
7885 clobber_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7886 HOST_WIDE_INT offset
, rtx set_src
)
7890 if (!dv_as_opaque (dv
)
7891 || (!dv_is_value_p (dv
) && ! DECL_P (dv_as_decl (dv
))))
7894 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7898 clobber_slot_part (set
, loc
, slot
, offset
, set_src
);
7901 /* Delete the part of variable's location from dataflow set SET. The
7902 variable part is specified by its SET->vars slot SLOT and offset
7903 OFFSET and the part's location by LOC. */
7906 delete_slot_part (dataflow_set
*set
, rtx loc
, variable
**slot
,
7907 HOST_WIDE_INT offset
)
7909 variable
*var
= *slot
;
7910 int pos
= find_variable_location_part (var
, offset
, NULL
);
7914 location_chain
*node
, *next
;
7915 location_chain
**nextp
;
7919 if (shared_var_p (var
, set
->vars
))
7921 /* If the variable contains the location part we have to
7922 make a copy of the variable. */
7923 for (node
= var
->var_part
[pos
].loc_chain
; node
;
7926 if ((REG_P (node
->loc
) && REG_P (loc
)
7927 && REGNO (node
->loc
) == REGNO (loc
))
7928 || rtx_equal_p (node
->loc
, loc
))
7930 slot
= unshare_variable (set
, slot
, var
,
7931 VAR_INIT_STATUS_UNKNOWN
);
7938 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7939 cur_loc
= VAR_LOC_FROM (var
);
7941 cur_loc
= var
->var_part
[pos
].cur_loc
;
7943 /* Delete the location part. */
7945 nextp
= &var
->var_part
[pos
].loc_chain
;
7946 for (node
= *nextp
; node
; node
= next
)
7949 if ((REG_P (node
->loc
) && REG_P (loc
)
7950 && REGNO (node
->loc
) == REGNO (loc
))
7951 || rtx_equal_p (node
->loc
, loc
))
7953 /* If we have deleted the location which was last emitted
7954 we have to emit new location so add the variable to set
7955 of changed variables. */
7956 if (cur_loc
== node
->loc
)
7959 var
->var_part
[pos
].cur_loc
= NULL
;
7960 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7961 VAR_LOC_FROM (var
) = NULL
;
7968 nextp
= &node
->next
;
7971 if (var
->var_part
[pos
].loc_chain
== NULL
)
7975 while (pos
< var
->n_var_parts
)
7977 var
->var_part
[pos
] = var
->var_part
[pos
+ 1];
7982 variable_was_changed (var
, set
);
7988 /* Delete the part of variable's location from dataflow set SET. The
7989 variable part is specified by variable's declaration or value DV
7990 and offset OFFSET and the part's location by LOC. */
7993 delete_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7994 HOST_WIDE_INT offset
)
7996 variable
**slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
8000 delete_slot_part (set
, loc
, slot
, offset
);
8004 /* Structure for passing some other parameters to function
8005 vt_expand_loc_callback. */
8006 struct expand_loc_callback_data
8008 /* The variables and values active at this point. */
8009 variable_table_type
*vars
;
8011 /* Stack of values and debug_exprs under expansion, and their
8013 auto_vec
<rtx
, 4> expanding
;
8015 /* Stack of values and debug_exprs whose expansion hit recursion
8016 cycles. They will have VALUE_RECURSED_INTO marked when added to
8017 this list. This flag will be cleared if any of its dependencies
8018 resolves to a valid location. So, if the flag remains set at the
8019 end of the search, we know no valid location for this one can
8021 auto_vec
<rtx
, 4> pending
;
8023 /* The maximum depth among the sub-expressions under expansion.
8024 Zero indicates no expansion so far. */
8028 /* Allocate the one-part auxiliary data structure for VAR, with enough
8029 room for COUNT dependencies. */
8032 loc_exp_dep_alloc (variable
*var
, int count
)
8036 gcc_checking_assert (var
->onepart
);
8038 /* We can be called with COUNT == 0 to allocate the data structure
8039 without any dependencies, e.g. for the backlinks only. However,
8040 if we are specifying a COUNT, then the dependency list must have
8041 been emptied before. It would be possible to adjust pointers or
8042 force it empty here, but this is better done at an earlier point
8043 in the algorithm, so we instead leave an assertion to catch
8045 gcc_checking_assert (!count
8046 || VAR_LOC_DEP_VEC (var
) == NULL
8047 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8049 if (VAR_LOC_1PAUX (var
) && VAR_LOC_DEP_VEC (var
)->space (count
))
8052 allocsize
= offsetof (struct onepart_aux
, deps
)
8053 + vec
<loc_exp_dep
, va_heap
, vl_embed
>::embedded_size (count
);
8055 if (VAR_LOC_1PAUX (var
))
8057 VAR_LOC_1PAUX (var
) = XRESIZEVAR (struct onepart_aux
,
8058 VAR_LOC_1PAUX (var
), allocsize
);
8059 /* If the reallocation moves the onepaux structure, the
8060 back-pointer to BACKLINKS in the first list member will still
8061 point to its old location. Adjust it. */
8062 if (VAR_LOC_DEP_LST (var
))
8063 VAR_LOC_DEP_LST (var
)->pprev
= VAR_LOC_DEP_LSTP (var
);
8067 VAR_LOC_1PAUX (var
) = XNEWVAR (struct onepart_aux
, allocsize
);
8068 *VAR_LOC_DEP_LSTP (var
) = NULL
;
8069 VAR_LOC_FROM (var
) = NULL
;
8070 VAR_LOC_DEPTH (var
).complexity
= 0;
8071 VAR_LOC_DEPTH (var
).entryvals
= 0;
8073 VAR_LOC_DEP_VEC (var
)->embedded_init (count
);
8076 /* Remove all entries from the vector of active dependencies of VAR,
8077 removing them from the back-links lists too. */
8080 loc_exp_dep_clear (variable
*var
)
8082 while (VAR_LOC_DEP_VEC (var
) && !VAR_LOC_DEP_VEC (var
)->is_empty ())
8084 loc_exp_dep
*led
= &VAR_LOC_DEP_VEC (var
)->last ();
8086 led
->next
->pprev
= led
->pprev
;
8088 *led
->pprev
= led
->next
;
8089 VAR_LOC_DEP_VEC (var
)->pop ();
8093 /* Insert an active dependency from VAR on X to the vector of
8094 dependencies, and add the corresponding back-link to X's list of
8095 back-links in VARS. */
8098 loc_exp_insert_dep (variable
*var
, rtx x
, variable_table_type
*vars
)
8104 dv
= dv_from_rtx (x
);
8106 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8107 an additional look up? */
8108 xvar
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8112 xvar
= variable_from_dropped (dv
, NO_INSERT
);
8113 gcc_checking_assert (xvar
);
8116 /* No point in adding the same backlink more than once. This may
8117 arise if say the same value appears in two complex expressions in
8118 the same loc_list, or even more than once in a single
8120 if (VAR_LOC_DEP_LST (xvar
) && VAR_LOC_DEP_LST (xvar
)->dv
== var
->dv
)
8123 if (var
->onepart
== NOT_ONEPART
)
8124 led
= new loc_exp_dep
;
8128 memset (&empty
, 0, sizeof (empty
));
8129 VAR_LOC_DEP_VEC (var
)->quick_push (empty
);
8130 led
= &VAR_LOC_DEP_VEC (var
)->last ();
8135 loc_exp_dep_alloc (xvar
, 0);
8136 led
->pprev
= VAR_LOC_DEP_LSTP (xvar
);
8137 led
->next
= *led
->pprev
;
8139 led
->next
->pprev
= &led
->next
;
8143 /* Create active dependencies of VAR on COUNT values starting at
8144 VALUE, and corresponding back-links to the entries in VARS. Return
8145 true if we found any pending-recursion results. */
8148 loc_exp_dep_set (variable
*var
, rtx result
, rtx
*value
, int count
,
8149 variable_table_type
*vars
)
8151 bool pending_recursion
= false;
8153 gcc_checking_assert (VAR_LOC_DEP_VEC (var
) == NULL
8154 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8156 /* Set up all dependencies from last_child (as set up at the end of
8157 the loop above) to the end. */
8158 loc_exp_dep_alloc (var
, count
);
8164 if (!pending_recursion
)
8165 pending_recursion
= !result
&& VALUE_RECURSED_INTO (x
);
8167 loc_exp_insert_dep (var
, x
, vars
);
8170 return pending_recursion
;
8173 /* Notify the back-links of IVAR that are pending recursion that we
8174 have found a non-NIL value for it, so they are cleared for another
8175 attempt to compute a current location. */
8178 notify_dependents_of_resolved_value (variable
*ivar
, variable_table_type
*vars
)
8180 loc_exp_dep
*led
, *next
;
8182 for (led
= VAR_LOC_DEP_LST (ivar
); led
; led
= next
)
8184 decl_or_value dv
= led
->dv
;
8189 if (dv_is_value_p (dv
))
8191 rtx value
= dv_as_value (dv
);
8193 /* If we have already resolved it, leave it alone. */
8194 if (!VALUE_RECURSED_INTO (value
))
8197 /* Check that VALUE_RECURSED_INTO, true from the test above,
8198 implies NO_LOC_P. */
8199 gcc_checking_assert (NO_LOC_P (value
));
8201 /* We won't notify variables that are being expanded,
8202 because their dependency list is cleared before
8204 NO_LOC_P (value
) = false;
8205 VALUE_RECURSED_INTO (value
) = false;
8207 gcc_checking_assert (dv_changed_p (dv
));
8211 gcc_checking_assert (dv_onepart_p (dv
) != NOT_ONEPART
);
8212 if (!dv_changed_p (dv
))
8216 var
= vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8219 var
= variable_from_dropped (dv
, NO_INSERT
);
8222 notify_dependents_of_resolved_value (var
, vars
);
8225 next
->pprev
= led
->pprev
;
8233 static rtx
vt_expand_loc_callback (rtx x
, bitmap regs
,
8234 int max_depth
, void *data
);
8236 /* Return the combined depth, when one sub-expression evaluated to
8237 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8239 static inline expand_depth
8240 update_depth (expand_depth saved_depth
, expand_depth best_depth
)
8242 /* If we didn't find anything, stick with what we had. */
8243 if (!best_depth
.complexity
)
8246 /* If we found hadn't found anything, use the depth of the current
8247 expression. Do NOT add one extra level, we want to compute the
8248 maximum depth among sub-expressions. We'll increment it later,
8250 if (!saved_depth
.complexity
)
8253 /* Combine the entryval count so that regardless of which one we
8254 return, the entryval count is accurate. */
8255 best_depth
.entryvals
= saved_depth
.entryvals
8256 = best_depth
.entryvals
+ saved_depth
.entryvals
;
8258 if (saved_depth
.complexity
< best_depth
.complexity
)
8264 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8265 DATA for cselib expand callback. If PENDRECP is given, indicate in
8266 it whether any sub-expression couldn't be fully evaluated because
8267 it is pending recursion resolution. */
8270 vt_expand_var_loc_chain (variable
*var
, bitmap regs
, void *data
,
8273 struct expand_loc_callback_data
*elcd
8274 = (struct expand_loc_callback_data
*) data
;
8275 location_chain
*loc
, *next
;
8277 int first_child
, result_first_child
, last_child
;
8278 bool pending_recursion
;
8279 rtx loc_from
= NULL
;
8280 struct elt_loc_list
*cloc
= NULL
;
8281 expand_depth depth
= { 0, 0 }, saved_depth
= elcd
->depth
;
8282 int wanted_entryvals
, found_entryvals
= 0;
8284 /* Clear all backlinks pointing at this, so that we're not notified
8285 while we're active. */
8286 loc_exp_dep_clear (var
);
8289 if (var
->onepart
== ONEPART_VALUE
)
8291 cselib_val
*val
= CSELIB_VAL_PTR (dv_as_value (var
->dv
));
8293 gcc_checking_assert (cselib_preserved_value_p (val
));
8298 first_child
= result_first_child
= last_child
8299 = elcd
->expanding
.length ();
8301 wanted_entryvals
= found_entryvals
;
8303 /* Attempt to expand each available location in turn. */
8304 for (next
= loc
= var
->n_var_parts
? var
->var_part
[0].loc_chain
: NULL
;
8305 loc
|| cloc
; loc
= next
)
8307 result_first_child
= last_child
;
8311 loc_from
= cloc
->loc
;
8314 if (unsuitable_loc (loc_from
))
8319 loc_from
= loc
->loc
;
8323 gcc_checking_assert (!unsuitable_loc (loc_from
));
8325 elcd
->depth
.complexity
= elcd
->depth
.entryvals
= 0;
8326 result
= cselib_expand_value_rtx_cb (loc_from
, regs
, EXPR_DEPTH
,
8327 vt_expand_loc_callback
, data
);
8328 last_child
= elcd
->expanding
.length ();
8332 depth
= elcd
->depth
;
8334 gcc_checking_assert (depth
.complexity
8335 || result_first_child
== last_child
);
8337 if (last_child
- result_first_child
!= 1)
8339 if (!depth
.complexity
&& GET_CODE (result
) == ENTRY_VALUE
)
8344 if (depth
.complexity
<= EXPR_USE_DEPTH
)
8346 if (depth
.entryvals
<= wanted_entryvals
)
8348 else if (!found_entryvals
|| depth
.entryvals
< found_entryvals
)
8349 found_entryvals
= depth
.entryvals
;
8355 /* Set it up in case we leave the loop. */
8356 depth
.complexity
= depth
.entryvals
= 0;
8358 result_first_child
= first_child
;
8361 if (!loc_from
&& wanted_entryvals
< found_entryvals
)
8363 /* We found entries with ENTRY_VALUEs and skipped them. Since
8364 we could not find any expansions without ENTRY_VALUEs, but we
8365 found at least one with them, go back and get an entry with
8366 the minimum number ENTRY_VALUE count that we found. We could
8367 avoid looping, but since each sub-loc is already resolved,
8368 the re-expansion should be trivial. ??? Should we record all
8369 attempted locs as dependencies, so that we retry the
8370 expansion should any of them change, in the hope it can give
8371 us a new entry without an ENTRY_VALUE? */
8372 elcd
->expanding
.truncate (first_child
);
8376 /* Register all encountered dependencies as active. */
8377 pending_recursion
= loc_exp_dep_set
8378 (var
, result
, elcd
->expanding
.address () + result_first_child
,
8379 last_child
- result_first_child
, elcd
->vars
);
8381 elcd
->expanding
.truncate (first_child
);
8383 /* Record where the expansion came from. */
8384 gcc_checking_assert (!result
|| !pending_recursion
);
8385 VAR_LOC_FROM (var
) = loc_from
;
8386 VAR_LOC_DEPTH (var
) = depth
;
8388 gcc_checking_assert (!depth
.complexity
== !result
);
8390 elcd
->depth
= update_depth (saved_depth
, depth
);
8392 /* Indicate whether any of the dependencies are pending recursion
8395 *pendrecp
= pending_recursion
;
8397 if (!pendrecp
|| !pending_recursion
)
8398 var
->var_part
[0].cur_loc
= result
;
8403 /* Callback for cselib_expand_value, that looks for expressions
8404 holding the value in the var-tracking hash tables. Return X for
8405 standard processing, anything else is to be used as-is. */
8408 vt_expand_loc_callback (rtx x
, bitmap regs
,
8409 int max_depth ATTRIBUTE_UNUSED
,
8412 struct expand_loc_callback_data
*elcd
8413 = (struct expand_loc_callback_data
*) data
;
8417 bool pending_recursion
= false;
8418 bool from_empty
= false;
8420 switch (GET_CODE (x
))
8423 subreg
= cselib_expand_value_rtx_cb (SUBREG_REG (x
), regs
,
8425 vt_expand_loc_callback
, data
);
8430 result
= simplify_gen_subreg (GET_MODE (x
), subreg
,
8431 GET_MODE (SUBREG_REG (x
)),
8434 /* Invalid SUBREGs are ok in debug info. ??? We could try
8435 alternate expansions for the VALUE as well. */
8437 result
= gen_rtx_raw_SUBREG (GET_MODE (x
), subreg
, SUBREG_BYTE (x
));
8443 dv
= dv_from_rtx (x
);
8450 elcd
->expanding
.safe_push (x
);
8452 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8453 gcc_checking_assert (!VALUE_RECURSED_INTO (x
) || NO_LOC_P (x
));
8457 gcc_checking_assert (VALUE_RECURSED_INTO (x
) || !dv_changed_p (dv
));
8461 var
= elcd
->vars
->find_with_hash (dv
, dv_htab_hash (dv
));
8466 var
= variable_from_dropped (dv
, INSERT
);
8469 gcc_checking_assert (var
);
8471 if (!dv_changed_p (dv
))
8473 gcc_checking_assert (!NO_LOC_P (x
));
8474 gcc_checking_assert (var
->var_part
[0].cur_loc
);
8475 gcc_checking_assert (VAR_LOC_1PAUX (var
));
8476 gcc_checking_assert (VAR_LOC_1PAUX (var
)->depth
.complexity
);
8478 elcd
->depth
= update_depth (elcd
->depth
, VAR_LOC_1PAUX (var
)->depth
);
8480 return var
->var_part
[0].cur_loc
;
8483 VALUE_RECURSED_INTO (x
) = true;
8484 /* This is tentative, but it makes some tests simpler. */
8485 NO_LOC_P (x
) = true;
8487 gcc_checking_assert (var
->n_var_parts
== 1 || from_empty
);
8489 result
= vt_expand_var_loc_chain (var
, regs
, data
, &pending_recursion
);
8491 if (pending_recursion
)
8493 gcc_checking_assert (!result
);
8494 elcd
->pending
.safe_push (x
);
8498 NO_LOC_P (x
) = !result
;
8499 VALUE_RECURSED_INTO (x
) = false;
8500 set_dv_changed (dv
, false);
8503 notify_dependents_of_resolved_value (var
, elcd
->vars
);
8509 /* While expanding variables, we may encounter recursion cycles
8510 because of mutual (possibly indirect) dependencies between two
8511 particular variables (or values), say A and B. If we're trying to
8512 expand A when we get to B, which in turn attempts to expand A, if
8513 we can't find any other expansion for B, we'll add B to this
8514 pending-recursion stack, and tentatively return NULL for its
8515 location. This tentative value will be used for any other
8516 occurrences of B, unless A gets some other location, in which case
8517 it will notify B that it is worth another try at computing a
8518 location for it, and it will use the location computed for A then.
8519 At the end of the expansion, the tentative NULL locations become
8520 final for all members of PENDING that didn't get a notification.
8521 This function performs this finalization of NULL locations. */
8524 resolve_expansions_pending_recursion (vec
<rtx
, va_heap
> *pending
)
8526 while (!pending
->is_empty ())
8528 rtx x
= pending
->pop ();
8531 if (!VALUE_RECURSED_INTO (x
))
8534 gcc_checking_assert (NO_LOC_P (x
));
8535 VALUE_RECURSED_INTO (x
) = false;
8536 dv
= dv_from_rtx (x
);
8537 gcc_checking_assert (dv_changed_p (dv
));
8538 set_dv_changed (dv
, false);
8542 /* Initialize expand_loc_callback_data D with variable hash table V.
8543 It must be a macro because of alloca (vec stack). */
8544 #define INIT_ELCD(d, v) \
8548 (d).depth.complexity = (d).depth.entryvals = 0; \
8551 /* Finalize expand_loc_callback_data D, resolved to location L. */
8552 #define FINI_ELCD(d, l) \
8555 resolve_expansions_pending_recursion (&(d).pending); \
8556 (d).pending.release (); \
8557 (d).expanding.release (); \
8559 if ((l) && MEM_P (l)) \
8560 (l) = targetm.delegitimize_address (l); \
8564 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8565 equivalences in VARS, updating their CUR_LOCs in the process. */
8568 vt_expand_loc (rtx loc
, variable_table_type
*vars
)
8570 struct expand_loc_callback_data data
;
8573 if (!MAY_HAVE_DEBUG_INSNS
)
8576 INIT_ELCD (data
, vars
);
8578 result
= cselib_expand_value_rtx_cb (loc
, scratch_regs
, EXPR_DEPTH
,
8579 vt_expand_loc_callback
, &data
);
8581 FINI_ELCD (data
, result
);
8586 /* Expand the one-part VARiable to a location, using the equivalences
8587 in VARS, updating their CUR_LOCs in the process. */
8590 vt_expand_1pvar (variable
*var
, variable_table_type
*vars
)
8592 struct expand_loc_callback_data data
;
8595 gcc_checking_assert (var
->onepart
&& var
->n_var_parts
== 1);
8597 if (!dv_changed_p (var
->dv
))
8598 return var
->var_part
[0].cur_loc
;
8600 INIT_ELCD (data
, vars
);
8602 loc
= vt_expand_var_loc_chain (var
, scratch_regs
, &data
, NULL
);
8604 gcc_checking_assert (data
.expanding
.is_empty ());
8606 FINI_ELCD (data
, loc
);
8611 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8612 additional parameters: WHERE specifies whether the note shall be emitted
8613 before or after instruction INSN. */
8616 emit_note_insn_var_location (variable
**varp
, emit_note_data
*data
)
8618 variable
*var
= *varp
;
8619 rtx_insn
*insn
= data
->insn
;
8620 enum emit_note_where where
= data
->where
;
8621 variable_table_type
*vars
= data
->vars
;
8624 int i
, j
, n_var_parts
;
8626 enum var_init_status initialized
= VAR_INIT_STATUS_UNINITIALIZED
;
8627 HOST_WIDE_INT last_limit
;
8628 tree type_size_unit
;
8629 HOST_WIDE_INT offsets
[MAX_VAR_PARTS
];
8630 rtx loc
[MAX_VAR_PARTS
];
8634 gcc_checking_assert (var
->onepart
== NOT_ONEPART
8635 || var
->onepart
== ONEPART_VDECL
);
8637 decl
= dv_as_decl (var
->dv
);
8643 for (i
= 0; i
< var
->n_var_parts
; i
++)
8644 if (var
->var_part
[i
].cur_loc
== NULL
&& var
->var_part
[i
].loc_chain
)
8645 var
->var_part
[i
].cur_loc
= var
->var_part
[i
].loc_chain
->loc
;
8646 for (i
= 0; i
< var
->n_var_parts
; i
++)
8648 machine_mode mode
, wider_mode
;
8650 HOST_WIDE_INT offset
;
8652 if (i
== 0 && var
->onepart
)
8654 gcc_checking_assert (var
->n_var_parts
== 1);
8656 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8657 loc2
= vt_expand_1pvar (var
, vars
);
8661 if (last_limit
< VAR_PART_OFFSET (var
, i
))
8666 else if (last_limit
> VAR_PART_OFFSET (var
, i
))
8668 offset
= VAR_PART_OFFSET (var
, i
);
8669 loc2
= var
->var_part
[i
].cur_loc
;
8670 if (loc2
&& GET_CODE (loc2
) == MEM
8671 && GET_CODE (XEXP (loc2
, 0)) == VALUE
)
8673 rtx depval
= XEXP (loc2
, 0);
8675 loc2
= vt_expand_loc (loc2
, vars
);
8678 loc_exp_insert_dep (var
, depval
, vars
);
8685 gcc_checking_assert (GET_CODE (loc2
) != VALUE
);
8686 for (lc
= var
->var_part
[i
].loc_chain
; lc
; lc
= lc
->next
)
8687 if (var
->var_part
[i
].cur_loc
== lc
->loc
)
8689 initialized
= lc
->init
;
8695 offsets
[n_var_parts
] = offset
;
8701 loc
[n_var_parts
] = loc2
;
8702 mode
= GET_MODE (var
->var_part
[i
].cur_loc
);
8703 if (mode
== VOIDmode
&& var
->onepart
)
8704 mode
= DECL_MODE (decl
);
8705 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8707 /* Attempt to merge adjacent registers or memory. */
8708 wider_mode
= GET_MODE_WIDER_MODE (mode
);
8709 for (j
= i
+ 1; j
< var
->n_var_parts
; j
++)
8710 if (last_limit
<= VAR_PART_OFFSET (var
, j
))
8712 if (j
< var
->n_var_parts
8713 && wider_mode
!= VOIDmode
8714 && var
->var_part
[j
].cur_loc
8715 && mode
== GET_MODE (var
->var_part
[j
].cur_loc
)
8716 && (REG_P (loc
[n_var_parts
]) || MEM_P (loc
[n_var_parts
]))
8717 && last_limit
== (var
->onepart
? 0 : VAR_PART_OFFSET (var
, j
))
8718 && (loc2
= vt_expand_loc (var
->var_part
[j
].cur_loc
, vars
))
8719 && GET_CODE (loc
[n_var_parts
]) == GET_CODE (loc2
))
8723 if (REG_P (loc
[n_var_parts
])
8724 && hard_regno_nregs
[REGNO (loc
[n_var_parts
])][mode
] * 2
8725 == hard_regno_nregs
[REGNO (loc
[n_var_parts
])][wider_mode
]
8726 && end_hard_regno (mode
, REGNO (loc
[n_var_parts
]))
8729 if (! WORDS_BIG_ENDIAN
&& ! BYTES_BIG_ENDIAN
)
8730 new_loc
= simplify_subreg (wider_mode
, loc
[n_var_parts
],
8732 else if (WORDS_BIG_ENDIAN
&& BYTES_BIG_ENDIAN
)
8733 new_loc
= simplify_subreg (wider_mode
, loc2
, mode
, 0);
8736 if (!REG_P (new_loc
)
8737 || REGNO (new_loc
) != REGNO (loc
[n_var_parts
]))
8740 REG_ATTRS (new_loc
) = REG_ATTRS (loc
[n_var_parts
]);
8743 else if (MEM_P (loc
[n_var_parts
])
8744 && GET_CODE (XEXP (loc2
, 0)) == PLUS
8745 && REG_P (XEXP (XEXP (loc2
, 0), 0))
8746 && CONST_INT_P (XEXP (XEXP (loc2
, 0), 1)))
8748 if ((REG_P (XEXP (loc
[n_var_parts
], 0))
8749 && rtx_equal_p (XEXP (loc
[n_var_parts
], 0),
8750 XEXP (XEXP (loc2
, 0), 0))
8751 && INTVAL (XEXP (XEXP (loc2
, 0), 1))
8752 == GET_MODE_SIZE (mode
))
8753 || (GET_CODE (XEXP (loc
[n_var_parts
], 0)) == PLUS
8754 && CONST_INT_P (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8755 && rtx_equal_p (XEXP (XEXP (loc
[n_var_parts
], 0), 0),
8756 XEXP (XEXP (loc2
, 0), 0))
8757 && INTVAL (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8758 + GET_MODE_SIZE (mode
)
8759 == INTVAL (XEXP (XEXP (loc2
, 0), 1))))
8760 new_loc
= adjust_address_nv (loc
[n_var_parts
],
8766 loc
[n_var_parts
] = new_loc
;
8768 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8774 type_size_unit
= TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8775 if ((unsigned HOST_WIDE_INT
) last_limit
< TREE_INT_CST_LOW (type_size_unit
))
8778 if (! flag_var_tracking_uninit
)
8779 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8783 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, NULL_RTX
, initialized
);
8784 else if (n_var_parts
== 1)
8788 if (offsets
[0] || GET_CODE (loc
[0]) == PARALLEL
)
8789 expr_list
= gen_rtx_EXPR_LIST (VOIDmode
, loc
[0], GEN_INT (offsets
[0]));
8793 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, expr_list
, initialized
);
8795 else if (n_var_parts
)
8799 for (i
= 0; i
< n_var_parts
; i
++)
8801 = gen_rtx_EXPR_LIST (VOIDmode
, loc
[i
], GEN_INT (offsets
[i
]));
8803 parallel
= gen_rtx_PARALLEL (VOIDmode
,
8804 gen_rtvec_v (n_var_parts
, loc
));
8805 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
,
8806 parallel
, initialized
);
8809 if (where
!= EMIT_NOTE_BEFORE_INSN
)
8811 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8812 if (where
== EMIT_NOTE_AFTER_CALL_INSN
)
8813 NOTE_DURING_CALL_P (note
) = true;
8817 /* Make sure that the call related notes come first. */
8818 while (NEXT_INSN (insn
)
8820 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8821 && NOTE_DURING_CALL_P (insn
))
8822 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8823 insn
= NEXT_INSN (insn
);
8825 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8826 && NOTE_DURING_CALL_P (insn
))
8827 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8828 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8830 note
= emit_note_before (NOTE_INSN_VAR_LOCATION
, insn
);
8832 NOTE_VAR_LOCATION (note
) = note_vl
;
8834 set_dv_changed (var
->dv
, false);
8835 gcc_assert (var
->in_changed_variables
);
8836 var
->in_changed_variables
= false;
8837 changed_variables
->clear_slot (varp
);
8839 /* Continue traversing the hash table. */
8843 /* While traversing changed_variables, push onto DATA (a stack of RTX
8844 values) entries that aren't user variables. */
8847 var_track_values_to_stack (variable
**slot
,
8848 vec
<rtx
, va_heap
> *changed_values_stack
)
8850 variable
*var
= *slot
;
8852 if (var
->onepart
== ONEPART_VALUE
)
8853 changed_values_stack
->safe_push (dv_as_value (var
->dv
));
8854 else if (var
->onepart
== ONEPART_DEXPR
)
8855 changed_values_stack
->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var
->dv
)));
8860 /* Remove from changed_variables the entry whose DV corresponds to
8861 value or debug_expr VAL. */
8863 remove_value_from_changed_variables (rtx val
)
8865 decl_or_value dv
= dv_from_rtx (val
);
8869 slot
= changed_variables
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8872 var
->in_changed_variables
= false;
8873 changed_variables
->clear_slot (slot
);
8876 /* If VAL (a value or debug_expr) has backlinks to variables actively
8877 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8878 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8879 have dependencies of their own to notify. */
8882 notify_dependents_of_changed_value (rtx val
, variable_table_type
*htab
,
8883 vec
<rtx
, va_heap
> *changed_values_stack
)
8888 decl_or_value dv
= dv_from_rtx (val
);
8890 slot
= changed_variables
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8893 slot
= htab
->find_slot_with_hash (dv
, dv_htab_hash (dv
), NO_INSERT
);
8895 slot
= dropped_values
->find_slot_with_hash (dv
, dv_htab_hash (dv
),
8899 while ((led
= VAR_LOC_DEP_LST (var
)))
8901 decl_or_value ldv
= led
->dv
;
8904 /* Deactivate and remove the backlink, as it was “used up”. It
8905 makes no sense to attempt to notify the same entity again:
8906 either it will be recomputed and re-register an active
8907 dependency, or it will still have the changed mark. */
8909 led
->next
->pprev
= led
->pprev
;
8911 *led
->pprev
= led
->next
;
8915 if (dv_changed_p (ldv
))
8918 switch (dv_onepart_p (ldv
))
8922 set_dv_changed (ldv
, true);
8923 changed_values_stack
->safe_push (dv_as_rtx (ldv
));
8927 ivar
= htab
->find_with_hash (ldv
, dv_htab_hash (ldv
));
8928 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar
));
8929 variable_was_changed (ivar
, NULL
);
8934 ivar
= htab
->find_with_hash (ldv
, dv_htab_hash (ldv
));
8937 int i
= ivar
->n_var_parts
;
8940 rtx loc
= ivar
->var_part
[i
].cur_loc
;
8942 if (loc
&& GET_CODE (loc
) == MEM
8943 && XEXP (loc
, 0) == val
)
8945 variable_was_changed (ivar
, NULL
);
8958 /* Take out of changed_variables any entries that don't refer to use
8959 variables. Back-propagate change notifications from values and
8960 debug_exprs to their active dependencies in HTAB or in
8961 CHANGED_VARIABLES. */
8964 process_changed_values (variable_table_type
*htab
)
8968 auto_vec
<rtx
, 20> changed_values_stack
;
8970 /* Move values from changed_variables to changed_values_stack. */
8972 ->traverse
<vec
<rtx
, va_heap
>*, var_track_values_to_stack
>
8973 (&changed_values_stack
);
8975 /* Back-propagate change notifications in values while popping
8976 them from the stack. */
8977 for (n
= i
= changed_values_stack
.length ();
8978 i
> 0; i
= changed_values_stack
.length ())
8980 val
= changed_values_stack
.pop ();
8981 notify_dependents_of_changed_value (val
, htab
, &changed_values_stack
);
8983 /* This condition will hold when visiting each of the entries
8984 originally in changed_variables. We can't remove them
8985 earlier because this could drop the backlinks before we got a
8986 chance to use them. */
8989 remove_value_from_changed_variables (val
);
8995 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
8996 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
8997 the notes shall be emitted before of after instruction INSN. */
9000 emit_notes_for_changes (rtx_insn
*insn
, enum emit_note_where where
,
9003 emit_note_data data
;
9004 variable_table_type
*htab
= shared_hash_htab (vars
);
9006 if (!changed_variables
->elements ())
9009 if (MAY_HAVE_DEBUG_INSNS
)
9010 process_changed_values (htab
);
9017 ->traverse
<emit_note_data
*, emit_note_insn_var_location
> (&data
);
9020 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
9021 same variable in hash table DATA or is not there at all. */
9024 emit_notes_for_differences_1 (variable
**slot
, variable_table_type
*new_vars
)
9026 variable
*old_var
, *new_var
;
9029 new_var
= new_vars
->find_with_hash (old_var
->dv
, dv_htab_hash (old_var
->dv
));
9033 /* Variable has disappeared. */
9034 variable
*empty_var
= NULL
;
9036 if (old_var
->onepart
== ONEPART_VALUE
9037 || old_var
->onepart
== ONEPART_DEXPR
)
9039 empty_var
= variable_from_dropped (old_var
->dv
, NO_INSERT
);
9042 gcc_checking_assert (!empty_var
->in_changed_variables
);
9043 if (!VAR_LOC_1PAUX (old_var
))
9045 VAR_LOC_1PAUX (old_var
) = VAR_LOC_1PAUX (empty_var
);
9046 VAR_LOC_1PAUX (empty_var
) = NULL
;
9049 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
9055 empty_var
= onepart_pool_allocate (old_var
->onepart
);
9056 empty_var
->dv
= old_var
->dv
;
9057 empty_var
->refcount
= 0;
9058 empty_var
->n_var_parts
= 0;
9059 empty_var
->onepart
= old_var
->onepart
;
9060 empty_var
->in_changed_variables
= false;
9063 if (empty_var
->onepart
)
9065 /* Propagate the auxiliary data to (ultimately)
9066 changed_variables. */
9067 empty_var
->var_part
[0].loc_chain
= NULL
;
9068 empty_var
->var_part
[0].cur_loc
= NULL
;
9069 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (old_var
);
9070 VAR_LOC_1PAUX (old_var
) = NULL
;
9072 variable_was_changed (empty_var
, NULL
);
9073 /* Continue traversing the hash table. */
9076 /* Update cur_loc and one-part auxiliary data, before new_var goes
9077 through variable_was_changed. */
9078 if (old_var
!= new_var
&& new_var
->onepart
)
9080 gcc_checking_assert (VAR_LOC_1PAUX (new_var
) == NULL
);
9081 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (old_var
);
9082 VAR_LOC_1PAUX (old_var
) = NULL
;
9083 new_var
->var_part
[0].cur_loc
= old_var
->var_part
[0].cur_loc
;
9085 if (variable_different_p (old_var
, new_var
))
9086 variable_was_changed (new_var
, NULL
);
9088 /* Continue traversing the hash table. */
9092 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9096 emit_notes_for_differences_2 (variable
**slot
, variable_table_type
*old_vars
)
9098 variable
*old_var
, *new_var
;
9101 old_var
= old_vars
->find_with_hash (new_var
->dv
, dv_htab_hash (new_var
->dv
));
9105 for (i
= 0; i
< new_var
->n_var_parts
; i
++)
9106 new_var
->var_part
[i
].cur_loc
= NULL
;
9107 variable_was_changed (new_var
, NULL
);
9110 /* Continue traversing the hash table. */
9114 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9118 emit_notes_for_differences (rtx_insn
*insn
, dataflow_set
*old_set
,
9119 dataflow_set
*new_set
)
9121 shared_hash_htab (old_set
->vars
)
9122 ->traverse
<variable_table_type
*, emit_notes_for_differences_1
>
9123 (shared_hash_htab (new_set
->vars
));
9124 shared_hash_htab (new_set
->vars
)
9125 ->traverse
<variable_table_type
*, emit_notes_for_differences_2
>
9126 (shared_hash_htab (old_set
->vars
));
9127 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, new_set
->vars
);
9130 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9133 next_non_note_insn_var_location (rtx_insn
*insn
)
9137 insn
= NEXT_INSN (insn
);
9140 || NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
)
9147 /* Emit the notes for changes of location parts in the basic block BB. */
9150 emit_notes_in_bb (basic_block bb
, dataflow_set
*set
)
9153 micro_operation
*mo
;
9155 dataflow_set_clear (set
);
9156 dataflow_set_copy (set
, &VTI (bb
)->in
);
9158 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
9160 rtx_insn
*insn
= mo
->insn
;
9161 rtx_insn
*next_insn
= next_non_note_insn_var_location (insn
);
9166 dataflow_set_clear_at_call (set
, insn
);
9167 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_CALL_INSN
, set
->vars
);
9169 rtx arguments
= mo
->u
.loc
, *p
= &arguments
;
9173 XEXP (XEXP (*p
, 0), 1)
9174 = vt_expand_loc (XEXP (XEXP (*p
, 0), 1),
9175 shared_hash_htab (set
->vars
));
9176 /* If expansion is successful, keep it in the list. */
9177 if (XEXP (XEXP (*p
, 0), 1))
9179 /* Otherwise, if the following item is data_value for it,
9181 else if (XEXP (*p
, 1)
9182 && REG_P (XEXP (XEXP (*p
, 0), 0))
9183 && MEM_P (XEXP (XEXP (XEXP (*p
, 1), 0), 0))
9184 && REG_P (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0), 0),
9186 && REGNO (XEXP (XEXP (*p
, 0), 0))
9187 == REGNO (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0),
9189 *p
= XEXP (XEXP (*p
, 1), 1);
9190 /* Just drop this item. */
9194 note
= emit_note_after (NOTE_INSN_CALL_ARG_LOCATION
, insn
);
9195 NOTE_VAR_LOCATION (note
) = arguments
;
9201 rtx loc
= mo
->u
.loc
;
9204 var_reg_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9206 var_mem_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9208 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9214 rtx loc
= mo
->u
.loc
;
9218 if (GET_CODE (loc
) == CONCAT
)
9220 val
= XEXP (loc
, 0);
9221 vloc
= XEXP (loc
, 1);
9229 var
= PAT_VAR_LOCATION_DECL (vloc
);
9231 clobber_variable_part (set
, NULL_RTX
,
9232 dv_from_decl (var
), 0, NULL_RTX
);
9235 if (VAL_NEEDS_RESOLUTION (loc
))
9236 val_resolve (set
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
9237 set_variable_part (set
, val
, dv_from_decl (var
), 0,
9238 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9241 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
9242 set_variable_part (set
, PAT_VAR_LOCATION_LOC (vloc
),
9243 dv_from_decl (var
), 0,
9244 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9247 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9253 rtx loc
= mo
->u
.loc
;
9254 rtx val
, vloc
, uloc
;
9256 vloc
= uloc
= XEXP (loc
, 1);
9257 val
= XEXP (loc
, 0);
9259 if (GET_CODE (val
) == CONCAT
)
9261 uloc
= XEXP (val
, 1);
9262 val
= XEXP (val
, 0);
9265 if (VAL_NEEDS_RESOLUTION (loc
))
9266 val_resolve (set
, val
, vloc
, insn
);
9268 val_store (set
, val
, uloc
, insn
, false);
9270 if (VAL_HOLDS_TRACK_EXPR (loc
))
9272 if (GET_CODE (uloc
) == REG
)
9273 var_reg_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9275 else if (GET_CODE (uloc
) == MEM
)
9276 var_mem_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9280 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9286 rtx loc
= mo
->u
.loc
;
9287 rtx val
, vloc
, uloc
;
9291 uloc
= XEXP (vloc
, 1);
9292 val
= XEXP (vloc
, 0);
9295 if (GET_CODE (uloc
) == SET
)
9297 dstv
= SET_DEST (uloc
);
9298 srcv
= SET_SRC (uloc
);
9306 if (GET_CODE (val
) == CONCAT
)
9308 dstv
= vloc
= XEXP (val
, 1);
9309 val
= XEXP (val
, 0);
9312 if (GET_CODE (vloc
) == SET
)
9314 srcv
= SET_SRC (vloc
);
9316 gcc_assert (val
!= srcv
);
9317 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
9319 dstv
= vloc
= SET_DEST (vloc
);
9321 if (VAL_NEEDS_RESOLUTION (loc
))
9322 val_resolve (set
, val
, srcv
, insn
);
9324 else if (VAL_NEEDS_RESOLUTION (loc
))
9326 gcc_assert (GET_CODE (uloc
) == SET
9327 && GET_CODE (SET_SRC (uloc
)) == REG
);
9328 val_resolve (set
, val
, SET_SRC (uloc
), insn
);
9331 if (VAL_HOLDS_TRACK_EXPR (loc
))
9333 if (VAL_EXPR_IS_CLOBBERED (loc
))
9336 var_reg_delete (set
, uloc
, true);
9337 else if (MEM_P (uloc
))
9339 gcc_assert (MEM_P (dstv
));
9340 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
9341 var_mem_delete (set
, dstv
, true);
9346 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
9347 rtx src
= NULL
, dst
= uloc
;
9348 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
9350 if (GET_CODE (uloc
) == SET
)
9352 src
= SET_SRC (uloc
);
9353 dst
= SET_DEST (uloc
);
9358 status
= find_src_status (set
, src
);
9360 src
= find_src_set_src (set
, src
);
9364 var_reg_delete_and_set (set
, dst
, !copied_p
,
9366 else if (MEM_P (dst
))
9368 gcc_assert (MEM_P (dstv
));
9369 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
9370 var_mem_delete_and_set (set
, dstv
, !copied_p
,
9375 else if (REG_P (uloc
))
9376 var_regno_delete (set
, REGNO (uloc
));
9377 else if (MEM_P (uloc
))
9379 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
9380 gcc_checking_assert (vloc
== dstv
);
9382 clobber_overlapping_mems (set
, vloc
);
9385 val_store (set
, val
, dstv
, insn
, true);
9387 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9394 rtx loc
= mo
->u
.loc
;
9397 if (GET_CODE (loc
) == SET
)
9399 set_src
= SET_SRC (loc
);
9400 loc
= SET_DEST (loc
);
9404 var_reg_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9407 var_mem_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9410 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9417 rtx loc
= mo
->u
.loc
;
9418 enum var_init_status src_status
;
9421 if (GET_CODE (loc
) == SET
)
9423 set_src
= SET_SRC (loc
);
9424 loc
= SET_DEST (loc
);
9427 src_status
= find_src_status (set
, set_src
);
9428 set_src
= find_src_set_src (set
, set_src
);
9431 var_reg_delete_and_set (set
, loc
, false, src_status
, set_src
);
9433 var_mem_delete_and_set (set
, loc
, false, src_status
, set_src
);
9435 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9442 rtx loc
= mo
->u
.loc
;
9445 var_reg_delete (set
, loc
, false);
9447 var_mem_delete (set
, loc
, false);
9449 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9455 rtx loc
= mo
->u
.loc
;
9458 var_reg_delete (set
, loc
, true);
9460 var_mem_delete (set
, loc
, true);
9462 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9468 set
->stack_adjust
+= mo
->u
.adjust
;
9474 /* Emit notes for the whole function. */
9477 vt_emit_notes (void)
9482 gcc_assert (!changed_variables
->elements ());
9484 /* Free memory occupied by the out hash tables, as they aren't used
9486 FOR_EACH_BB_FN (bb
, cfun
)
9487 dataflow_set_clear (&VTI (bb
)->out
);
9489 /* Enable emitting notes by functions (mainly by set_variable_part and
9490 delete_variable_part). */
9493 if (MAY_HAVE_DEBUG_INSNS
)
9495 dropped_values
= new variable_table_type (cselib_get_next_uid () * 2);
9498 dataflow_set_init (&cur
);
9500 FOR_EACH_BB_FN (bb
, cfun
)
9502 /* Emit the notes for changes of variable locations between two
9503 subsequent basic blocks. */
9504 emit_notes_for_differences (BB_HEAD (bb
), &cur
, &VTI (bb
)->in
);
9506 if (MAY_HAVE_DEBUG_INSNS
)
9507 local_get_addr_cache
= new hash_map
<rtx
, rtx
>;
9509 /* Emit the notes for the changes in the basic block itself. */
9510 emit_notes_in_bb (bb
, &cur
);
9512 if (MAY_HAVE_DEBUG_INSNS
)
9513 delete local_get_addr_cache
;
9514 local_get_addr_cache
= NULL
;
9516 /* Free memory occupied by the in hash table, we won't need it
9518 dataflow_set_clear (&VTI (bb
)->in
);
9522 shared_hash_htab (cur
.vars
)
9523 ->traverse
<variable_table_type
*, emit_notes_for_differences_1
>
9524 (shared_hash_htab (empty_shared_hash
));
9526 dataflow_set_destroy (&cur
);
9528 if (MAY_HAVE_DEBUG_INSNS
)
9529 delete dropped_values
;
9530 dropped_values
= NULL
;
9535 /* If there is a declaration and offset associated with register/memory RTL
9536 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9539 vt_get_decl_and_offset (rtx rtl
, tree
*declp
, HOST_WIDE_INT
*offsetp
)
9543 if (REG_ATTRS (rtl
))
9545 *declp
= REG_EXPR (rtl
);
9546 *offsetp
= REG_OFFSET (rtl
);
9550 else if (GET_CODE (rtl
) == PARALLEL
)
9552 tree decl
= NULL_TREE
;
9553 HOST_WIDE_INT offset
= MAX_VAR_PARTS
;
9554 int len
= XVECLEN (rtl
, 0), i
;
9556 for (i
= 0; i
< len
; i
++)
9558 rtx reg
= XEXP (XVECEXP (rtl
, 0, i
), 0);
9559 if (!REG_P (reg
) || !REG_ATTRS (reg
))
9562 decl
= REG_EXPR (reg
);
9563 if (REG_EXPR (reg
) != decl
)
9565 if (REG_OFFSET (reg
) < offset
)
9566 offset
= REG_OFFSET (reg
);
9576 else if (MEM_P (rtl
))
9578 if (MEM_ATTRS (rtl
))
9580 *declp
= MEM_EXPR (rtl
);
9581 *offsetp
= INT_MEM_OFFSET (rtl
);
9588 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9592 record_entry_value (cselib_val
*val
, rtx rtl
)
9594 rtx ev
= gen_rtx_ENTRY_VALUE (GET_MODE (rtl
));
9596 ENTRY_VALUE_EXP (ev
) = rtl
;
9598 cselib_add_permanent_equiv (val
, ev
, get_insns ());
9601 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9604 vt_add_function_parameter (tree parm
)
9606 rtx decl_rtl
= DECL_RTL_IF_SET (parm
);
9607 rtx incoming
= DECL_INCOMING_RTL (parm
);
9610 HOST_WIDE_INT offset
;
9614 if (TREE_CODE (parm
) != PARM_DECL
)
9617 if (!decl_rtl
|| !incoming
)
9620 if (GET_MODE (decl_rtl
) == BLKmode
|| GET_MODE (incoming
) == BLKmode
)
9623 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9624 rewrite the incoming location of parameters passed on the stack
9625 into MEMs based on the argument pointer, so that incoming doesn't
9626 depend on a pseudo. */
9627 if (MEM_P (incoming
)
9628 && (XEXP (incoming
, 0) == crtl
->args
.internal_arg_pointer
9629 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
9630 && XEXP (XEXP (incoming
, 0), 0)
9631 == crtl
->args
.internal_arg_pointer
9632 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
9634 HOST_WIDE_INT off
= -FIRST_PARM_OFFSET (current_function_decl
);
9635 if (GET_CODE (XEXP (incoming
, 0)) == PLUS
)
9636 off
+= INTVAL (XEXP (XEXP (incoming
, 0), 1));
9638 = replace_equiv_address_nv (incoming
,
9639 plus_constant (Pmode
,
9640 arg_pointer_rtx
, off
));
9643 #ifdef HAVE_window_save
9644 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9645 If the target machine has an explicit window save instruction, the
9646 actual entry value is the corresponding OUTGOING_REGNO instead. */
9647 if (HAVE_window_save
&& !crtl
->uses_only_leaf_regs
)
9649 if (REG_P (incoming
)
9650 && HARD_REGISTER_P (incoming
)
9651 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
9654 p
.incoming
= incoming
;
9656 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
9657 OUTGOING_REGNO (REGNO (incoming
)), 0);
9658 p
.outgoing
= incoming
;
9659 vec_safe_push (windowed_parm_regs
, p
);
9661 else if (GET_CODE (incoming
) == PARALLEL
)
9664 = gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (XVECLEN (incoming
, 0)));
9667 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9669 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9672 reg
= gen_rtx_REG_offset (reg
, GET_MODE (reg
),
9673 OUTGOING_REGNO (REGNO (reg
)), 0);
9675 XVECEXP (outgoing
, 0, i
)
9676 = gen_rtx_EXPR_LIST (VOIDmode
, reg
,
9677 XEXP (XVECEXP (incoming
, 0, i
), 1));
9678 vec_safe_push (windowed_parm_regs
, p
);
9681 incoming
= outgoing
;
9683 else if (MEM_P (incoming
)
9684 && REG_P (XEXP (incoming
, 0))
9685 && HARD_REGISTER_P (XEXP (incoming
, 0)))
9687 rtx reg
= XEXP (incoming
, 0);
9688 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
9692 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
9694 vec_safe_push (windowed_parm_regs
, p
);
9695 incoming
= replace_equiv_address_nv (incoming
, reg
);
9701 if (!vt_get_decl_and_offset (incoming
, &decl
, &offset
))
9703 if (MEM_P (incoming
))
9705 /* This means argument is passed by invisible reference. */
9711 if (!vt_get_decl_and_offset (decl_rtl
, &decl
, &offset
))
9713 offset
+= byte_lowpart_offset (GET_MODE (incoming
),
9714 GET_MODE (decl_rtl
));
9723 /* If that DECL_RTL wasn't a pseudo that got spilled to
9724 memory, bail out. Otherwise, the spill slot sharing code
9725 will force the memory to reference spill_slot_decl (%sfp),
9726 so we don't match above. That's ok, the pseudo must have
9727 referenced the entire parameter, so just reset OFFSET. */
9728 if (decl
!= get_spill_slot_decl (false))
9733 if (!track_loc_p (incoming
, parm
, offset
, false, &mode
, &offset
))
9736 out
= &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
;
9738 dv
= dv_from_decl (parm
);
9740 if (target_for_debug_bind (parm
)
9741 /* We can't deal with these right now, because this kind of
9742 variable is single-part. ??? We could handle parallels
9743 that describe multiple locations for the same single
9744 value, but ATM we don't. */
9745 && GET_CODE (incoming
) != PARALLEL
)
9750 /* ??? We shouldn't ever hit this, but it may happen because
9751 arguments passed by invisible reference aren't dealt with
9752 above: incoming-rtl will have Pmode rather than the
9753 expected mode for the type. */
9757 lowpart
= var_lowpart (mode
, incoming
);
9761 val
= cselib_lookup_from_insn (lowpart
, mode
, true,
9762 VOIDmode
, get_insns ());
9764 /* ??? Float-typed values in memory are not handled by
9768 preserve_value (val
);
9769 set_variable_part (out
, val
->val_rtx
, dv
, offset
,
9770 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9771 dv
= dv_from_value (val
->val_rtx
);
9774 if (MEM_P (incoming
))
9776 val
= cselib_lookup_from_insn (XEXP (incoming
, 0), mode
, true,
9777 VOIDmode
, get_insns ());
9780 preserve_value (val
);
9781 incoming
= replace_equiv_address_nv (incoming
, val
->val_rtx
);
9786 if (REG_P (incoming
))
9788 incoming
= var_lowpart (mode
, incoming
);
9789 gcc_assert (REGNO (incoming
) < FIRST_PSEUDO_REGISTER
);
9790 attrs_list_insert (&out
->regs
[REGNO (incoming
)], dv
, offset
,
9792 set_variable_part (out
, incoming
, dv
, offset
,
9793 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9794 if (dv_is_value_p (dv
))
9796 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv
)), incoming
);
9797 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
9798 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm
))))
9800 machine_mode indmode
9801 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm
)));
9802 rtx mem
= gen_rtx_MEM (indmode
, incoming
);
9803 cselib_val
*val
= cselib_lookup_from_insn (mem
, indmode
, true,
9808 preserve_value (val
);
9809 record_entry_value (val
, mem
);
9810 set_variable_part (out
, mem
, dv_from_value (val
->val_rtx
), 0,
9811 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9816 else if (GET_CODE (incoming
) == PARALLEL
&& !dv_onepart_p (dv
))
9820 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9822 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9823 offset
= REG_OFFSET (reg
);
9824 gcc_assert (REGNO (reg
) < FIRST_PSEUDO_REGISTER
);
9825 attrs_list_insert (&out
->regs
[REGNO (reg
)], dv
, offset
, reg
);
9826 set_variable_part (out
, reg
, dv
, offset
,
9827 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9830 else if (MEM_P (incoming
))
9832 incoming
= var_lowpart (mode
, incoming
);
9833 set_variable_part (out
, incoming
, dv
, offset
,
9834 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9838 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9841 vt_add_function_parameters (void)
9845 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9846 parm
; parm
= DECL_CHAIN (parm
))
9847 if (!POINTER_BOUNDS_P (parm
))
9848 vt_add_function_parameter (parm
);
9850 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl
)))
9852 tree vexpr
= DECL_VALUE_EXPR (DECL_RESULT (current_function_decl
));
9854 if (TREE_CODE (vexpr
) == INDIRECT_REF
)
9855 vexpr
= TREE_OPERAND (vexpr
, 0);
9857 if (TREE_CODE (vexpr
) == PARM_DECL
9858 && DECL_ARTIFICIAL (vexpr
)
9859 && !DECL_IGNORED_P (vexpr
)
9860 && DECL_NAMELESS (vexpr
))
9861 vt_add_function_parameter (vexpr
);
9865 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9866 ensure it isn't flushed during cselib_reset_table.
9867 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9868 has been eliminated. */
9871 vt_init_cfa_base (void)
9875 #ifdef FRAME_POINTER_CFA_OFFSET
9876 cfa_base_rtx
= frame_pointer_rtx
;
9877 cfa_base_offset
= -FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9879 cfa_base_rtx
= arg_pointer_rtx
;
9880 cfa_base_offset
= -ARG_POINTER_CFA_OFFSET (current_function_decl
);
9882 if (cfa_base_rtx
== hard_frame_pointer_rtx
9883 || !fixed_regs
[REGNO (cfa_base_rtx
)])
9885 cfa_base_rtx
= NULL_RTX
;
9888 if (!MAY_HAVE_DEBUG_INSNS
)
9891 /* Tell alias analysis that cfa_base_rtx should share
9892 find_base_term value with stack pointer or hard frame pointer. */
9893 if (!frame_pointer_needed
)
9894 vt_equate_reg_base_value (cfa_base_rtx
, stack_pointer_rtx
);
9895 else if (!crtl
->stack_realign_tried
)
9896 vt_equate_reg_base_value (cfa_base_rtx
, hard_frame_pointer_rtx
);
9898 val
= cselib_lookup_from_insn (cfa_base_rtx
, GET_MODE (cfa_base_rtx
), 1,
9899 VOIDmode
, get_insns ());
9900 preserve_value (val
);
9901 cselib_preserve_cfa_base_value (val
, REGNO (cfa_base_rtx
));
9904 /* Allocate and initialize the data structures for variable tracking
9905 and parse the RTL to get the micro operations. */
9908 vt_initialize (void)
9911 HOST_WIDE_INT fp_cfa_offset
= -1;
9913 alloc_aux_for_blocks (sizeof (variable_tracking_info
));
9915 empty_shared_hash
= shared_hash_pool
.allocate ();
9916 empty_shared_hash
->refcount
= 1;
9917 empty_shared_hash
->htab
= new variable_table_type (1);
9918 changed_variables
= new variable_table_type (10);
9920 /* Init the IN and OUT sets. */
9921 FOR_ALL_BB_FN (bb
, cfun
)
9923 VTI (bb
)->visited
= false;
9924 VTI (bb
)->flooded
= false;
9925 dataflow_set_init (&VTI (bb
)->in
);
9926 dataflow_set_init (&VTI (bb
)->out
);
9927 VTI (bb
)->permp
= NULL
;
9930 if (MAY_HAVE_DEBUG_INSNS
)
9932 cselib_init (CSELIB_RECORD_MEMORY
| CSELIB_PRESERVE_CONSTANTS
);
9933 scratch_regs
= BITMAP_ALLOC (NULL
);
9934 preserved_values
.create (256);
9935 global_get_addr_cache
= new hash_map
<rtx
, rtx
>;
9939 scratch_regs
= NULL
;
9940 global_get_addr_cache
= NULL
;
9943 if (MAY_HAVE_DEBUG_INSNS
)
9949 #ifdef FRAME_POINTER_CFA_OFFSET
9950 reg
= frame_pointer_rtx
;
9951 ofst
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9953 reg
= arg_pointer_rtx
;
9954 ofst
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9957 ofst
-= INCOMING_FRAME_SP_OFFSET
;
9959 val
= cselib_lookup_from_insn (reg
, GET_MODE (reg
), 1,
9960 VOIDmode
, get_insns ());
9961 preserve_value (val
);
9962 if (reg
!= hard_frame_pointer_rtx
&& fixed_regs
[REGNO (reg
)])
9963 cselib_preserve_cfa_base_value (val
, REGNO (reg
));
9964 expr
= plus_constant (GET_MODE (stack_pointer_rtx
),
9965 stack_pointer_rtx
, -ofst
);
9966 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9970 val
= cselib_lookup_from_insn (stack_pointer_rtx
,
9971 GET_MODE (stack_pointer_rtx
), 1,
9972 VOIDmode
, get_insns ());
9973 preserve_value (val
);
9974 expr
= plus_constant (GET_MODE (reg
), reg
, ofst
);
9975 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9979 /* In order to factor out the adjustments made to the stack pointer or to
9980 the hard frame pointer and thus be able to use DW_OP_fbreg operations
9981 instead of individual location lists, we're going to rewrite MEMs based
9982 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
9983 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
9984 resp. arg_pointer_rtx. We can do this either when there is no frame
9985 pointer in the function and stack adjustments are consistent for all
9986 basic blocks or when there is a frame pointer and no stack realignment.
9987 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
9988 has been eliminated. */
9989 if (!frame_pointer_needed
)
9993 if (!vt_stack_adjustments ())
9996 #ifdef FRAME_POINTER_CFA_OFFSET
9997 reg
= frame_pointer_rtx
;
9999 reg
= arg_pointer_rtx
;
10001 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10004 if (GET_CODE (elim
) == PLUS
)
10005 elim
= XEXP (elim
, 0);
10006 if (elim
== stack_pointer_rtx
)
10007 vt_init_cfa_base ();
10010 else if (!crtl
->stack_realign_tried
)
10014 #ifdef FRAME_POINTER_CFA_OFFSET
10015 reg
= frame_pointer_rtx
;
10016 fp_cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
10018 reg
= arg_pointer_rtx
;
10019 fp_cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
10021 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10024 if (GET_CODE (elim
) == PLUS
)
10026 fp_cfa_offset
-= INTVAL (XEXP (elim
, 1));
10027 elim
= XEXP (elim
, 0);
10029 if (elim
!= hard_frame_pointer_rtx
)
10030 fp_cfa_offset
= -1;
10033 fp_cfa_offset
= -1;
10036 /* If the stack is realigned and a DRAP register is used, we're going to
10037 rewrite MEMs based on it representing incoming locations of parameters
10038 passed on the stack into MEMs based on the argument pointer. Although
10039 we aren't going to rewrite other MEMs, we still need to initialize the
10040 virtual CFA pointer in order to ensure that the argument pointer will
10041 be seen as a constant throughout the function.
10043 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
10044 else if (stack_realign_drap
)
10048 #ifdef FRAME_POINTER_CFA_OFFSET
10049 reg
= frame_pointer_rtx
;
10051 reg
= arg_pointer_rtx
;
10053 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
10056 if (GET_CODE (elim
) == PLUS
)
10057 elim
= XEXP (elim
, 0);
10058 if (elim
== hard_frame_pointer_rtx
)
10059 vt_init_cfa_base ();
10063 hard_frame_pointer_adjustment
= -1;
10065 vt_add_function_parameters ();
10067 FOR_EACH_BB_FN (bb
, cfun
)
10070 HOST_WIDE_INT pre
, post
= 0;
10071 basic_block first_bb
, last_bb
;
10073 if (MAY_HAVE_DEBUG_INSNS
)
10075 cselib_record_sets_hook
= add_with_sets
;
10076 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10077 fprintf (dump_file
, "first value: %i\n",
10078 cselib_get_next_uid ());
10085 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
10086 || ! single_pred_p (bb
->next_bb
))
10088 e
= find_edge (bb
, bb
->next_bb
);
10089 if (! e
|| (e
->flags
& EDGE_FALLTHRU
) == 0)
10095 /* Add the micro-operations to the vector. */
10096 FOR_BB_BETWEEN (bb
, first_bb
, last_bb
->next_bb
, next_bb
)
10098 HOST_WIDE_INT offset
= VTI (bb
)->out
.stack_adjust
;
10099 VTI (bb
)->out
.stack_adjust
= VTI (bb
)->in
.stack_adjust
;
10100 for (insn
= BB_HEAD (bb
); insn
!= NEXT_INSN (BB_END (bb
));
10101 insn
= NEXT_INSN (insn
))
10105 if (!frame_pointer_needed
)
10107 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
10110 micro_operation mo
;
10111 mo
.type
= MO_ADJUST
;
10114 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10115 log_op_type (PATTERN (insn
), bb
, insn
,
10116 MO_ADJUST
, dump_file
);
10117 VTI (bb
)->mos
.safe_push (mo
);
10118 VTI (bb
)->out
.stack_adjust
+= pre
;
10122 cselib_hook_called
= false;
10123 adjust_insn (bb
, insn
);
10124 if (MAY_HAVE_DEBUG_INSNS
)
10127 prepare_call_arguments (bb
, insn
);
10128 cselib_process_insn (insn
);
10129 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10131 print_rtl_single (dump_file
, insn
);
10132 dump_cselib_table (dump_file
);
10135 if (!cselib_hook_called
)
10136 add_with_sets (insn
, 0, 0);
10137 cancel_changes (0);
10139 if (!frame_pointer_needed
&& post
)
10141 micro_operation mo
;
10142 mo
.type
= MO_ADJUST
;
10143 mo
.u
.adjust
= post
;
10145 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10146 log_op_type (PATTERN (insn
), bb
, insn
,
10147 MO_ADJUST
, dump_file
);
10148 VTI (bb
)->mos
.safe_push (mo
);
10149 VTI (bb
)->out
.stack_adjust
+= post
;
10152 if (fp_cfa_offset
!= -1
10153 && hard_frame_pointer_adjustment
== -1
10154 && fp_setter_insn (insn
))
10156 vt_init_cfa_base ();
10157 hard_frame_pointer_adjustment
= fp_cfa_offset
;
10158 /* Disassociate sp from fp now. */
10159 if (MAY_HAVE_DEBUG_INSNS
)
10162 cselib_invalidate_rtx (stack_pointer_rtx
);
10163 v
= cselib_lookup (stack_pointer_rtx
, Pmode
, 1,
10165 if (v
&& !cselib_preserved_value_p (v
))
10167 cselib_set_value_sp_based (v
);
10168 preserve_value (v
);
10174 gcc_assert (offset
== VTI (bb
)->out
.stack_adjust
);
10179 if (MAY_HAVE_DEBUG_INSNS
)
10181 cselib_preserve_only_values ();
10182 cselib_reset_table (cselib_get_next_uid ());
10183 cselib_record_sets_hook
= NULL
;
10187 hard_frame_pointer_adjustment
= -1;
10188 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flooded
= true;
10189 cfa_base_rtx
= NULL_RTX
;
10193 /* This is *not* reset after each function. It gives each
10194 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10195 a unique label number. */
10197 static int debug_label_num
= 1;
10199 /* Get rid of all debug insns from the insn stream. */
10202 delete_debug_insns (void)
10205 rtx_insn
*insn
, *next
;
10207 if (!MAY_HAVE_DEBUG_INSNS
)
10210 FOR_EACH_BB_FN (bb
, cfun
)
10212 FOR_BB_INSNS_SAFE (bb
, insn
, next
)
10213 if (DEBUG_INSN_P (insn
))
10215 tree decl
= INSN_VAR_LOCATION_DECL (insn
);
10216 if (TREE_CODE (decl
) == LABEL_DECL
10217 && DECL_NAME (decl
)
10218 && !DECL_RTL_SET_P (decl
))
10220 PUT_CODE (insn
, NOTE
);
10221 NOTE_KIND (insn
) = NOTE_INSN_DELETED_DEBUG_LABEL
;
10222 NOTE_DELETED_LABEL_NAME (insn
)
10223 = IDENTIFIER_POINTER (DECL_NAME (decl
));
10224 SET_DECL_RTL (decl
, insn
);
10225 CODE_LABEL_NUMBER (insn
) = debug_label_num
++;
10228 delete_insn (insn
);
10233 /* Run a fast, BB-local only version of var tracking, to take care of
10234 information that we don't do global analysis on, such that not all
10235 information is lost. If SKIPPED holds, we're skipping the global
10236 pass entirely, so we should try to use information it would have
10237 handled as well.. */
10240 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED
)
10242 /* ??? Just skip it all for now. */
10243 delete_debug_insns ();
10246 /* Free the data structures needed for variable tracking. */
10253 FOR_EACH_BB_FN (bb
, cfun
)
10255 VTI (bb
)->mos
.release ();
10258 FOR_ALL_BB_FN (bb
, cfun
)
10260 dataflow_set_destroy (&VTI (bb
)->in
);
10261 dataflow_set_destroy (&VTI (bb
)->out
);
10262 if (VTI (bb
)->permp
)
10264 dataflow_set_destroy (VTI (bb
)->permp
);
10265 XDELETE (VTI (bb
)->permp
);
10268 free_aux_for_blocks ();
10269 delete empty_shared_hash
->htab
;
10270 empty_shared_hash
->htab
= NULL
;
10271 delete changed_variables
;
10272 changed_variables
= NULL
;
10273 attrs_pool
.release ();
10274 var_pool
.release ();
10275 location_chain_pool
.release ();
10276 shared_hash_pool
.release ();
10278 if (MAY_HAVE_DEBUG_INSNS
)
10280 if (global_get_addr_cache
)
10281 delete global_get_addr_cache
;
10282 global_get_addr_cache
= NULL
;
10283 loc_exp_dep_pool
.release ();
10284 valvar_pool
.release ();
10285 preserved_values
.release ();
10287 BITMAP_FREE (scratch_regs
);
10288 scratch_regs
= NULL
;
10291 #ifdef HAVE_window_save
10292 vec_free (windowed_parm_regs
);
10296 XDELETEVEC (vui_vec
);
10301 /* The entry point to variable tracking pass. */
10303 static inline unsigned int
10304 variable_tracking_main_1 (void)
10308 if (flag_var_tracking_assignments
< 0
10309 /* Var-tracking right now assumes the IR doesn't contain
10310 any pseudos at this point. */
10311 || targetm
.no_register_allocation
)
10313 delete_debug_insns ();
10317 if (n_basic_blocks_for_fn (cfun
) > 500 &&
10318 n_edges_for_fn (cfun
) / n_basic_blocks_for_fn (cfun
) >= 20)
10320 vt_debug_insns_local (true);
10324 mark_dfs_back_edges ();
10325 if (!vt_initialize ())
10328 vt_debug_insns_local (true);
10332 success
= vt_find_locations ();
10334 if (!success
&& flag_var_tracking_assignments
> 0)
10338 delete_debug_insns ();
10340 /* This is later restored by our caller. */
10341 flag_var_tracking_assignments
= 0;
10343 success
= vt_initialize ();
10344 gcc_assert (success
);
10346 success
= vt_find_locations ();
10352 vt_debug_insns_local (false);
10356 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10358 dump_dataflow_sets ();
10359 dump_reg_info (dump_file
);
10360 dump_flow_info (dump_file
, dump_flags
);
10363 timevar_push (TV_VAR_TRACKING_EMIT
);
10365 timevar_pop (TV_VAR_TRACKING_EMIT
);
10368 vt_debug_insns_local (false);
10373 variable_tracking_main (void)
10376 int save
= flag_var_tracking_assignments
;
10378 ret
= variable_tracking_main_1 ();
10380 flag_var_tracking_assignments
= save
;
10387 const pass_data pass_data_variable_tracking
=
10389 RTL_PASS
, /* type */
10390 "vartrack", /* name */
10391 OPTGROUP_NONE
, /* optinfo_flags */
10392 TV_VAR_TRACKING
, /* tv_id */
10393 0, /* properties_required */
10394 0, /* properties_provided */
10395 0, /* properties_destroyed */
10396 0, /* todo_flags_start */
10397 0, /* todo_flags_finish */
10400 class pass_variable_tracking
: public rtl_opt_pass
10403 pass_variable_tracking (gcc::context
*ctxt
)
10404 : rtl_opt_pass (pass_data_variable_tracking
, ctxt
)
10407 /* opt_pass methods: */
10408 virtual bool gate (function
*)
10410 return (flag_var_tracking
&& !targetm
.delay_vartrack
);
10413 virtual unsigned int execute (function
*)
10415 return variable_tracking_main ();
10418 }; // class pass_variable_tracking
10420 } // anon namespace
10423 make_pass_variable_tracking (gcc::context
*ctxt
)
10425 return new pass_variable_tracking (ctxt
);