1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2014 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"
95 #include "stor-layout.h"
96 #include "pointer-set.h"
97 #include "hash-table.h"
98 #include "basic-block.h"
100 #include "hard-reg-set.h"
102 #include "insn-config.h"
105 #include "alloc-pool.h"
109 #include "tree-pass.h"
111 #include "tree-dfa.h"
112 #include "tree-ssa.h"
116 #include "diagnostic.h"
117 #include "tree-pretty-print.h"
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 typedef struct micro_operation_def
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. */
245 typedef struct attrs_def
247 /* Pointer to next member of the list. */
248 struct attrs_def
*next
;
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 typedef struct location_chain_def
263 /* Next element in the chain. */
264 struct location_chain_def
*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. */
280 typedef struct loc_exp_dep_s
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_s
*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_s
**pprev
;
294 /* This data structure holds information about the depth of a variable
296 typedef struct expand_depth_struct
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. */
331 typedef struct variable_part_def
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
354 typedef enum onepart_enum
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. */
367 typedef struct variable_def
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];
389 typedef const struct variable_def
*const_variable
;
391 /* Pointer to the BB's information specific to variable tracking pass. */
392 #define VTI(BB) ((variable_tracking_info) (BB)->aux)
394 /* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
395 #define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
397 #if ENABLE_CHECKING && (GCC_VERSION >= 2007)
399 /* Access VAR's Ith part's offset, checking that it's not a one-part
401 #define VAR_PART_OFFSET(var, i) __extension__ \
402 (*({ variable const __v = (var); \
403 gcc_checking_assert (!__v->onepart); \
404 &__v->var_part[(i)].aux.offset; }))
406 /* Access VAR's one-part auxiliary data, checking that it is a
407 one-part variable. */
408 #define VAR_LOC_1PAUX(var) __extension__ \
409 (*({ variable const __v = (var); \
410 gcc_checking_assert (__v->onepart); \
411 &__v->var_part[0].aux.onepaux; }))
414 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
415 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
418 /* These are accessor macros for the one-part auxiliary data. When
419 convenient for users, they're guarded by tests that the data was
421 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
422 ? VAR_LOC_1PAUX (var)->backlinks \
424 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
425 ? &VAR_LOC_1PAUX (var)->backlinks \
427 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
428 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
429 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
430 ? &VAR_LOC_1PAUX (var)->deps \
435 typedef unsigned int dvuid
;
437 /* Return the uid of DV. */
440 dv_uid (decl_or_value dv
)
442 if (dv_is_value_p (dv
))
443 return CSELIB_VAL_PTR (dv_as_value (dv
))->uid
;
445 return DECL_UID (dv_as_decl (dv
));
448 /* Compute the hash from the uid. */
450 static inline hashval_t
451 dv_uid2hash (dvuid uid
)
456 /* The hash function for a mask table in a shared_htab chain. */
458 static inline hashval_t
459 dv_htab_hash (decl_or_value dv
)
461 return dv_uid2hash (dv_uid (dv
));
464 static void variable_htab_free (void *);
466 /* Variable hashtable helpers. */
468 struct variable_hasher
470 typedef variable_def value_type
;
471 typedef void compare_type
;
472 static inline hashval_t
hash (const value_type
*);
473 static inline bool equal (const value_type
*, const compare_type
*);
474 static inline void remove (value_type
*);
477 /* The hash function for variable_htab, computes the hash value
478 from the declaration of variable X. */
481 variable_hasher::hash (const value_type
*v
)
483 return dv_htab_hash (v
->dv
);
486 /* Compare the declaration of variable X with declaration Y. */
489 variable_hasher::equal (const value_type
*v
, const compare_type
*y
)
491 decl_or_value dv
= CONST_CAST2 (decl_or_value
, const void *, y
);
493 return (dv_as_opaque (v
->dv
) == dv_as_opaque (dv
));
496 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
499 variable_hasher::remove (value_type
*var
)
501 variable_htab_free (var
);
504 typedef hash_table
<variable_hasher
> variable_table_type
;
505 typedef variable_table_type::iterator variable_iterator_type
;
507 /* Structure for passing some other parameters to function
508 emit_note_insn_var_location. */
509 typedef struct emit_note_data_def
511 /* The instruction which the note will be emitted before/after. */
514 /* Where the note will be emitted (before/after insn)? */
515 enum emit_note_where where
;
517 /* The variables and values active at this point. */
518 variable_table_type vars
;
521 /* Structure holding a refcounted hash table. If refcount > 1,
522 it must be first unshared before modified. */
523 typedef struct shared_hash_def
525 /* Reference count. */
528 /* Actual hash table. */
529 variable_table_type htab
;
532 /* Structure holding the IN or OUT set for a basic block. */
533 typedef struct dataflow_set_def
535 /* Adjustment of stack offset. */
536 HOST_WIDE_INT stack_adjust
;
538 /* Attributes for registers (lists of attrs). */
539 attrs regs
[FIRST_PSEUDO_REGISTER
];
541 /* Variable locations. */
544 /* Vars that is being traversed. */
545 shared_hash traversed_vars
;
548 /* The structure (one for each basic block) containing the information
549 needed for variable tracking. */
550 typedef struct variable_tracking_info_def
552 /* The vector of micro operations. */
553 vec
<micro_operation
> mos
;
555 /* The IN and OUT set for dataflow analysis. */
559 /* The permanent-in dataflow set for this block. This is used to
560 hold values for which we had to compute entry values. ??? This
561 should probably be dynamically allocated, to avoid using more
562 memory in non-debug builds. */
565 /* Has the block been visited in DFS? */
568 /* Has the block been flooded in VTA? */
571 } *variable_tracking_info
;
573 /* Alloc pool for struct attrs_def. */
574 static alloc_pool attrs_pool
;
576 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
577 static alloc_pool var_pool
;
579 /* Alloc pool for struct variable_def with a single var_part entry. */
580 static alloc_pool valvar_pool
;
582 /* Alloc pool for struct location_chain_def. */
583 static alloc_pool loc_chain_pool
;
585 /* Alloc pool for struct shared_hash_def. */
586 static alloc_pool shared_hash_pool
;
588 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
589 static alloc_pool loc_exp_dep_pool
;
591 /* Changed variables, notes will be emitted for them. */
592 static variable_table_type changed_variables
;
594 /* Shall notes be emitted? */
595 static bool emit_notes
;
597 /* Values whose dynamic location lists have gone empty, but whose
598 cselib location lists are still usable. Use this to hold the
599 current location, the backlinks, etc, during emit_notes. */
600 static variable_table_type dropped_values
;
602 /* Empty shared hashtable. */
603 static shared_hash empty_shared_hash
;
605 /* Scratch register bitmap used by cselib_expand_value_rtx. */
606 static bitmap scratch_regs
= NULL
;
608 #ifdef HAVE_window_save
609 typedef struct GTY(()) parm_reg
{
615 /* Vector of windowed parameter registers, if any. */
616 static vec
<parm_reg_t
, va_gc
> *windowed_parm_regs
= NULL
;
619 /* Variable used to tell whether cselib_process_insn called our hook. */
620 static bool cselib_hook_called
;
622 /* Local function prototypes. */
623 static void stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
625 static void insn_stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
627 static bool vt_stack_adjustments (void);
629 static void init_attrs_list_set (attrs
*);
630 static void attrs_list_clear (attrs
*);
631 static attrs
attrs_list_member (attrs
, decl_or_value
, HOST_WIDE_INT
);
632 static void attrs_list_insert (attrs
*, decl_or_value
, HOST_WIDE_INT
, rtx
);
633 static void attrs_list_copy (attrs
*, attrs
);
634 static void attrs_list_union (attrs
*, attrs
);
636 static variable_def
**unshare_variable (dataflow_set
*set
, variable_def
**slot
,
637 variable var
, enum var_init_status
);
638 static void vars_copy (variable_table_type
, variable_table_type
);
639 static tree
var_debug_decl (tree
);
640 static void var_reg_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
641 static void var_reg_delete_and_set (dataflow_set
*, rtx
, bool,
642 enum var_init_status
, rtx
);
643 static void var_reg_delete (dataflow_set
*, rtx
, bool);
644 static void var_regno_delete (dataflow_set
*, int);
645 static void var_mem_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
646 static void var_mem_delete_and_set (dataflow_set
*, rtx
, bool,
647 enum var_init_status
, rtx
);
648 static void var_mem_delete (dataflow_set
*, rtx
, bool);
650 static void dataflow_set_init (dataflow_set
*);
651 static void dataflow_set_clear (dataflow_set
*);
652 static void dataflow_set_copy (dataflow_set
*, dataflow_set
*);
653 static int variable_union_info_cmp_pos (const void *, const void *);
654 static void dataflow_set_union (dataflow_set
*, dataflow_set
*);
655 static location_chain
find_loc_in_1pdv (rtx
, variable
, variable_table_type
);
656 static bool canon_value_cmp (rtx
, rtx
);
657 static int loc_cmp (rtx
, rtx
);
658 static bool variable_part_different_p (variable_part
*, variable_part
*);
659 static bool onepart_variable_different_p (variable
, variable
);
660 static bool variable_different_p (variable
, variable
);
661 static bool dataflow_set_different (dataflow_set
*, dataflow_set
*);
662 static void dataflow_set_destroy (dataflow_set
*);
664 static bool contains_symbol_ref (rtx
);
665 static bool track_expr_p (tree
, bool);
666 static bool same_variable_part_p (rtx
, tree
, HOST_WIDE_INT
);
667 static int add_uses (rtx
*, void *);
668 static void add_uses_1 (rtx
*, void *);
669 static void add_stores (rtx
, const_rtx
, void *);
670 static bool compute_bb_dataflow (basic_block
);
671 static bool vt_find_locations (void);
673 static void dump_attrs_list (attrs
);
674 static void dump_var (variable
);
675 static void dump_vars (variable_table_type
);
676 static void dump_dataflow_set (dataflow_set
*);
677 static void dump_dataflow_sets (void);
679 static void set_dv_changed (decl_or_value
, bool);
680 static void variable_was_changed (variable
, dataflow_set
*);
681 static variable_def
**set_slot_part (dataflow_set
*, rtx
, variable_def
**,
682 decl_or_value
, HOST_WIDE_INT
,
683 enum var_init_status
, rtx
);
684 static void set_variable_part (dataflow_set
*, rtx
,
685 decl_or_value
, HOST_WIDE_INT
,
686 enum var_init_status
, rtx
, enum insert_option
);
687 static variable_def
**clobber_slot_part (dataflow_set
*, rtx
,
688 variable_def
**, HOST_WIDE_INT
, rtx
);
689 static void clobber_variable_part (dataflow_set
*, rtx
,
690 decl_or_value
, HOST_WIDE_INT
, rtx
);
691 static variable_def
**delete_slot_part (dataflow_set
*, rtx
, variable_def
**,
693 static void delete_variable_part (dataflow_set
*, rtx
,
694 decl_or_value
, HOST_WIDE_INT
);
695 static void emit_notes_in_bb (basic_block
, dataflow_set
*);
696 static void vt_emit_notes (void);
698 static bool vt_get_decl_and_offset (rtx
, tree
*, HOST_WIDE_INT
*);
699 static void vt_add_function_parameters (void);
700 static bool vt_initialize (void);
701 static void vt_finalize (void);
703 /* Given a SET, calculate the amount of stack adjustment it contains
704 PRE- and POST-modifying stack pointer.
705 This function is similar to stack_adjust_offset. */
708 stack_adjust_offset_pre_post (rtx pattern
, HOST_WIDE_INT
*pre
,
711 rtx src
= SET_SRC (pattern
);
712 rtx dest
= SET_DEST (pattern
);
715 if (dest
== stack_pointer_rtx
)
717 /* (set (reg sp) (plus (reg sp) (const_int))) */
718 code
= GET_CODE (src
);
719 if (! (code
== PLUS
|| code
== MINUS
)
720 || XEXP (src
, 0) != stack_pointer_rtx
721 || !CONST_INT_P (XEXP (src
, 1)))
725 *post
+= INTVAL (XEXP (src
, 1));
727 *post
-= INTVAL (XEXP (src
, 1));
729 else if (MEM_P (dest
))
731 /* (set (mem (pre_dec (reg sp))) (foo)) */
732 src
= XEXP (dest
, 0);
733 code
= GET_CODE (src
);
739 if (XEXP (src
, 0) == stack_pointer_rtx
)
741 rtx val
= XEXP (XEXP (src
, 1), 1);
742 /* We handle only adjustments by constant amount. */
743 gcc_assert (GET_CODE (XEXP (src
, 1)) == PLUS
&&
746 if (code
== PRE_MODIFY
)
747 *pre
-= INTVAL (val
);
749 *post
-= INTVAL (val
);
755 if (XEXP (src
, 0) == stack_pointer_rtx
)
757 *pre
+= GET_MODE_SIZE (GET_MODE (dest
));
763 if (XEXP (src
, 0) == stack_pointer_rtx
)
765 *post
+= GET_MODE_SIZE (GET_MODE (dest
));
771 if (XEXP (src
, 0) == stack_pointer_rtx
)
773 *pre
-= GET_MODE_SIZE (GET_MODE (dest
));
779 if (XEXP (src
, 0) == stack_pointer_rtx
)
781 *post
-= GET_MODE_SIZE (GET_MODE (dest
));
792 /* Given an INSN, calculate the amount of stack adjustment it contains
793 PRE- and POST-modifying stack pointer. */
796 insn_stack_adjust_offset_pre_post (rtx insn
, HOST_WIDE_INT
*pre
,
804 pattern
= PATTERN (insn
);
805 if (RTX_FRAME_RELATED_P (insn
))
807 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
809 pattern
= XEXP (expr
, 0);
812 if (GET_CODE (pattern
) == SET
)
813 stack_adjust_offset_pre_post (pattern
, pre
, post
);
814 else if (GET_CODE (pattern
) == PARALLEL
815 || GET_CODE (pattern
) == SEQUENCE
)
819 /* There may be stack adjustments inside compound insns. Search
821 for ( i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
822 if (GET_CODE (XVECEXP (pattern
, 0, i
)) == SET
)
823 stack_adjust_offset_pre_post (XVECEXP (pattern
, 0, i
), pre
, post
);
827 /* Compute stack adjustments for all blocks by traversing DFS tree.
828 Return true when the adjustments on all incoming edges are consistent.
829 Heavily borrowed from pre_and_rev_post_order_compute. */
832 vt_stack_adjustments (void)
834 edge_iterator
*stack
;
837 /* Initialize entry block. */
838 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->visited
= true;
839 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->in
.stack_adjust
=
840 INCOMING_FRAME_SP_OFFSET
;
841 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
.stack_adjust
=
842 INCOMING_FRAME_SP_OFFSET
;
844 /* Allocate stack for back-tracking up CFG. */
845 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
848 /* Push the first edge on to the stack. */
849 stack
[sp
++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
857 /* Look at the edge on the top of the stack. */
859 src
= ei_edge (ei
)->src
;
860 dest
= ei_edge (ei
)->dest
;
862 /* Check if the edge destination has been visited yet. */
863 if (!VTI (dest
)->visited
)
866 HOST_WIDE_INT pre
, post
, offset
;
867 VTI (dest
)->visited
= true;
868 VTI (dest
)->in
.stack_adjust
= offset
= VTI (src
)->out
.stack_adjust
;
870 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
871 for (insn
= BB_HEAD (dest
);
872 insn
!= NEXT_INSN (BB_END (dest
));
873 insn
= NEXT_INSN (insn
))
876 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
877 offset
+= pre
+ post
;
880 VTI (dest
)->out
.stack_adjust
= offset
;
882 if (EDGE_COUNT (dest
->succs
) > 0)
883 /* Since the DEST node has been visited for the first
884 time, check its successors. */
885 stack
[sp
++] = ei_start (dest
->succs
);
889 /* Check whether the adjustments on the edges are the same. */
890 if (VTI (dest
)->in
.stack_adjust
!= VTI (src
)->out
.stack_adjust
)
896 if (! ei_one_before_end_p (ei
))
897 /* Go to the next edge. */
898 ei_next (&stack
[sp
- 1]);
900 /* Return to previous level if there are no more edges. */
909 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
910 hard_frame_pointer_rtx is being mapped to it and offset for it. */
911 static rtx cfa_base_rtx
;
912 static HOST_WIDE_INT cfa_base_offset
;
914 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
915 or hard_frame_pointer_rtx. */
918 compute_cfa_pointer (HOST_WIDE_INT adjustment
)
920 return plus_constant (Pmode
, cfa_base_rtx
, adjustment
+ cfa_base_offset
);
923 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
924 or -1 if the replacement shouldn't be done. */
925 static HOST_WIDE_INT hard_frame_pointer_adjustment
= -1;
927 /* Data for adjust_mems callback. */
929 struct adjust_mem_data
932 enum machine_mode mem_mode
;
933 HOST_WIDE_INT stack_adjust
;
937 /* Helper for adjust_mems. Return 1 if *loc is unsuitable for
938 transformation of wider mode arithmetics to narrower mode,
939 -1 if it is suitable and subexpressions shouldn't be
940 traversed and 0 if it is suitable and subexpressions should
941 be traversed. Called through for_each_rtx. */
944 use_narrower_mode_test (rtx
*loc
, void *data
)
946 rtx subreg
= (rtx
) data
;
948 if (CONSTANT_P (*loc
))
950 switch (GET_CODE (*loc
))
953 if (cselib_lookup (*loc
, GET_MODE (SUBREG_REG (subreg
)), 0, VOIDmode
))
955 if (!validate_subreg (GET_MODE (subreg
), GET_MODE (*loc
),
956 *loc
, subreg_lowpart_offset (GET_MODE (subreg
),
965 if (for_each_rtx (&XEXP (*loc
, 0), use_narrower_mode_test
, data
))
974 /* Transform X into narrower mode MODE from wider mode WMODE. */
977 use_narrower_mode (rtx x
, enum machine_mode mode
, enum machine_mode wmode
)
981 return lowpart_subreg (mode
, x
, wmode
);
982 switch (GET_CODE (x
))
985 return lowpart_subreg (mode
, x
, wmode
);
989 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
990 op1
= use_narrower_mode (XEXP (x
, 1), mode
, wmode
);
991 return simplify_gen_binary (GET_CODE (x
), mode
, op0
, op1
);
993 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
994 return simplify_gen_binary (ASHIFT
, mode
, op0
, XEXP (x
, 1));
1000 /* Helper function for adjusting used MEMs. */
1003 adjust_mems (rtx loc
, const_rtx old_rtx
, void *data
)
1005 struct adjust_mem_data
*amd
= (struct adjust_mem_data
*) data
;
1006 rtx mem
, addr
= loc
, tem
;
1007 enum machine_mode mem_mode_save
;
1009 switch (GET_CODE (loc
))
1012 /* Don't do any sp or fp replacements outside of MEM addresses
1014 if (amd
->mem_mode
== VOIDmode
&& amd
->store
)
1016 if (loc
== stack_pointer_rtx
1017 && !frame_pointer_needed
1019 return compute_cfa_pointer (amd
->stack_adjust
);
1020 else if (loc
== hard_frame_pointer_rtx
1021 && frame_pointer_needed
1022 && hard_frame_pointer_adjustment
!= -1
1024 return compute_cfa_pointer (hard_frame_pointer_adjustment
);
1025 gcc_checking_assert (loc
!= virtual_incoming_args_rtx
);
1031 mem
= targetm
.delegitimize_address (mem
);
1032 if (mem
!= loc
&& !MEM_P (mem
))
1033 return simplify_replace_fn_rtx (mem
, old_rtx
, adjust_mems
, data
);
1036 addr
= XEXP (mem
, 0);
1037 mem_mode_save
= amd
->mem_mode
;
1038 amd
->mem_mode
= GET_MODE (mem
);
1039 store_save
= amd
->store
;
1041 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1042 amd
->store
= store_save
;
1043 amd
->mem_mode
= mem_mode_save
;
1045 addr
= targetm
.delegitimize_address (addr
);
1046 if (addr
!= XEXP (mem
, 0))
1047 mem
= replace_equiv_address_nv (mem
, addr
);
1049 mem
= avoid_constant_pool_reference (mem
);
1053 addr
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1054 gen_int_mode (GET_CODE (loc
) == PRE_INC
1055 ? GET_MODE_SIZE (amd
->mem_mode
)
1056 : -GET_MODE_SIZE (amd
->mem_mode
),
1061 addr
= XEXP (loc
, 0);
1062 gcc_assert (amd
->mem_mode
!= VOIDmode
&& amd
->mem_mode
!= BLKmode
);
1063 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1064 tem
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1065 gen_int_mode ((GET_CODE (loc
) == PRE_INC
1066 || GET_CODE (loc
) == POST_INC
)
1067 ? GET_MODE_SIZE (amd
->mem_mode
)
1068 : -GET_MODE_SIZE (amd
->mem_mode
),
1070 amd
->side_effects
= alloc_EXPR_LIST (0,
1071 gen_rtx_SET (VOIDmode
,
1077 addr
= XEXP (loc
, 1);
1080 addr
= XEXP (loc
, 0);
1081 gcc_assert (amd
->mem_mode
!= VOIDmode
);
1082 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1083 amd
->side_effects
= alloc_EXPR_LIST (0,
1084 gen_rtx_SET (VOIDmode
,
1090 /* First try without delegitimization of whole MEMs and
1091 avoid_constant_pool_reference, which is more likely to succeed. */
1092 store_save
= amd
->store
;
1094 addr
= simplify_replace_fn_rtx (SUBREG_REG (loc
), old_rtx
, adjust_mems
,
1096 amd
->store
= store_save
;
1097 mem
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1098 if (mem
== SUBREG_REG (loc
))
1103 tem
= simplify_gen_subreg (GET_MODE (loc
), mem
,
1104 GET_MODE (SUBREG_REG (loc
)),
1108 tem
= simplify_gen_subreg (GET_MODE (loc
), addr
,
1109 GET_MODE (SUBREG_REG (loc
)),
1111 if (tem
== NULL_RTX
)
1112 tem
= gen_rtx_raw_SUBREG (GET_MODE (loc
), addr
, SUBREG_BYTE (loc
));
1114 if (MAY_HAVE_DEBUG_INSNS
1115 && GET_CODE (tem
) == SUBREG
1116 && (GET_CODE (SUBREG_REG (tem
)) == PLUS
1117 || GET_CODE (SUBREG_REG (tem
)) == MINUS
1118 || GET_CODE (SUBREG_REG (tem
)) == MULT
1119 || GET_CODE (SUBREG_REG (tem
)) == ASHIFT
)
1120 && GET_MODE_CLASS (GET_MODE (tem
)) == MODE_INT
1121 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem
))) == MODE_INT
1122 && GET_MODE_SIZE (GET_MODE (tem
))
1123 < GET_MODE_SIZE (GET_MODE (SUBREG_REG (tem
)))
1124 && subreg_lowpart_p (tem
)
1125 && !for_each_rtx (&SUBREG_REG (tem
), use_narrower_mode_test
, tem
))
1126 return use_narrower_mode (SUBREG_REG (tem
), GET_MODE (tem
),
1127 GET_MODE (SUBREG_REG (tem
)));
1130 /* Don't do any replacements in second and following
1131 ASM_OPERANDS of inline-asm with multiple sets.
1132 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1133 and ASM_OPERANDS_LABEL_VEC need to be equal between
1134 all the ASM_OPERANDs in the insn and adjust_insn will
1136 if (ASM_OPERANDS_OUTPUT_IDX (loc
) != 0)
1145 /* Helper function for replacement of uses. */
1148 adjust_mem_uses (rtx
*x
, void *data
)
1150 rtx new_x
= simplify_replace_fn_rtx (*x
, NULL_RTX
, adjust_mems
, data
);
1152 validate_change (NULL_RTX
, x
, new_x
, true);
1155 /* Helper function for replacement of stores. */
1158 adjust_mem_stores (rtx loc
, const_rtx expr
, void *data
)
1162 rtx new_dest
= simplify_replace_fn_rtx (SET_DEST (expr
), NULL_RTX
,
1164 if (new_dest
!= SET_DEST (expr
))
1166 rtx xexpr
= CONST_CAST_RTX (expr
);
1167 validate_change (NULL_RTX
, &SET_DEST (xexpr
), new_dest
, true);
1172 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1173 replace them with their value in the insn and add the side-effects
1174 as other sets to the insn. */
1177 adjust_insn (basic_block bb
, rtx insn
)
1179 struct adjust_mem_data amd
;
1182 #ifdef HAVE_window_save
1183 /* If the target machine has an explicit window save instruction, the
1184 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1185 if (RTX_FRAME_RELATED_P (insn
)
1186 && find_reg_note (insn
, REG_CFA_WINDOW_SAVE
, NULL_RTX
))
1188 unsigned int i
, nregs
= vec_safe_length (windowed_parm_regs
);
1189 rtx rtl
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (nregs
* 2));
1192 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs
, i
, p
)
1194 XVECEXP (rtl
, 0, i
* 2)
1195 = gen_rtx_SET (VOIDmode
, p
->incoming
, p
->outgoing
);
1196 /* Do not clobber the attached DECL, but only the REG. */
1197 XVECEXP (rtl
, 0, i
* 2 + 1)
1198 = gen_rtx_CLOBBER (GET_MODE (p
->outgoing
),
1199 gen_raw_REG (GET_MODE (p
->outgoing
),
1200 REGNO (p
->outgoing
)));
1203 validate_change (NULL_RTX
, &PATTERN (insn
), rtl
, true);
1208 amd
.mem_mode
= VOIDmode
;
1209 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
1210 amd
.side_effects
= NULL_RTX
;
1213 note_stores (PATTERN (insn
), adjust_mem_stores
, &amd
);
1216 if (GET_CODE (PATTERN (insn
)) == PARALLEL
1217 && asm_noperands (PATTERN (insn
)) > 0
1218 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == SET
)
1223 /* inline-asm with multiple sets is tiny bit more complicated,
1224 because the 3 vectors in ASM_OPERANDS need to be shared between
1225 all ASM_OPERANDS in the instruction. adjust_mems will
1226 not touch ASM_OPERANDS other than the first one, asm_noperands
1227 test above needs to be called before that (otherwise it would fail)
1228 and afterwards this code fixes it up. */
1229 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1230 body
= PATTERN (insn
);
1231 set0
= XVECEXP (body
, 0, 0);
1232 gcc_checking_assert (GET_CODE (set0
) == SET
1233 && GET_CODE (SET_SRC (set0
)) == ASM_OPERANDS
1234 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0
)) == 0);
1235 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1236 if (GET_CODE (XVECEXP (body
, 0, i
)) != SET
)
1240 set
= XVECEXP (body
, 0, i
);
1241 gcc_checking_assert (GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
1242 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set
))
1244 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set
))
1245 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
))
1246 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set
))
1247 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
))
1248 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set
))
1249 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
)))
1251 rtx newsrc
= shallow_copy_rtx (SET_SRC (set
));
1252 ASM_OPERANDS_INPUT_VEC (newsrc
)
1253 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
));
1254 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc
)
1255 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
));
1256 ASM_OPERANDS_LABEL_VEC (newsrc
)
1257 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
));
1258 validate_change (NULL_RTX
, &SET_SRC (set
), newsrc
, true);
1263 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1265 /* For read-only MEMs containing some constant, prefer those
1267 set
= single_set (insn
);
1268 if (set
&& MEM_P (SET_SRC (set
)) && MEM_READONLY_P (SET_SRC (set
)))
1270 rtx note
= find_reg_equal_equiv_note (insn
);
1272 if (note
&& CONSTANT_P (XEXP (note
, 0)))
1273 validate_change (NULL_RTX
, &SET_SRC (set
), XEXP (note
, 0), true);
1276 if (amd
.side_effects
)
1278 rtx
*pat
, new_pat
, s
;
1281 pat
= &PATTERN (insn
);
1282 if (GET_CODE (*pat
) == COND_EXEC
)
1283 pat
= &COND_EXEC_CODE (*pat
);
1284 if (GET_CODE (*pat
) == PARALLEL
)
1285 oldn
= XVECLEN (*pat
, 0);
1288 for (s
= amd
.side_effects
, newn
= 0; s
; newn
++)
1290 new_pat
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (oldn
+ newn
));
1291 if (GET_CODE (*pat
) == PARALLEL
)
1292 for (i
= 0; i
< oldn
; i
++)
1293 XVECEXP (new_pat
, 0, i
) = XVECEXP (*pat
, 0, i
);
1295 XVECEXP (new_pat
, 0, 0) = *pat
;
1296 for (s
= amd
.side_effects
, i
= oldn
; i
< oldn
+ newn
; i
++, s
= XEXP (s
, 1))
1297 XVECEXP (new_pat
, 0, i
) = XEXP (s
, 0);
1298 free_EXPR_LIST_list (&amd
.side_effects
);
1299 validate_change (NULL_RTX
, pat
, new_pat
, true);
1303 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1305 dv_as_rtx (decl_or_value dv
)
1309 if (dv_is_value_p (dv
))
1310 return dv_as_value (dv
);
1312 decl
= dv_as_decl (dv
);
1314 gcc_checking_assert (TREE_CODE (decl
) == DEBUG_EXPR_DECL
);
1315 return DECL_RTL_KNOWN_SET (decl
);
1318 /* Return nonzero if a decl_or_value must not have more than one
1319 variable part. The returned value discriminates among various
1320 kinds of one-part DVs ccording to enum onepart_enum. */
1321 static inline onepart_enum_t
1322 dv_onepart_p (decl_or_value dv
)
1326 if (!MAY_HAVE_DEBUG_INSNS
)
1329 if (dv_is_value_p (dv
))
1330 return ONEPART_VALUE
;
1332 decl
= dv_as_decl (dv
);
1334 if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
1335 return ONEPART_DEXPR
;
1337 if (target_for_debug_bind (decl
) != NULL_TREE
)
1338 return ONEPART_VDECL
;
1343 /* Return the variable pool to be used for a dv of type ONEPART. */
1344 static inline alloc_pool
1345 onepart_pool (onepart_enum_t onepart
)
1347 return onepart
? valvar_pool
: var_pool
;
1350 /* Build a decl_or_value out of a decl. */
1351 static inline decl_or_value
1352 dv_from_decl (tree decl
)
1356 gcc_checking_assert (dv_is_decl_p (dv
));
1360 /* Build a decl_or_value out of a value. */
1361 static inline decl_or_value
1362 dv_from_value (rtx value
)
1366 gcc_checking_assert (dv_is_value_p (dv
));
1370 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1371 static inline decl_or_value
1376 switch (GET_CODE (x
))
1379 dv
= dv_from_decl (DEBUG_EXPR_TREE_DECL (x
));
1380 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x
)) == x
);
1384 dv
= dv_from_value (x
);
1394 extern void debug_dv (decl_or_value dv
);
1397 debug_dv (decl_or_value dv
)
1399 if (dv_is_value_p (dv
))
1400 debug_rtx (dv_as_value (dv
));
1402 debug_generic_stmt (dv_as_decl (dv
));
1405 static void loc_exp_dep_clear (variable var
);
1407 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1410 variable_htab_free (void *elem
)
1413 variable var
= (variable
) elem
;
1414 location_chain node
, next
;
1416 gcc_checking_assert (var
->refcount
> 0);
1419 if (var
->refcount
> 0)
1422 for (i
= 0; i
< var
->n_var_parts
; i
++)
1424 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= next
)
1427 pool_free (loc_chain_pool
, node
);
1429 var
->var_part
[i
].loc_chain
= NULL
;
1431 if (var
->onepart
&& VAR_LOC_1PAUX (var
))
1433 loc_exp_dep_clear (var
);
1434 if (VAR_LOC_DEP_LST (var
))
1435 VAR_LOC_DEP_LST (var
)->pprev
= NULL
;
1436 XDELETE (VAR_LOC_1PAUX (var
));
1437 /* These may be reused across functions, so reset
1439 if (var
->onepart
== ONEPART_DEXPR
)
1440 set_dv_changed (var
->dv
, true);
1442 pool_free (onepart_pool (var
->onepart
), var
);
1445 /* Initialize the set (array) SET of attrs to empty lists. */
1448 init_attrs_list_set (attrs
*set
)
1452 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1456 /* Make the list *LISTP empty. */
1459 attrs_list_clear (attrs
*listp
)
1463 for (list
= *listp
; list
; list
= next
)
1466 pool_free (attrs_pool
, list
);
1471 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1474 attrs_list_member (attrs list
, decl_or_value dv
, HOST_WIDE_INT offset
)
1476 for (; list
; list
= list
->next
)
1477 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
) && list
->offset
== offset
)
1482 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1485 attrs_list_insert (attrs
*listp
, decl_or_value dv
,
1486 HOST_WIDE_INT offset
, rtx loc
)
1490 list
= (attrs
) pool_alloc (attrs_pool
);
1493 list
->offset
= offset
;
1494 list
->next
= *listp
;
1498 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1501 attrs_list_copy (attrs
*dstp
, attrs src
)
1505 attrs_list_clear (dstp
);
1506 for (; src
; src
= src
->next
)
1508 n
= (attrs
) pool_alloc (attrs_pool
);
1511 n
->offset
= src
->offset
;
1517 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1520 attrs_list_union (attrs
*dstp
, attrs src
)
1522 for (; src
; src
= src
->next
)
1524 if (!attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1525 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1529 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1533 attrs_list_mpdv_union (attrs
*dstp
, attrs src
, attrs src2
)
1535 gcc_assert (!*dstp
);
1536 for (; src
; src
= src
->next
)
1538 if (!dv_onepart_p (src
->dv
))
1539 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1541 for (src
= src2
; src
; src
= src
->next
)
1543 if (!dv_onepart_p (src
->dv
)
1544 && !attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1545 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1549 /* Shared hashtable support. */
1551 /* Return true if VARS is shared. */
1554 shared_hash_shared (shared_hash vars
)
1556 return vars
->refcount
> 1;
1559 /* Return the hash table for VARS. */
1561 static inline variable_table_type
1562 shared_hash_htab (shared_hash vars
)
1567 /* Return true if VAR is shared, or maybe because VARS is shared. */
1570 shared_var_p (variable var
, shared_hash vars
)
1572 /* Don't count an entry in the changed_variables table as a duplicate. */
1573 return ((var
->refcount
> 1 + (int) var
->in_changed_variables
)
1574 || shared_hash_shared (vars
));
1577 /* Copy variables into a new hash table. */
1580 shared_hash_unshare (shared_hash vars
)
1582 shared_hash new_vars
= (shared_hash
) pool_alloc (shared_hash_pool
);
1583 gcc_assert (vars
->refcount
> 1);
1584 new_vars
->refcount
= 1;
1585 new_vars
->htab
.create (vars
->htab
.elements () + 3);
1586 vars_copy (new_vars
->htab
, vars
->htab
);
1591 /* Increment reference counter on VARS and return it. */
1593 static inline shared_hash
1594 shared_hash_copy (shared_hash vars
)
1600 /* Decrement reference counter and destroy hash table if not shared
1604 shared_hash_destroy (shared_hash vars
)
1606 gcc_checking_assert (vars
->refcount
> 0);
1607 if (--vars
->refcount
== 0)
1609 vars
->htab
.dispose ();
1610 pool_free (shared_hash_pool
, vars
);
1614 /* Unshare *PVARS if shared and return slot for DV. If INS is
1615 INSERT, insert it if not already present. */
1617 static inline variable_def
**
1618 shared_hash_find_slot_unshare_1 (shared_hash
*pvars
, decl_or_value dv
,
1619 hashval_t dvhash
, enum insert_option ins
)
1621 if (shared_hash_shared (*pvars
))
1622 *pvars
= shared_hash_unshare (*pvars
);
1623 return shared_hash_htab (*pvars
).find_slot_with_hash (dv
, dvhash
, ins
);
1626 static inline variable_def
**
1627 shared_hash_find_slot_unshare (shared_hash
*pvars
, decl_or_value dv
,
1628 enum insert_option ins
)
1630 return shared_hash_find_slot_unshare_1 (pvars
, dv
, dv_htab_hash (dv
), ins
);
1633 /* Return slot for DV, if it is already present in the hash table.
1634 If it is not present, insert it only VARS is not shared, otherwise
1637 static inline variable_def
**
1638 shared_hash_find_slot_1 (shared_hash vars
, decl_or_value dv
, hashval_t dvhash
)
1640 return shared_hash_htab (vars
).find_slot_with_hash (dv
, dvhash
,
1641 shared_hash_shared (vars
)
1642 ? NO_INSERT
: INSERT
);
1645 static inline variable_def
**
1646 shared_hash_find_slot (shared_hash vars
, decl_or_value dv
)
1648 return shared_hash_find_slot_1 (vars
, dv
, dv_htab_hash (dv
));
1651 /* Return slot for DV only if it is already present in the hash table. */
1653 static inline variable_def
**
1654 shared_hash_find_slot_noinsert_1 (shared_hash vars
, decl_or_value dv
,
1657 return shared_hash_htab (vars
).find_slot_with_hash (dv
, dvhash
, NO_INSERT
);
1660 static inline variable_def
**
1661 shared_hash_find_slot_noinsert (shared_hash vars
, decl_or_value dv
)
1663 return shared_hash_find_slot_noinsert_1 (vars
, dv
, dv_htab_hash (dv
));
1666 /* Return variable for DV or NULL if not already present in the hash
1669 static inline variable
1670 shared_hash_find_1 (shared_hash vars
, decl_or_value dv
, hashval_t dvhash
)
1672 return shared_hash_htab (vars
).find_with_hash (dv
, dvhash
);
1675 static inline variable
1676 shared_hash_find (shared_hash vars
, decl_or_value dv
)
1678 return shared_hash_find_1 (vars
, dv
, dv_htab_hash (dv
));
1681 /* Return true if TVAL is better than CVAL as a canonival value. We
1682 choose lowest-numbered VALUEs, using the RTX address as a
1683 tie-breaker. The idea is to arrange them into a star topology,
1684 such that all of them are at most one step away from the canonical
1685 value, and the canonical value has backlinks to all of them, in
1686 addition to all the actual locations. We don't enforce this
1687 topology throughout the entire dataflow analysis, though.
1691 canon_value_cmp (rtx tval
, rtx cval
)
1694 || CSELIB_VAL_PTR (tval
)->uid
< CSELIB_VAL_PTR (cval
)->uid
;
1697 static bool dst_can_be_shared
;
1699 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1701 static variable_def
**
1702 unshare_variable (dataflow_set
*set
, variable_def
**slot
, variable var
,
1703 enum var_init_status initialized
)
1708 new_var
= (variable
) pool_alloc (onepart_pool (var
->onepart
));
1709 new_var
->dv
= var
->dv
;
1710 new_var
->refcount
= 1;
1712 new_var
->n_var_parts
= var
->n_var_parts
;
1713 new_var
->onepart
= var
->onepart
;
1714 new_var
->in_changed_variables
= false;
1716 if (! flag_var_tracking_uninit
)
1717 initialized
= VAR_INIT_STATUS_INITIALIZED
;
1719 for (i
= 0; i
< var
->n_var_parts
; i
++)
1721 location_chain node
;
1722 location_chain
*nextp
;
1724 if (i
== 0 && var
->onepart
)
1726 /* One-part auxiliary data is only used while emitting
1727 notes, so propagate it to the new variable in the active
1728 dataflow set. If we're not emitting notes, this will be
1730 gcc_checking_assert (!VAR_LOC_1PAUX (var
) || emit_notes
);
1731 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (var
);
1732 VAR_LOC_1PAUX (var
) = NULL
;
1735 VAR_PART_OFFSET (new_var
, i
) = VAR_PART_OFFSET (var
, i
);
1736 nextp
= &new_var
->var_part
[i
].loc_chain
;
1737 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
1739 location_chain new_lc
;
1741 new_lc
= (location_chain
) pool_alloc (loc_chain_pool
);
1742 new_lc
->next
= NULL
;
1743 if (node
->init
> initialized
)
1744 new_lc
->init
= node
->init
;
1746 new_lc
->init
= initialized
;
1747 if (node
->set_src
&& !(MEM_P (node
->set_src
)))
1748 new_lc
->set_src
= node
->set_src
;
1750 new_lc
->set_src
= NULL
;
1751 new_lc
->loc
= node
->loc
;
1754 nextp
= &new_lc
->next
;
1757 new_var
->var_part
[i
].cur_loc
= var
->var_part
[i
].cur_loc
;
1760 dst_can_be_shared
= false;
1761 if (shared_hash_shared (set
->vars
))
1762 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
, NO_INSERT
);
1763 else if (set
->traversed_vars
&& set
->vars
!= set
->traversed_vars
)
1764 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
1766 if (var
->in_changed_variables
)
1768 variable_def
**cslot
1769 = changed_variables
.find_slot_with_hash (var
->dv
,
1770 dv_htab_hash (var
->dv
), NO_INSERT
);
1771 gcc_assert (*cslot
== (void *) var
);
1772 var
->in_changed_variables
= false;
1773 variable_htab_free (var
);
1775 new_var
->in_changed_variables
= true;
1780 /* Copy all variables from hash table SRC to hash table DST. */
1783 vars_copy (variable_table_type dst
, variable_table_type src
)
1785 variable_iterator_type hi
;
1788 FOR_EACH_HASH_TABLE_ELEMENT (src
, var
, variable
, hi
)
1790 variable_def
**dstp
;
1792 dstp
= dst
.find_slot_with_hash (var
->dv
, dv_htab_hash (var
->dv
), INSERT
);
1797 /* Map a decl to its main debug decl. */
1800 var_debug_decl (tree decl
)
1802 if (decl
&& TREE_CODE (decl
) == VAR_DECL
1803 && DECL_HAS_DEBUG_EXPR_P (decl
))
1805 tree debugdecl
= DECL_DEBUG_EXPR (decl
);
1806 if (DECL_P (debugdecl
))
1813 /* Set the register LOC to contain DV, OFFSET. */
1816 var_reg_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1817 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
1818 enum insert_option iopt
)
1821 bool decl_p
= dv_is_decl_p (dv
);
1824 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
1826 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
1827 if (dv_as_opaque (node
->dv
) == dv_as_opaque (dv
)
1828 && node
->offset
== offset
)
1831 attrs_list_insert (&set
->regs
[REGNO (loc
)], dv
, offset
, loc
);
1832 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
1835 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1838 var_reg_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1841 tree decl
= REG_EXPR (loc
);
1842 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1844 var_reg_decl_set (set
, loc
, initialized
,
1845 dv_from_decl (decl
), offset
, set_src
, INSERT
);
1848 static enum var_init_status
1849 get_init_value (dataflow_set
*set
, rtx loc
, decl_or_value dv
)
1853 enum var_init_status ret_val
= VAR_INIT_STATUS_UNKNOWN
;
1855 if (! flag_var_tracking_uninit
)
1856 return VAR_INIT_STATUS_INITIALIZED
;
1858 var
= shared_hash_find (set
->vars
, dv
);
1861 for (i
= 0; i
< var
->n_var_parts
&& ret_val
== VAR_INIT_STATUS_UNKNOWN
; i
++)
1863 location_chain nextp
;
1864 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
; nextp
= nextp
->next
)
1865 if (rtx_equal_p (nextp
->loc
, loc
))
1867 ret_val
= nextp
->init
;
1876 /* Delete current content of register LOC in dataflow set SET and set
1877 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1878 MODIFY is true, any other live copies of the same variable part are
1879 also deleted from the dataflow set, otherwise the variable part is
1880 assumed to be copied from another location holding the same
1884 var_reg_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
1885 enum var_init_status initialized
, rtx set_src
)
1887 tree decl
= REG_EXPR (loc
);
1888 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1892 decl
= var_debug_decl (decl
);
1894 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
1895 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
1897 nextp
= &set
->regs
[REGNO (loc
)];
1898 for (node
= *nextp
; node
; node
= next
)
1901 if (dv_as_opaque (node
->dv
) != decl
|| node
->offset
!= offset
)
1903 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1904 pool_free (attrs_pool
, node
);
1910 nextp
= &node
->next
;
1914 clobber_variable_part (set
, loc
, dv_from_decl (decl
), offset
, set_src
);
1915 var_reg_set (set
, loc
, initialized
, set_src
);
1918 /* Delete the association of register LOC in dataflow set SET with any
1919 variables that aren't onepart. If CLOBBER is true, also delete any
1920 other live copies of the same variable part, and delete the
1921 association with onepart dvs too. */
1924 var_reg_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
1926 attrs
*nextp
= &set
->regs
[REGNO (loc
)];
1931 tree decl
= REG_EXPR (loc
);
1932 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1934 decl
= var_debug_decl (decl
);
1936 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
1939 for (node
= *nextp
; node
; node
= next
)
1942 if (clobber
|| !dv_onepart_p (node
->dv
))
1944 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1945 pool_free (attrs_pool
, node
);
1949 nextp
= &node
->next
;
1953 /* Delete content of register with number REGNO in dataflow set SET. */
1956 var_regno_delete (dataflow_set
*set
, int regno
)
1958 attrs
*reg
= &set
->regs
[regno
];
1961 for (node
= *reg
; node
; node
= next
)
1964 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1965 pool_free (attrs_pool
, node
);
1970 /* Return true if I is the negated value of a power of two. */
1972 negative_power_of_two_p (HOST_WIDE_INT i
)
1974 unsigned HOST_WIDE_INT x
= -(unsigned HOST_WIDE_INT
)i
;
1975 return x
== (x
& -x
);
1978 /* Strip constant offsets and alignments off of LOC. Return the base
1982 vt_get_canonicalize_base (rtx loc
)
1984 while ((GET_CODE (loc
) == PLUS
1985 || GET_CODE (loc
) == AND
)
1986 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
1987 && (GET_CODE (loc
) != AND
1988 || negative_power_of_two_p (INTVAL (XEXP (loc
, 1)))))
1989 loc
= XEXP (loc
, 0);
1994 /* This caches canonicalized addresses for VALUEs, computed using
1995 information in the global cselib table. */
1996 static struct pointer_map_t
*global_get_addr_cache
;
1998 /* This caches canonicalized addresses for VALUEs, computed using
1999 information from the global cache and information pertaining to a
2000 basic block being analyzed. */
2001 static struct pointer_map_t
*local_get_addr_cache
;
2003 static rtx
vt_canonicalize_addr (dataflow_set
*, rtx
);
2005 /* Return the canonical address for LOC, that must be a VALUE, using a
2006 cached global equivalence or computing it and storing it in the
2010 get_addr_from_global_cache (rtx
const loc
)
2015 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2017 slot
= pointer_map_insert (global_get_addr_cache
, loc
);
2021 x
= canon_rtx (get_addr (loc
));
2023 /* Tentative, avoiding infinite recursion. */
2028 rtx nx
= vt_canonicalize_addr (NULL
, x
);
2031 /* The table may have moved during recursion, recompute
2033 slot
= pointer_map_contains (global_get_addr_cache
, loc
);
2041 /* Return the canonical address for LOC, that must be a VALUE, using a
2042 cached local equivalence or computing it and storing it in the
2046 get_addr_from_local_cache (dataflow_set
*set
, rtx
const loc
)
2054 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2056 slot
= pointer_map_insert (local_get_addr_cache
, loc
);
2060 x
= get_addr_from_global_cache (loc
);
2062 /* Tentative, avoiding infinite recursion. */
2065 /* Recurse to cache local expansion of X, or if we need to search
2066 for a VALUE in the expansion. */
2069 rtx nx
= vt_canonicalize_addr (set
, x
);
2072 slot
= pointer_map_contains (local_get_addr_cache
, loc
);
2078 dv
= dv_from_rtx (x
);
2079 var
= shared_hash_find (set
->vars
, dv
);
2083 /* Look for an improved equivalent expression. */
2084 for (l
= var
->var_part
[0].loc_chain
; l
; l
= l
->next
)
2086 rtx base
= vt_get_canonicalize_base (l
->loc
);
2087 if (GET_CODE (base
) == VALUE
2088 && canon_value_cmp (base
, loc
))
2090 rtx nx
= vt_canonicalize_addr (set
, l
->loc
);
2093 slot
= pointer_map_contains (local_get_addr_cache
, loc
);
2103 /* Canonicalize LOC using equivalences from SET in addition to those
2104 in the cselib static table. It expects a VALUE-based expression,
2105 and it will only substitute VALUEs with other VALUEs or
2106 function-global equivalences, so that, if two addresses have base
2107 VALUEs that are locally or globally related in ways that
2108 memrefs_conflict_p cares about, they will both canonicalize to
2109 expressions that have the same base VALUE.
2111 The use of VALUEs as canonical base addresses enables the canonical
2112 RTXs to remain unchanged globally, if they resolve to a constant,
2113 or throughout a basic block otherwise, so that they can be cached
2114 and the cache needs not be invalidated when REGs, MEMs or such
2118 vt_canonicalize_addr (dataflow_set
*set
, rtx oloc
)
2120 HOST_WIDE_INT ofst
= 0;
2121 enum machine_mode mode
= GET_MODE (oloc
);
2128 while (GET_CODE (loc
) == PLUS
2129 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2131 ofst
+= INTVAL (XEXP (loc
, 1));
2132 loc
= XEXP (loc
, 0);
2135 /* Alignment operations can't normally be combined, so just
2136 canonicalize the base and we're done. We'll normally have
2137 only one stack alignment anyway. */
2138 if (GET_CODE (loc
) == AND
2139 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
2140 && negative_power_of_two_p (INTVAL (XEXP (loc
, 1))))
2142 x
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2143 if (x
!= XEXP (loc
, 0))
2144 loc
= gen_rtx_AND (mode
, x
, XEXP (loc
, 1));
2148 if (GET_CODE (loc
) == VALUE
)
2151 loc
= get_addr_from_local_cache (set
, loc
);
2153 loc
= get_addr_from_global_cache (loc
);
2155 /* Consolidate plus_constants. */
2156 while (ofst
&& GET_CODE (loc
) == PLUS
2157 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2159 ofst
+= INTVAL (XEXP (loc
, 1));
2160 loc
= XEXP (loc
, 0);
2167 x
= canon_rtx (loc
);
2174 /* Add OFST back in. */
2177 /* Don't build new RTL if we can help it. */
2178 if (GET_CODE (oloc
) == PLUS
2179 && XEXP (oloc
, 0) == loc
2180 && INTVAL (XEXP (oloc
, 1)) == ofst
)
2183 loc
= plus_constant (mode
, loc
, ofst
);
2189 /* Return true iff there's a true dependence between MLOC and LOC.
2190 MADDR must be a canonicalized version of MLOC's address. */
2193 vt_canon_true_dep (dataflow_set
*set
, rtx mloc
, rtx maddr
, rtx loc
)
2195 if (GET_CODE (loc
) != MEM
)
2198 rtx addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2199 if (!canon_true_dependence (mloc
, GET_MODE (mloc
), maddr
, loc
, addr
))
2205 /* Hold parameters for the hashtab traversal function
2206 drop_overlapping_mem_locs, see below. */
2208 struct overlapping_mems
2214 /* Remove all MEMs that overlap with COMS->LOC from the location list
2215 of a hash table entry for a value. COMS->ADDR must be a
2216 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2217 canonicalized itself. */
2220 drop_overlapping_mem_locs (variable_def
**slot
, overlapping_mems
*coms
)
2222 dataflow_set
*set
= coms
->set
;
2223 rtx mloc
= coms
->loc
, addr
= coms
->addr
;
2224 variable var
= *slot
;
2226 if (var
->onepart
== ONEPART_VALUE
)
2228 location_chain loc
, *locp
;
2229 bool changed
= false;
2232 gcc_assert (var
->n_var_parts
== 1);
2234 if (shared_var_p (var
, set
->vars
))
2236 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
2237 if (vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2243 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
2245 gcc_assert (var
->n_var_parts
== 1);
2248 if (VAR_LOC_1PAUX (var
))
2249 cur_loc
= VAR_LOC_FROM (var
);
2251 cur_loc
= var
->var_part
[0].cur_loc
;
2253 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
2256 if (!vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2263 /* If we have deleted the location which was last emitted
2264 we have to emit new location so add the variable to set
2265 of changed variables. */
2266 if (cur_loc
== loc
->loc
)
2269 var
->var_part
[0].cur_loc
= NULL
;
2270 if (VAR_LOC_1PAUX (var
))
2271 VAR_LOC_FROM (var
) = NULL
;
2273 pool_free (loc_chain_pool
, loc
);
2276 if (!var
->var_part
[0].loc_chain
)
2282 variable_was_changed (var
, set
);
2288 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2291 clobber_overlapping_mems (dataflow_set
*set
, rtx loc
)
2293 struct overlapping_mems coms
;
2295 gcc_checking_assert (GET_CODE (loc
) == MEM
);
2298 coms
.loc
= canon_rtx (loc
);
2299 coms
.addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2301 set
->traversed_vars
= set
->vars
;
2302 shared_hash_htab (set
->vars
)
2303 .traverse
<overlapping_mems
*, drop_overlapping_mem_locs
> (&coms
);
2304 set
->traversed_vars
= NULL
;
2307 /* Set the location of DV, OFFSET as the MEM LOC. */
2310 var_mem_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2311 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
2312 enum insert_option iopt
)
2314 if (dv_is_decl_p (dv
))
2315 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
2317 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
2320 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2322 Adjust the address first if it is stack pointer based. */
2325 var_mem_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2328 tree decl
= MEM_EXPR (loc
);
2329 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2331 var_mem_decl_set (set
, loc
, initialized
,
2332 dv_from_decl (decl
), offset
, set_src
, INSERT
);
2335 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2336 dataflow set SET to LOC. If MODIFY is true, any other live copies
2337 of the same variable part are also deleted from the dataflow set,
2338 otherwise the variable part is assumed to be copied from another
2339 location holding the same part.
2340 Adjust the address first if it is stack pointer based. */
2343 var_mem_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
2344 enum var_init_status initialized
, rtx set_src
)
2346 tree decl
= MEM_EXPR (loc
);
2347 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2349 clobber_overlapping_mems (set
, loc
);
2350 decl
= var_debug_decl (decl
);
2352 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
2353 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
2356 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, set_src
);
2357 var_mem_set (set
, loc
, initialized
, set_src
);
2360 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2361 true, also delete any other live copies of the same variable part.
2362 Adjust the address first if it is stack pointer based. */
2365 var_mem_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
2367 tree decl
= MEM_EXPR (loc
);
2368 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2370 clobber_overlapping_mems (set
, loc
);
2371 decl
= var_debug_decl (decl
);
2373 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
2374 delete_variable_part (set
, loc
, dv_from_decl (decl
), offset
);
2377 /* Return true if LOC should not be expanded for location expressions,
2381 unsuitable_loc (rtx loc
)
2383 switch (GET_CODE (loc
))
2397 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2401 val_bind (dataflow_set
*set
, rtx val
, rtx loc
, bool modified
)
2406 var_regno_delete (set
, REGNO (loc
));
2407 var_reg_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2408 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2410 else if (MEM_P (loc
))
2412 struct elt_loc_list
*l
= CSELIB_VAL_PTR (val
)->locs
;
2415 clobber_overlapping_mems (set
, loc
);
2417 if (l
&& GET_CODE (l
->loc
) == VALUE
)
2418 l
= canonical_cselib_val (CSELIB_VAL_PTR (l
->loc
))->locs
;
2420 /* If this MEM is a global constant, we don't need it in the
2421 dynamic tables. ??? We should test this before emitting the
2422 micro-op in the first place. */
2424 if (GET_CODE (l
->loc
) == MEM
&& XEXP (l
->loc
, 0) == XEXP (loc
, 0))
2430 var_mem_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2431 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2435 /* Other kinds of equivalences are necessarily static, at least
2436 so long as we do not perform substitutions while merging
2439 set_variable_part (set
, loc
, dv_from_value (val
), 0,
2440 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2444 /* Bind a value to a location it was just stored in. If MODIFIED
2445 holds, assume the location was modified, detaching it from any
2446 values bound to it. */
2449 val_store (dataflow_set
*set
, rtx val
, rtx loc
, rtx insn
, bool modified
)
2451 cselib_val
*v
= CSELIB_VAL_PTR (val
);
2453 gcc_assert (cselib_preserved_value_p (v
));
2457 fprintf (dump_file
, "%i: ", insn
? INSN_UID (insn
) : 0);
2458 print_inline_rtx (dump_file
, loc
, 0);
2459 fprintf (dump_file
, " evaluates to ");
2460 print_inline_rtx (dump_file
, val
, 0);
2463 struct elt_loc_list
*l
;
2464 for (l
= v
->locs
; l
; l
= l
->next
)
2466 fprintf (dump_file
, "\n%i: ", INSN_UID (l
->setting_insn
));
2467 print_inline_rtx (dump_file
, l
->loc
, 0);
2470 fprintf (dump_file
, "\n");
2473 gcc_checking_assert (!unsuitable_loc (loc
));
2475 val_bind (set
, val
, loc
, modified
);
2478 /* Clear (canonical address) slots that reference X. */
2481 local_get_addr_clear_given_value (const void *v ATTRIBUTE_UNUSED
,
2482 void **slot
, void *x
)
2484 if (vt_get_canonicalize_base ((rtx
)*slot
) == x
)
2489 /* Reset this node, detaching all its equivalences. Return the slot
2490 in the variable hash table that holds dv, if there is one. */
2493 val_reset (dataflow_set
*set
, decl_or_value dv
)
2495 variable var
= shared_hash_find (set
->vars
, dv
) ;
2496 location_chain node
;
2499 if (!var
|| !var
->n_var_parts
)
2502 gcc_assert (var
->n_var_parts
== 1);
2504 if (var
->onepart
== ONEPART_VALUE
)
2506 rtx x
= dv_as_value (dv
);
2509 /* Relationships in the global cache don't change, so reset the
2510 local cache entry only. */
2511 slot
= pointer_map_contains (local_get_addr_cache
, x
);
2514 /* If the value resolved back to itself, odds are that other
2515 values may have cached it too. These entries now refer
2516 to the old X, so detach them too. Entries that used the
2517 old X but resolved to something else remain ok as long as
2518 that something else isn't also reset. */
2520 pointer_map_traverse (local_get_addr_cache
,
2521 local_get_addr_clear_given_value
, x
);
2527 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2528 if (GET_CODE (node
->loc
) == VALUE
2529 && canon_value_cmp (node
->loc
, cval
))
2532 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2533 if (GET_CODE (node
->loc
) == VALUE
&& cval
!= node
->loc
)
2535 /* Redirect the equivalence link to the new canonical
2536 value, or simply remove it if it would point at
2539 set_variable_part (set
, cval
, dv_from_value (node
->loc
),
2540 0, node
->init
, node
->set_src
, NO_INSERT
);
2541 delete_variable_part (set
, dv_as_value (dv
),
2542 dv_from_value (node
->loc
), 0);
2547 decl_or_value cdv
= dv_from_value (cval
);
2549 /* Keep the remaining values connected, accummulating links
2550 in the canonical value. */
2551 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2553 if (node
->loc
== cval
)
2555 else if (GET_CODE (node
->loc
) == REG
)
2556 var_reg_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2557 node
->set_src
, NO_INSERT
);
2558 else if (GET_CODE (node
->loc
) == MEM
)
2559 var_mem_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2560 node
->set_src
, NO_INSERT
);
2562 set_variable_part (set
, node
->loc
, cdv
, 0,
2563 node
->init
, node
->set_src
, NO_INSERT
);
2567 /* We remove this last, to make sure that the canonical value is not
2568 removed to the point of requiring reinsertion. */
2570 delete_variable_part (set
, dv_as_value (dv
), dv_from_value (cval
), 0);
2572 clobber_variable_part (set
, NULL
, dv
, 0, NULL
);
2575 /* Find the values in a given location and map the val to another
2576 value, if it is unique, or add the location as one holding the
2580 val_resolve (dataflow_set
*set
, rtx val
, rtx loc
, rtx insn
)
2582 decl_or_value dv
= dv_from_value (val
);
2584 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2587 fprintf (dump_file
, "%i: ", INSN_UID (insn
));
2589 fprintf (dump_file
, "head: ");
2590 print_inline_rtx (dump_file
, val
, 0);
2591 fputs (" is at ", dump_file
);
2592 print_inline_rtx (dump_file
, loc
, 0);
2593 fputc ('\n', dump_file
);
2596 val_reset (set
, dv
);
2598 gcc_checking_assert (!unsuitable_loc (loc
));
2602 attrs node
, found
= NULL
;
2604 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
2605 if (dv_is_value_p (node
->dv
)
2606 && GET_MODE (dv_as_value (node
->dv
)) == GET_MODE (loc
))
2610 /* Map incoming equivalences. ??? Wouldn't it be nice if
2611 we just started sharing the location lists? Maybe a
2612 circular list ending at the value itself or some
2614 set_variable_part (set
, dv_as_value (node
->dv
),
2615 dv_from_value (val
), node
->offset
,
2616 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2617 set_variable_part (set
, val
, node
->dv
, node
->offset
,
2618 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2621 /* If we didn't find any equivalence, we need to remember that
2622 this value is held in the named register. */
2626 /* ??? Attempt to find and merge equivalent MEMs or other
2629 val_bind (set
, val
, loc
, false);
2632 /* Initialize dataflow set SET to be empty.
2633 VARS_SIZE is the initial size of hash table VARS. */
2636 dataflow_set_init (dataflow_set
*set
)
2638 init_attrs_list_set (set
->regs
);
2639 set
->vars
= shared_hash_copy (empty_shared_hash
);
2640 set
->stack_adjust
= 0;
2641 set
->traversed_vars
= NULL
;
2644 /* Delete the contents of dataflow set SET. */
2647 dataflow_set_clear (dataflow_set
*set
)
2651 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2652 attrs_list_clear (&set
->regs
[i
]);
2654 shared_hash_destroy (set
->vars
);
2655 set
->vars
= shared_hash_copy (empty_shared_hash
);
2658 /* Copy the contents of dataflow set SRC to DST. */
2661 dataflow_set_copy (dataflow_set
*dst
, dataflow_set
*src
)
2665 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2666 attrs_list_copy (&dst
->regs
[i
], src
->regs
[i
]);
2668 shared_hash_destroy (dst
->vars
);
2669 dst
->vars
= shared_hash_copy (src
->vars
);
2670 dst
->stack_adjust
= src
->stack_adjust
;
2673 /* Information for merging lists of locations for a given offset of variable.
2675 struct variable_union_info
2677 /* Node of the location chain. */
2680 /* The sum of positions in the input chains. */
2683 /* The position in the chain of DST dataflow set. */
2687 /* Buffer for location list sorting and its allocated size. */
2688 static struct variable_union_info
*vui_vec
;
2689 static int vui_allocated
;
2691 /* Compare function for qsort, order the structures by POS element. */
2694 variable_union_info_cmp_pos (const void *n1
, const void *n2
)
2696 const struct variable_union_info
*const i1
=
2697 (const struct variable_union_info
*) n1
;
2698 const struct variable_union_info
*const i2
=
2699 ( const struct variable_union_info
*) n2
;
2701 if (i1
->pos
!= i2
->pos
)
2702 return i1
->pos
- i2
->pos
;
2704 return (i1
->pos_dst
- i2
->pos_dst
);
2707 /* Compute union of location parts of variable *SLOT and the same variable
2708 from hash table DATA. Compute "sorted" union of the location chains
2709 for common offsets, i.e. the locations of a variable part are sorted by
2710 a priority where the priority is the sum of the positions in the 2 chains
2711 (if a location is only in one list the position in the second list is
2712 defined to be larger than the length of the chains).
2713 When we are updating the location parts the newest location is in the
2714 beginning of the chain, so when we do the described "sorted" union
2715 we keep the newest locations in the beginning. */
2718 variable_union (variable src
, dataflow_set
*set
)
2721 variable_def
**dstp
;
2724 dstp
= shared_hash_find_slot (set
->vars
, src
->dv
);
2725 if (!dstp
|| !*dstp
)
2729 dst_can_be_shared
= false;
2731 dstp
= shared_hash_find_slot_unshare (&set
->vars
, src
->dv
, INSERT
);
2735 /* Continue traversing the hash table. */
2741 gcc_assert (src
->n_var_parts
);
2742 gcc_checking_assert (src
->onepart
== dst
->onepart
);
2744 /* We can combine one-part variables very efficiently, because their
2745 entries are in canonical order. */
2748 location_chain
*nodep
, dnode
, snode
;
2750 gcc_assert (src
->n_var_parts
== 1
2751 && dst
->n_var_parts
== 1);
2753 snode
= src
->var_part
[0].loc_chain
;
2756 restart_onepart_unshared
:
2757 nodep
= &dst
->var_part
[0].loc_chain
;
2763 int r
= dnode
? loc_cmp (dnode
->loc
, snode
->loc
) : 1;
2767 location_chain nnode
;
2769 if (shared_var_p (dst
, set
->vars
))
2771 dstp
= unshare_variable (set
, dstp
, dst
,
2772 VAR_INIT_STATUS_INITIALIZED
);
2774 goto restart_onepart_unshared
;
2777 *nodep
= nnode
= (location_chain
) pool_alloc (loc_chain_pool
);
2778 nnode
->loc
= snode
->loc
;
2779 nnode
->init
= snode
->init
;
2780 if (!snode
->set_src
|| MEM_P (snode
->set_src
))
2781 nnode
->set_src
= NULL
;
2783 nnode
->set_src
= snode
->set_src
;
2784 nnode
->next
= dnode
;
2788 gcc_checking_assert (rtx_equal_p (dnode
->loc
, snode
->loc
));
2791 snode
= snode
->next
;
2793 nodep
= &dnode
->next
;
2800 gcc_checking_assert (!src
->onepart
);
2802 /* Count the number of location parts, result is K. */
2803 for (i
= 0, j
= 0, k
= 0;
2804 i
< src
->n_var_parts
&& j
< dst
->n_var_parts
; k
++)
2806 if (VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2811 else if (VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
2816 k
+= src
->n_var_parts
- i
;
2817 k
+= dst
->n_var_parts
- j
;
2819 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2820 thus there are at most MAX_VAR_PARTS different offsets. */
2821 gcc_checking_assert (dst
->onepart
? k
== 1 : k
<= MAX_VAR_PARTS
);
2823 if (dst
->n_var_parts
!= k
&& shared_var_p (dst
, set
->vars
))
2825 dstp
= unshare_variable (set
, dstp
, dst
, VAR_INIT_STATUS_UNKNOWN
);
2829 i
= src
->n_var_parts
- 1;
2830 j
= dst
->n_var_parts
- 1;
2831 dst
->n_var_parts
= k
;
2833 for (k
--; k
>= 0; k
--)
2835 location_chain node
, node2
;
2837 if (i
>= 0 && j
>= 0
2838 && VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2840 /* Compute the "sorted" union of the chains, i.e. the locations which
2841 are in both chains go first, they are sorted by the sum of
2842 positions in the chains. */
2845 struct variable_union_info
*vui
;
2847 /* If DST is shared compare the location chains.
2848 If they are different we will modify the chain in DST with
2849 high probability so make a copy of DST. */
2850 if (shared_var_p (dst
, set
->vars
))
2852 for (node
= src
->var_part
[i
].loc_chain
,
2853 node2
= dst
->var_part
[j
].loc_chain
; node
&& node2
;
2854 node
= node
->next
, node2
= node2
->next
)
2856 if (!((REG_P (node2
->loc
)
2857 && REG_P (node
->loc
)
2858 && REGNO (node2
->loc
) == REGNO (node
->loc
))
2859 || rtx_equal_p (node2
->loc
, node
->loc
)))
2861 if (node2
->init
< node
->init
)
2862 node2
->init
= node
->init
;
2868 dstp
= unshare_variable (set
, dstp
, dst
,
2869 VAR_INIT_STATUS_UNKNOWN
);
2870 dst
= (variable
)*dstp
;
2875 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2878 for (node
= dst
->var_part
[j
].loc_chain
; node
; node
= node
->next
)
2883 /* The most common case, much simpler, no qsort is needed. */
2884 location_chain dstnode
= dst
->var_part
[j
].loc_chain
;
2885 dst
->var_part
[k
].loc_chain
= dstnode
;
2886 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
2888 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2889 if (!((REG_P (dstnode
->loc
)
2890 && REG_P (node
->loc
)
2891 && REGNO (dstnode
->loc
) == REGNO (node
->loc
))
2892 || rtx_equal_p (dstnode
->loc
, node
->loc
)))
2894 location_chain new_node
;
2896 /* Copy the location from SRC. */
2897 new_node
= (location_chain
) pool_alloc (loc_chain_pool
);
2898 new_node
->loc
= node
->loc
;
2899 new_node
->init
= node
->init
;
2900 if (!node
->set_src
|| MEM_P (node
->set_src
))
2901 new_node
->set_src
= NULL
;
2903 new_node
->set_src
= node
->set_src
;
2904 node2
->next
= new_node
;
2911 if (src_l
+ dst_l
> vui_allocated
)
2913 vui_allocated
= MAX (vui_allocated
* 2, src_l
+ dst_l
);
2914 vui_vec
= XRESIZEVEC (struct variable_union_info
, vui_vec
,
2919 /* Fill in the locations from DST. */
2920 for (node
= dst
->var_part
[j
].loc_chain
, jj
= 0; node
;
2921 node
= node
->next
, jj
++)
2924 vui
[jj
].pos_dst
= jj
;
2926 /* Pos plus value larger than a sum of 2 valid positions. */
2927 vui
[jj
].pos
= jj
+ src_l
+ dst_l
;
2930 /* Fill in the locations from SRC. */
2932 for (node
= src
->var_part
[i
].loc_chain
, ii
= 0; node
;
2933 node
= node
->next
, ii
++)
2935 /* Find location from NODE. */
2936 for (jj
= 0; jj
< dst_l
; jj
++)
2938 if ((REG_P (vui
[jj
].lc
->loc
)
2939 && REG_P (node
->loc
)
2940 && REGNO (vui
[jj
].lc
->loc
) == REGNO (node
->loc
))
2941 || rtx_equal_p (vui
[jj
].lc
->loc
, node
->loc
))
2943 vui
[jj
].pos
= jj
+ ii
;
2947 if (jj
>= dst_l
) /* The location has not been found. */
2949 location_chain new_node
;
2951 /* Copy the location from SRC. */
2952 new_node
= (location_chain
) pool_alloc (loc_chain_pool
);
2953 new_node
->loc
= node
->loc
;
2954 new_node
->init
= node
->init
;
2955 if (!node
->set_src
|| MEM_P (node
->set_src
))
2956 new_node
->set_src
= NULL
;
2958 new_node
->set_src
= node
->set_src
;
2959 vui
[n
].lc
= new_node
;
2960 vui
[n
].pos_dst
= src_l
+ dst_l
;
2961 vui
[n
].pos
= ii
+ src_l
+ dst_l
;
2968 /* Special case still very common case. For dst_l == 2
2969 all entries dst_l ... n-1 are sorted, with for i >= dst_l
2970 vui[i].pos == i + src_l + dst_l. */
2971 if (vui
[0].pos
> vui
[1].pos
)
2973 /* Order should be 1, 0, 2... */
2974 dst
->var_part
[k
].loc_chain
= vui
[1].lc
;
2975 vui
[1].lc
->next
= vui
[0].lc
;
2978 vui
[0].lc
->next
= vui
[2].lc
;
2979 vui
[n
- 1].lc
->next
= NULL
;
2982 vui
[0].lc
->next
= NULL
;
2987 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
2988 if (n
>= 3 && vui
[2].pos
< vui
[1].pos
)
2990 /* Order should be 0, 2, 1, 3... */
2991 vui
[0].lc
->next
= vui
[2].lc
;
2992 vui
[2].lc
->next
= vui
[1].lc
;
2995 vui
[1].lc
->next
= vui
[3].lc
;
2996 vui
[n
- 1].lc
->next
= NULL
;
2999 vui
[1].lc
->next
= NULL
;
3004 /* Order should be 0, 1, 2... */
3006 vui
[n
- 1].lc
->next
= NULL
;
3009 for (; ii
< n
; ii
++)
3010 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3014 qsort (vui
, n
, sizeof (struct variable_union_info
),
3015 variable_union_info_cmp_pos
);
3017 /* Reconnect the nodes in sorted order. */
3018 for (ii
= 1; ii
< n
; ii
++)
3019 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3020 vui
[n
- 1].lc
->next
= NULL
;
3021 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
3024 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
3029 else if ((i
>= 0 && j
>= 0
3030 && VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
3033 dst
->var_part
[k
] = dst
->var_part
[j
];
3036 else if ((i
>= 0 && j
>= 0
3037 && VAR_PART_OFFSET (src
, i
) > VAR_PART_OFFSET (dst
, j
))
3040 location_chain
*nextp
;
3042 /* Copy the chain from SRC. */
3043 nextp
= &dst
->var_part
[k
].loc_chain
;
3044 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3046 location_chain new_lc
;
3048 new_lc
= (location_chain
) pool_alloc (loc_chain_pool
);
3049 new_lc
->next
= NULL
;
3050 new_lc
->init
= node
->init
;
3051 if (!node
->set_src
|| MEM_P (node
->set_src
))
3052 new_lc
->set_src
= NULL
;
3054 new_lc
->set_src
= node
->set_src
;
3055 new_lc
->loc
= node
->loc
;
3058 nextp
= &new_lc
->next
;
3061 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (src
, i
);
3064 dst
->var_part
[k
].cur_loc
= NULL
;
3067 if (flag_var_tracking_uninit
)
3068 for (i
= 0; i
< src
->n_var_parts
&& i
< dst
->n_var_parts
; i
++)
3070 location_chain node
, node2
;
3071 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3072 for (node2
= dst
->var_part
[i
].loc_chain
; node2
; node2
= node2
->next
)
3073 if (rtx_equal_p (node
->loc
, node2
->loc
))
3075 if (node
->init
> node2
->init
)
3076 node2
->init
= node
->init
;
3080 /* Continue traversing the hash table. */
3084 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3087 dataflow_set_union (dataflow_set
*dst
, dataflow_set
*src
)
3091 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3092 attrs_list_union (&dst
->regs
[i
], src
->regs
[i
]);
3094 if (dst
->vars
== empty_shared_hash
)
3096 shared_hash_destroy (dst
->vars
);
3097 dst
->vars
= shared_hash_copy (src
->vars
);
3101 variable_iterator_type hi
;
3104 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (src
->vars
),
3106 variable_union (var
, dst
);
3110 /* Whether the value is currently being expanded. */
3111 #define VALUE_RECURSED_INTO(x) \
3112 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3114 /* Whether no expansion was found, saving useless lookups.
3115 It must only be set when VALUE_CHANGED is clear. */
3116 #define NO_LOC_P(x) \
3117 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3119 /* Whether cur_loc in the value needs to be (re)computed. */
3120 #define VALUE_CHANGED(x) \
3121 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3122 /* Whether cur_loc in the decl needs to be (re)computed. */
3123 #define DECL_CHANGED(x) TREE_VISITED (x)
3125 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3126 user DECLs, this means they're in changed_variables. Values and
3127 debug exprs may be left with this flag set if no user variable
3128 requires them to be evaluated. */
3131 set_dv_changed (decl_or_value dv
, bool newv
)
3133 switch (dv_onepart_p (dv
))
3137 NO_LOC_P (dv_as_value (dv
)) = false;
3138 VALUE_CHANGED (dv_as_value (dv
)) = newv
;
3143 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv
))) = false;
3144 /* Fall through... */
3147 DECL_CHANGED (dv_as_decl (dv
)) = newv
;
3152 /* Return true if DV needs to have its cur_loc recomputed. */
3155 dv_changed_p (decl_or_value dv
)
3157 return (dv_is_value_p (dv
)
3158 ? VALUE_CHANGED (dv_as_value (dv
))
3159 : DECL_CHANGED (dv_as_decl (dv
)));
3162 /* Return a location list node whose loc is rtx_equal to LOC, in the
3163 location list of a one-part variable or value VAR, or in that of
3164 any values recursively mentioned in the location lists. VARS must
3165 be in star-canonical form. */
3167 static location_chain
3168 find_loc_in_1pdv (rtx loc
, variable var
, variable_table_type vars
)
3170 location_chain node
;
3171 enum rtx_code loc_code
;
3176 gcc_checking_assert (var
->onepart
);
3178 if (!var
->n_var_parts
)
3181 gcc_checking_assert (loc
!= dv_as_opaque (var
->dv
));
3183 loc_code
= GET_CODE (loc
);
3184 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3189 if (GET_CODE (node
->loc
) != loc_code
)
3191 if (GET_CODE (node
->loc
) != VALUE
)
3194 else if (loc
== node
->loc
)
3196 else if (loc_code
!= VALUE
)
3198 if (rtx_equal_p (loc
, node
->loc
))
3203 /* Since we're in star-canonical form, we don't need to visit
3204 non-canonical nodes: one-part variables and non-canonical
3205 values would only point back to the canonical node. */
3206 if (dv_is_value_p (var
->dv
)
3207 && !canon_value_cmp (node
->loc
, dv_as_value (var
->dv
)))
3209 /* Skip all subsequent VALUEs. */
3210 while (node
->next
&& GET_CODE (node
->next
->loc
) == VALUE
)
3213 gcc_checking_assert (!canon_value_cmp (node
->loc
,
3214 dv_as_value (var
->dv
)));
3215 if (loc
== node
->loc
)
3221 gcc_checking_assert (node
== var
->var_part
[0].loc_chain
);
3222 gcc_checking_assert (!node
->next
);
3224 dv
= dv_from_value (node
->loc
);
3225 rvar
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
3226 return find_loc_in_1pdv (loc
, rvar
, vars
);
3229 /* ??? Gotta look in cselib_val locations too. */
3234 /* Hash table iteration argument passed to variable_merge. */
3237 /* The set in which the merge is to be inserted. */
3239 /* The set that we're iterating in. */
3241 /* The set that may contain the other dv we are to merge with. */
3243 /* Number of onepart dvs in src. */
3244 int src_onepart_cnt
;
3247 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3248 loc_cmp order, and it is maintained as such. */
3251 insert_into_intersection (location_chain
*nodep
, rtx loc
,
3252 enum var_init_status status
)
3254 location_chain node
;
3257 for (node
= *nodep
; node
; nodep
= &node
->next
, node
= *nodep
)
3258 if ((r
= loc_cmp (node
->loc
, loc
)) == 0)
3260 node
->init
= MIN (node
->init
, status
);
3266 node
= (location_chain
) pool_alloc (loc_chain_pool
);
3269 node
->set_src
= NULL
;
3270 node
->init
= status
;
3271 node
->next
= *nodep
;
3275 /* Insert in DEST the intersection of the locations present in both
3276 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3277 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3281 intersect_loc_chains (rtx val
, location_chain
*dest
, struct dfset_merge
*dsm
,
3282 location_chain s1node
, variable s2var
)
3284 dataflow_set
*s1set
= dsm
->cur
;
3285 dataflow_set
*s2set
= dsm
->src
;
3286 location_chain found
;
3290 location_chain s2node
;
3292 gcc_checking_assert (s2var
->onepart
);
3294 if (s2var
->n_var_parts
)
3296 s2node
= s2var
->var_part
[0].loc_chain
;
3298 for (; s1node
&& s2node
;
3299 s1node
= s1node
->next
, s2node
= s2node
->next
)
3300 if (s1node
->loc
!= s2node
->loc
)
3302 else if (s1node
->loc
== val
)
3305 insert_into_intersection (dest
, s1node
->loc
,
3306 MIN (s1node
->init
, s2node
->init
));
3310 for (; s1node
; s1node
= s1node
->next
)
3312 if (s1node
->loc
== val
)
3315 if ((found
= find_loc_in_1pdv (s1node
->loc
, s2var
,
3316 shared_hash_htab (s2set
->vars
))))
3318 insert_into_intersection (dest
, s1node
->loc
,
3319 MIN (s1node
->init
, found
->init
));
3323 if (GET_CODE (s1node
->loc
) == VALUE
3324 && !VALUE_RECURSED_INTO (s1node
->loc
))
3326 decl_or_value dv
= dv_from_value (s1node
->loc
);
3327 variable svar
= shared_hash_find (s1set
->vars
, dv
);
3330 if (svar
->n_var_parts
== 1)
3332 VALUE_RECURSED_INTO (s1node
->loc
) = true;
3333 intersect_loc_chains (val
, dest
, dsm
,
3334 svar
->var_part
[0].loc_chain
,
3336 VALUE_RECURSED_INTO (s1node
->loc
) = false;
3341 /* ??? gotta look in cselib_val locations too. */
3343 /* ??? if the location is equivalent to any location in src,
3344 searched recursively
3346 add to dst the values needed to represent the equivalence
3348 telling whether locations S is equivalent to another dv's
3351 for each location D in the list
3353 if S and D satisfy rtx_equal_p, then it is present
3355 else if D is a value, recurse without cycles
3357 else if S and D have the same CODE and MODE
3359 for each operand oS and the corresponding oD
3361 if oS and oD are not equivalent, then S an D are not equivalent
3363 else if they are RTX vectors
3365 if any vector oS element is not equivalent to its respective oD,
3366 then S and D are not equivalent
3374 /* Return -1 if X should be before Y in a location list for a 1-part
3375 variable, 1 if Y should be before X, and 0 if they're equivalent
3376 and should not appear in the list. */
3379 loc_cmp (rtx x
, rtx y
)
3382 RTX_CODE code
= GET_CODE (x
);
3392 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3393 if (REGNO (x
) == REGNO (y
))
3395 else if (REGNO (x
) < REGNO (y
))
3408 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3409 return loc_cmp (XEXP (x
, 0), XEXP (y
, 0));
3415 if (GET_CODE (x
) == VALUE
)
3417 if (GET_CODE (y
) != VALUE
)
3419 /* Don't assert the modes are the same, that is true only
3420 when not recursing. (subreg:QI (value:SI 1:1) 0)
3421 and (subreg:QI (value:DI 2:2) 0) can be compared,
3422 even when the modes are different. */
3423 if (canon_value_cmp (x
, y
))
3429 if (GET_CODE (y
) == VALUE
)
3432 /* Entry value is the least preferable kind of expression. */
3433 if (GET_CODE (x
) == ENTRY_VALUE
)
3435 if (GET_CODE (y
) != ENTRY_VALUE
)
3437 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3438 return loc_cmp (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
3441 if (GET_CODE (y
) == ENTRY_VALUE
)
3444 if (GET_CODE (x
) == GET_CODE (y
))
3445 /* Compare operands below. */;
3446 else if (GET_CODE (x
) < GET_CODE (y
))
3451 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3453 if (GET_CODE (x
) == DEBUG_EXPR
)
3455 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3456 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)))
3458 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3459 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)));
3463 fmt
= GET_RTX_FORMAT (code
);
3464 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
3468 if (XWINT (x
, i
) == XWINT (y
, i
))
3470 else if (XWINT (x
, i
) < XWINT (y
, i
))
3477 if (XINT (x
, i
) == XINT (y
, i
))
3479 else if (XINT (x
, i
) < XINT (y
, i
))
3486 /* Compare the vector length first. */
3487 if (XVECLEN (x
, i
) == XVECLEN (y
, i
))
3488 /* Compare the vectors elements. */;
3489 else if (XVECLEN (x
, i
) < XVECLEN (y
, i
))
3494 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3495 if ((r
= loc_cmp (XVECEXP (x
, i
, j
),
3496 XVECEXP (y
, i
, j
))))
3501 if ((r
= loc_cmp (XEXP (x
, i
), XEXP (y
, i
))))
3507 if (XSTR (x
, i
) == XSTR (y
, i
))
3513 if ((r
= strcmp (XSTR (x
, i
), XSTR (y
, i
))) == 0)
3521 /* These are just backpointers, so they don't matter. */
3528 /* It is believed that rtx's at this level will never
3529 contain anything but integers and other rtx's,
3530 except for within LABEL_REFs and SYMBOL_REFs. */
3539 /* Check the order of entries in one-part variables. */
3542 canonicalize_loc_order_check (variable_def
**slot
,
3543 dataflow_set
*data ATTRIBUTE_UNUSED
)
3545 variable var
= *slot
;
3546 location_chain node
, next
;
3548 #ifdef ENABLE_RTL_CHECKING
3550 for (i
= 0; i
< var
->n_var_parts
; i
++)
3551 gcc_assert (var
->var_part
[0].cur_loc
== NULL
);
3552 gcc_assert (!var
->in_changed_variables
);
3558 gcc_assert (var
->n_var_parts
== 1);
3559 node
= var
->var_part
[0].loc_chain
;
3562 while ((next
= node
->next
))
3564 gcc_assert (loc_cmp (node
->loc
, next
->loc
) < 0);
3572 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3573 more likely to be chosen as canonical for an equivalence set.
3574 Ensure less likely values can reach more likely neighbors, making
3575 the connections bidirectional. */
3578 canonicalize_values_mark (variable_def
**slot
, dataflow_set
*set
)
3580 variable var
= *slot
;
3581 decl_or_value dv
= var
->dv
;
3583 location_chain node
;
3585 if (!dv_is_value_p (dv
))
3588 gcc_checking_assert (var
->n_var_parts
== 1);
3590 val
= dv_as_value (dv
);
3592 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3593 if (GET_CODE (node
->loc
) == VALUE
)
3595 if (canon_value_cmp (node
->loc
, val
))
3596 VALUE_RECURSED_INTO (val
) = true;
3599 decl_or_value odv
= dv_from_value (node
->loc
);
3600 variable_def
**oslot
;
3601 oslot
= shared_hash_find_slot_noinsert (set
->vars
, odv
);
3603 set_slot_part (set
, val
, oslot
, odv
, 0,
3604 node
->init
, NULL_RTX
);
3606 VALUE_RECURSED_INTO (node
->loc
) = true;
3613 /* Remove redundant entries from equivalence lists in onepart
3614 variables, canonicalizing equivalence sets into star shapes. */
3617 canonicalize_values_star (variable_def
**slot
, dataflow_set
*set
)
3619 variable var
= *slot
;
3620 decl_or_value dv
= var
->dv
;
3621 location_chain node
;
3624 variable_def
**cslot
;
3631 gcc_checking_assert (var
->n_var_parts
== 1);
3633 if (dv_is_value_p (dv
))
3635 cval
= dv_as_value (dv
);
3636 if (!VALUE_RECURSED_INTO (cval
))
3638 VALUE_RECURSED_INTO (cval
) = false;
3648 gcc_assert (var
->n_var_parts
== 1);
3650 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3651 if (GET_CODE (node
->loc
) == VALUE
)
3654 if (VALUE_RECURSED_INTO (node
->loc
))
3656 if (canon_value_cmp (node
->loc
, cval
))
3665 if (!has_marks
|| dv_is_decl_p (dv
))
3668 /* Keep it marked so that we revisit it, either after visiting a
3669 child node, or after visiting a new parent that might be
3671 VALUE_RECURSED_INTO (val
) = true;
3673 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3674 if (GET_CODE (node
->loc
) == VALUE
3675 && VALUE_RECURSED_INTO (node
->loc
))
3679 VALUE_RECURSED_INTO (cval
) = false;
3680 dv
= dv_from_value (cval
);
3681 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
3684 gcc_assert (dv_is_decl_p (var
->dv
));
3685 /* The canonical value was reset and dropped.
3687 clobber_variable_part (set
, NULL
, var
->dv
, 0, NULL
);
3691 gcc_assert (dv_is_value_p (var
->dv
));
3692 if (var
->n_var_parts
== 0)
3694 gcc_assert (var
->n_var_parts
== 1);
3698 VALUE_RECURSED_INTO (val
) = false;
3703 /* Push values to the canonical one. */
3704 cdv
= dv_from_value (cval
);
3705 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3707 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3708 if (node
->loc
!= cval
)
3710 cslot
= set_slot_part (set
, node
->loc
, cslot
, cdv
, 0,
3711 node
->init
, NULL_RTX
);
3712 if (GET_CODE (node
->loc
) == VALUE
)
3714 decl_or_value ndv
= dv_from_value (node
->loc
);
3716 set_variable_part (set
, cval
, ndv
, 0, node
->init
, NULL_RTX
,
3719 if (canon_value_cmp (node
->loc
, val
))
3721 /* If it could have been a local minimum, it's not any more,
3722 since it's now neighbor to cval, so it may have to push
3723 to it. Conversely, if it wouldn't have prevailed over
3724 val, then whatever mark it has is fine: if it was to
3725 push, it will now push to a more canonical node, but if
3726 it wasn't, then it has already pushed any values it might
3728 VALUE_RECURSED_INTO (node
->loc
) = true;
3729 /* Make sure we visit node->loc by ensuring we cval is
3731 VALUE_RECURSED_INTO (cval
) = true;
3733 else if (!VALUE_RECURSED_INTO (node
->loc
))
3734 /* If we have no need to "recurse" into this node, it's
3735 already "canonicalized", so drop the link to the old
3737 clobber_variable_part (set
, cval
, ndv
, 0, NULL
);
3739 else if (GET_CODE (node
->loc
) == REG
)
3741 attrs list
= set
->regs
[REGNO (node
->loc
)], *listp
;
3743 /* Change an existing attribute referring to dv so that it
3744 refers to cdv, removing any duplicate this might
3745 introduce, and checking that no previous duplicates
3746 existed, all in a single pass. */
3750 if (list
->offset
== 0
3751 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3752 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3759 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3762 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3767 if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3769 *listp
= list
->next
;
3770 pool_free (attrs_pool
, list
);
3775 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (dv
));
3778 else if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3780 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3785 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3787 *listp
= list
->next
;
3788 pool_free (attrs_pool
, list
);
3793 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (cdv
));
3802 if (list
->offset
== 0
3803 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3804 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3814 set_slot_part (set
, val
, cslot
, cdv
, 0,
3815 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
);
3817 slot
= clobber_slot_part (set
, cval
, slot
, 0, NULL
);
3819 /* Variable may have been unshared. */
3821 gcc_checking_assert (var
->n_var_parts
&& var
->var_part
[0].loc_chain
->loc
== cval
3822 && var
->var_part
[0].loc_chain
->next
== NULL
);
3824 if (VALUE_RECURSED_INTO (cval
))
3825 goto restart_with_cval
;
3830 /* Bind one-part variables to the canonical value in an equivalence
3831 set. Not doing this causes dataflow convergence failure in rare
3832 circumstances, see PR42873. Unfortunately we can't do this
3833 efficiently as part of canonicalize_values_star, since we may not
3834 have determined or even seen the canonical value of a set when we
3835 get to a variable that references another member of the set. */
3838 canonicalize_vars_star (variable_def
**slot
, dataflow_set
*set
)
3840 variable var
= *slot
;
3841 decl_or_value dv
= var
->dv
;
3842 location_chain node
;
3845 variable_def
**cslot
;
3847 location_chain cnode
;
3849 if (!var
->onepart
|| var
->onepart
== ONEPART_VALUE
)
3852 gcc_assert (var
->n_var_parts
== 1);
3854 node
= var
->var_part
[0].loc_chain
;
3856 if (GET_CODE (node
->loc
) != VALUE
)
3859 gcc_assert (!node
->next
);
3862 /* Push values to the canonical one. */
3863 cdv
= dv_from_value (cval
);
3864 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3868 gcc_assert (cvar
->n_var_parts
== 1);
3870 cnode
= cvar
->var_part
[0].loc_chain
;
3872 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3873 that are not “more canonical” than it. */
3874 if (GET_CODE (cnode
->loc
) != VALUE
3875 || !canon_value_cmp (cnode
->loc
, cval
))
3878 /* CVAL was found to be non-canonical. Change the variable to point
3879 to the canonical VALUE. */
3880 gcc_assert (!cnode
->next
);
3883 slot
= set_slot_part (set
, cval
, slot
, dv
, 0,
3884 node
->init
, node
->set_src
);
3885 clobber_slot_part (set
, cval
, slot
, 0, node
->set_src
);
3890 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3891 corresponding entry in DSM->src. Multi-part variables are combined
3892 with variable_union, whereas onepart dvs are combined with
3896 variable_merge_over_cur (variable s1var
, struct dfset_merge
*dsm
)
3898 dataflow_set
*dst
= dsm
->dst
;
3899 variable_def
**dstslot
;
3900 variable s2var
, dvar
= NULL
;
3901 decl_or_value dv
= s1var
->dv
;
3902 onepart_enum_t onepart
= s1var
->onepart
;
3905 location_chain node
, *nodep
;
3907 /* If the incoming onepart variable has an empty location list, then
3908 the intersection will be just as empty. For other variables,
3909 it's always union. */
3910 gcc_checking_assert (s1var
->n_var_parts
3911 && s1var
->var_part
[0].loc_chain
);
3914 return variable_union (s1var
, dst
);
3916 gcc_checking_assert (s1var
->n_var_parts
== 1);
3918 dvhash
= dv_htab_hash (dv
);
3919 if (dv_is_value_p (dv
))
3920 val
= dv_as_value (dv
);
3924 s2var
= shared_hash_find_1 (dsm
->src
->vars
, dv
, dvhash
);
3927 dst_can_be_shared
= false;
3931 dsm
->src_onepart_cnt
--;
3932 gcc_assert (s2var
->var_part
[0].loc_chain
3933 && s2var
->onepart
== onepart
3934 && s2var
->n_var_parts
== 1);
3936 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
3940 gcc_assert (dvar
->refcount
== 1
3941 && dvar
->onepart
== onepart
3942 && dvar
->n_var_parts
== 1);
3943 nodep
= &dvar
->var_part
[0].loc_chain
;
3951 if (!dstslot
&& !onepart_variable_different_p (s1var
, s2var
))
3953 dstslot
= shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
,
3955 *dstslot
= dvar
= s2var
;
3960 dst_can_be_shared
= false;
3962 intersect_loc_chains (val
, nodep
, dsm
,
3963 s1var
->var_part
[0].loc_chain
, s2var
);
3969 dvar
= (variable
) pool_alloc (onepart_pool (onepart
));
3972 dvar
->n_var_parts
= 1;
3973 dvar
->onepart
= onepart
;
3974 dvar
->in_changed_variables
= false;
3975 dvar
->var_part
[0].loc_chain
= node
;
3976 dvar
->var_part
[0].cur_loc
= NULL
;
3978 VAR_LOC_1PAUX (dvar
) = NULL
;
3980 VAR_PART_OFFSET (dvar
, 0) = 0;
3983 = shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
, dvhash
,
3985 gcc_assert (!*dstslot
);
3993 nodep
= &dvar
->var_part
[0].loc_chain
;
3994 while ((node
= *nodep
))
3996 location_chain
*nextp
= &node
->next
;
3998 if (GET_CODE (node
->loc
) == REG
)
4002 for (list
= dst
->regs
[REGNO (node
->loc
)]; list
; list
= list
->next
)
4003 if (GET_MODE (node
->loc
) == GET_MODE (list
->loc
)
4004 && dv_is_value_p (list
->dv
))
4008 attrs_list_insert (&dst
->regs
[REGNO (node
->loc
)],
4010 /* If this value became canonical for another value that had
4011 this register, we want to leave it alone. */
4012 else if (dv_as_value (list
->dv
) != val
)
4014 dstslot
= set_slot_part (dst
, dv_as_value (list
->dv
),
4016 node
->init
, NULL_RTX
);
4017 dstslot
= delete_slot_part (dst
, node
->loc
, dstslot
, 0);
4019 /* Since nextp points into the removed node, we can't
4020 use it. The pointer to the next node moved to nodep.
4021 However, if the variable we're walking is unshared
4022 during our walk, we'll keep walking the location list
4023 of the previously-shared variable, in which case the
4024 node won't have been removed, and we'll want to skip
4025 it. That's why we test *nodep here. */
4031 /* Canonicalization puts registers first, so we don't have to
4037 if (dvar
!= *dstslot
)
4039 nodep
= &dvar
->var_part
[0].loc_chain
;
4043 /* Mark all referenced nodes for canonicalization, and make sure
4044 we have mutual equivalence links. */
4045 VALUE_RECURSED_INTO (val
) = true;
4046 for (node
= *nodep
; node
; node
= node
->next
)
4047 if (GET_CODE (node
->loc
) == VALUE
)
4049 VALUE_RECURSED_INTO (node
->loc
) = true;
4050 set_variable_part (dst
, val
, dv_from_value (node
->loc
), 0,
4051 node
->init
, NULL
, INSERT
);
4054 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4055 gcc_assert (*dstslot
== dvar
);
4056 canonicalize_values_star (dstslot
, dst
);
4057 gcc_checking_assert (dstslot
4058 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4064 bool has_value
= false, has_other
= false;
4066 /* If we have one value and anything else, we're going to
4067 canonicalize this, so make sure all values have an entry in
4068 the table and are marked for canonicalization. */
4069 for (node
= *nodep
; node
; node
= node
->next
)
4071 if (GET_CODE (node
->loc
) == VALUE
)
4073 /* If this was marked during register canonicalization,
4074 we know we have to canonicalize values. */
4089 if (has_value
&& has_other
)
4091 for (node
= *nodep
; node
; node
= node
->next
)
4093 if (GET_CODE (node
->loc
) == VALUE
)
4095 decl_or_value dv
= dv_from_value (node
->loc
);
4096 variable_def
**slot
= NULL
;
4098 if (shared_hash_shared (dst
->vars
))
4099 slot
= shared_hash_find_slot_noinsert (dst
->vars
, dv
);
4101 slot
= shared_hash_find_slot_unshare (&dst
->vars
, dv
,
4105 variable var
= (variable
) pool_alloc (onepart_pool
4109 var
->n_var_parts
= 1;
4110 var
->onepart
= ONEPART_VALUE
;
4111 var
->in_changed_variables
= false;
4112 var
->var_part
[0].loc_chain
= NULL
;
4113 var
->var_part
[0].cur_loc
= NULL
;
4114 VAR_LOC_1PAUX (var
) = NULL
;
4118 VALUE_RECURSED_INTO (node
->loc
) = true;
4122 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4123 gcc_assert (*dstslot
== dvar
);
4124 canonicalize_values_star (dstslot
, dst
);
4125 gcc_checking_assert (dstslot
4126 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4132 if (!onepart_variable_different_p (dvar
, s2var
))
4134 variable_htab_free (dvar
);
4135 *dstslot
= dvar
= s2var
;
4138 else if (s2var
!= s1var
&& !onepart_variable_different_p (dvar
, s1var
))
4140 variable_htab_free (dvar
);
4141 *dstslot
= dvar
= s1var
;
4143 dst_can_be_shared
= false;
4146 dst_can_be_shared
= false;
4151 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4152 multi-part variable. Unions of multi-part variables and
4153 intersections of one-part ones will be handled in
4154 variable_merge_over_cur(). */
4157 variable_merge_over_src (variable s2var
, struct dfset_merge
*dsm
)
4159 dataflow_set
*dst
= dsm
->dst
;
4160 decl_or_value dv
= s2var
->dv
;
4162 if (!s2var
->onepart
)
4164 variable_def
**dstp
= shared_hash_find_slot (dst
->vars
, dv
);
4170 dsm
->src_onepart_cnt
++;
4174 /* Combine dataflow set information from SRC2 into DST, using PDST
4175 to carry over information across passes. */
4178 dataflow_set_merge (dataflow_set
*dst
, dataflow_set
*src2
)
4180 dataflow_set cur
= *dst
;
4181 dataflow_set
*src1
= &cur
;
4182 struct dfset_merge dsm
;
4184 size_t src1_elems
, src2_elems
;
4185 variable_iterator_type hi
;
4188 src1_elems
= shared_hash_htab (src1
->vars
).elements ();
4189 src2_elems
= shared_hash_htab (src2
->vars
).elements ();
4190 dataflow_set_init (dst
);
4191 dst
->stack_adjust
= cur
.stack_adjust
;
4192 shared_hash_destroy (dst
->vars
);
4193 dst
->vars
= (shared_hash
) pool_alloc (shared_hash_pool
);
4194 dst
->vars
->refcount
= 1;
4195 dst
->vars
->htab
.create (MAX (src1_elems
, src2_elems
));
4197 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4198 attrs_list_mpdv_union (&dst
->regs
[i
], src1
->regs
[i
], src2
->regs
[i
]);
4203 dsm
.src_onepart_cnt
= 0;
4205 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm
.src
->vars
),
4207 variable_merge_over_src (var
, &dsm
);
4208 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm
.cur
->vars
),
4210 variable_merge_over_cur (var
, &dsm
);
4212 if (dsm
.src_onepart_cnt
)
4213 dst_can_be_shared
= false;
4215 dataflow_set_destroy (src1
);
4218 /* Mark register equivalences. */
4221 dataflow_set_equiv_regs (dataflow_set
*set
)
4226 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4228 rtx canon
[NUM_MACHINE_MODES
];
4230 /* If the list is empty or one entry, no need to canonicalize
4232 if (set
->regs
[i
] == NULL
|| set
->regs
[i
]->next
== NULL
)
4235 memset (canon
, 0, sizeof (canon
));
4237 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4238 if (list
->offset
== 0 && dv_is_value_p (list
->dv
))
4240 rtx val
= dv_as_value (list
->dv
);
4241 rtx
*cvalp
= &canon
[(int)GET_MODE (val
)];
4244 if (canon_value_cmp (val
, cval
))
4248 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4249 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4251 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4256 if (dv_is_value_p (list
->dv
))
4258 rtx val
= dv_as_value (list
->dv
);
4263 VALUE_RECURSED_INTO (val
) = true;
4264 set_variable_part (set
, val
, dv_from_value (cval
), 0,
4265 VAR_INIT_STATUS_INITIALIZED
,
4269 VALUE_RECURSED_INTO (cval
) = true;
4270 set_variable_part (set
, cval
, list
->dv
, 0,
4271 VAR_INIT_STATUS_INITIALIZED
, NULL
, NO_INSERT
);
4274 for (listp
= &set
->regs
[i
]; (list
= *listp
);
4275 listp
= list
? &list
->next
: listp
)
4276 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4278 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4279 variable_def
**slot
;
4284 if (dv_is_value_p (list
->dv
))
4286 rtx val
= dv_as_value (list
->dv
);
4287 if (!VALUE_RECURSED_INTO (val
))
4291 slot
= shared_hash_find_slot_noinsert (set
->vars
, list
->dv
);
4292 canonicalize_values_star (slot
, set
);
4299 /* Remove any redundant values in the location list of VAR, which must
4300 be unshared and 1-part. */
4303 remove_duplicate_values (variable var
)
4305 location_chain node
, *nodep
;
4307 gcc_assert (var
->onepart
);
4308 gcc_assert (var
->n_var_parts
== 1);
4309 gcc_assert (var
->refcount
== 1);
4311 for (nodep
= &var
->var_part
[0].loc_chain
; (node
= *nodep
); )
4313 if (GET_CODE (node
->loc
) == VALUE
)
4315 if (VALUE_RECURSED_INTO (node
->loc
))
4317 /* Remove duplicate value node. */
4318 *nodep
= node
->next
;
4319 pool_free (loc_chain_pool
, node
);
4323 VALUE_RECURSED_INTO (node
->loc
) = true;
4325 nodep
= &node
->next
;
4328 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4329 if (GET_CODE (node
->loc
) == VALUE
)
4331 gcc_assert (VALUE_RECURSED_INTO (node
->loc
));
4332 VALUE_RECURSED_INTO (node
->loc
) = false;
4337 /* Hash table iteration argument passed to variable_post_merge. */
4338 struct dfset_post_merge
4340 /* The new input set for the current block. */
4342 /* Pointer to the permanent input set for the current block, or
4344 dataflow_set
**permp
;
4347 /* Create values for incoming expressions associated with one-part
4348 variables that don't have value numbers for them. */
4351 variable_post_merge_new_vals (variable_def
**slot
, dfset_post_merge
*dfpm
)
4353 dataflow_set
*set
= dfpm
->set
;
4354 variable var
= *slot
;
4355 location_chain node
;
4357 if (!var
->onepart
|| !var
->n_var_parts
)
4360 gcc_assert (var
->n_var_parts
== 1);
4362 if (dv_is_decl_p (var
->dv
))
4364 bool check_dupes
= false;
4367 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4369 if (GET_CODE (node
->loc
) == VALUE
)
4370 gcc_assert (!VALUE_RECURSED_INTO (node
->loc
));
4371 else if (GET_CODE (node
->loc
) == REG
)
4373 attrs att
, *attp
, *curp
= NULL
;
4375 if (var
->refcount
!= 1)
4377 slot
= unshare_variable (set
, slot
, var
,
4378 VAR_INIT_STATUS_INITIALIZED
);
4383 for (attp
= &set
->regs
[REGNO (node
->loc
)]; (att
= *attp
);
4385 if (att
->offset
== 0
4386 && GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4388 if (dv_is_value_p (att
->dv
))
4390 rtx cval
= dv_as_value (att
->dv
);
4395 else if (dv_as_opaque (att
->dv
) == dv_as_opaque (var
->dv
))
4403 if ((*curp
)->offset
== 0
4404 && GET_MODE ((*curp
)->loc
) == GET_MODE (node
->loc
)
4405 && dv_as_opaque ((*curp
)->dv
) == dv_as_opaque (var
->dv
))
4408 curp
= &(*curp
)->next
;
4419 *dfpm
->permp
= XNEW (dataflow_set
);
4420 dataflow_set_init (*dfpm
->permp
);
4423 for (att
= (*dfpm
->permp
)->regs
[REGNO (node
->loc
)];
4424 att
; att
= att
->next
)
4425 if (GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4427 gcc_assert (att
->offset
== 0
4428 && dv_is_value_p (att
->dv
));
4429 val_reset (set
, att
->dv
);
4436 cval
= dv_as_value (cdv
);
4440 /* Create a unique value to hold this register,
4441 that ought to be found and reused in
4442 subsequent rounds. */
4444 gcc_assert (!cselib_lookup (node
->loc
,
4445 GET_MODE (node
->loc
), 0,
4447 v
= cselib_lookup (node
->loc
, GET_MODE (node
->loc
), 1,
4449 cselib_preserve_value (v
);
4450 cselib_invalidate_rtx (node
->loc
);
4452 cdv
= dv_from_value (cval
);
4455 "Created new value %u:%u for reg %i\n",
4456 v
->uid
, v
->hash
, REGNO (node
->loc
));
4459 var_reg_decl_set (*dfpm
->permp
, node
->loc
,
4460 VAR_INIT_STATUS_INITIALIZED
,
4461 cdv
, 0, NULL
, INSERT
);
4467 /* Remove attribute referring to the decl, which now
4468 uses the value for the register, already existing or
4469 to be added when we bring perm in. */
4472 pool_free (attrs_pool
, att
);
4477 remove_duplicate_values (var
);
4483 /* Reset values in the permanent set that are not associated with the
4484 chosen expression. */
4487 variable_post_merge_perm_vals (variable_def
**pslot
, dfset_post_merge
*dfpm
)
4489 dataflow_set
*set
= dfpm
->set
;
4490 variable pvar
= *pslot
, var
;
4491 location_chain pnode
;
4495 gcc_assert (dv_is_value_p (pvar
->dv
)
4496 && pvar
->n_var_parts
== 1);
4497 pnode
= pvar
->var_part
[0].loc_chain
;
4500 && REG_P (pnode
->loc
));
4504 var
= shared_hash_find (set
->vars
, dv
);
4507 /* Although variable_post_merge_new_vals may have made decls
4508 non-star-canonical, values that pre-existed in canonical form
4509 remain canonical, and newly-created values reference a single
4510 REG, so they are canonical as well. Since VAR has the
4511 location list for a VALUE, using find_loc_in_1pdv for it is
4512 fine, since VALUEs don't map back to DECLs. */
4513 if (find_loc_in_1pdv (pnode
->loc
, var
, shared_hash_htab (set
->vars
)))
4515 val_reset (set
, dv
);
4518 for (att
= set
->regs
[REGNO (pnode
->loc
)]; att
; att
= att
->next
)
4519 if (att
->offset
== 0
4520 && GET_MODE (att
->loc
) == GET_MODE (pnode
->loc
)
4521 && dv_is_value_p (att
->dv
))
4524 /* If there is a value associated with this register already, create
4526 if (att
&& dv_as_value (att
->dv
) != dv_as_value (dv
))
4528 rtx cval
= dv_as_value (att
->dv
);
4529 set_variable_part (set
, cval
, dv
, 0, pnode
->init
, NULL
, INSERT
);
4530 set_variable_part (set
, dv_as_value (dv
), att
->dv
, 0, pnode
->init
,
4535 attrs_list_insert (&set
->regs
[REGNO (pnode
->loc
)],
4537 variable_union (pvar
, set
);
4543 /* Just checking stuff and registering register attributes for
4547 dataflow_post_merge_adjust (dataflow_set
*set
, dataflow_set
**permp
)
4549 struct dfset_post_merge dfpm
;
4554 shared_hash_htab (set
->vars
)
4555 .traverse
<dfset_post_merge
*, variable_post_merge_new_vals
> (&dfpm
);
4557 shared_hash_htab ((*permp
)->vars
)
4558 .traverse
<dfset_post_merge
*, variable_post_merge_perm_vals
> (&dfpm
);
4559 shared_hash_htab (set
->vars
)
4560 .traverse
<dataflow_set
*, canonicalize_values_star
> (set
);
4561 shared_hash_htab (set
->vars
)
4562 .traverse
<dataflow_set
*, canonicalize_vars_star
> (set
);
4565 /* Return a node whose loc is a MEM that refers to EXPR in the
4566 location list of a one-part variable or value VAR, or in that of
4567 any values recursively mentioned in the location lists. */
4569 static location_chain
4570 find_mem_expr_in_1pdv (tree expr
, rtx val
, variable_table_type vars
)
4572 location_chain node
;
4575 location_chain where
= NULL
;
4580 gcc_assert (GET_CODE (val
) == VALUE
4581 && !VALUE_RECURSED_INTO (val
));
4583 dv
= dv_from_value (val
);
4584 var
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
4589 gcc_assert (var
->onepart
);
4591 if (!var
->n_var_parts
)
4594 VALUE_RECURSED_INTO (val
) = true;
4596 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4597 if (MEM_P (node
->loc
)
4598 && MEM_EXPR (node
->loc
) == expr
4599 && INT_MEM_OFFSET (node
->loc
) == 0)
4604 else if (GET_CODE (node
->loc
) == VALUE
4605 && !VALUE_RECURSED_INTO (node
->loc
)
4606 && (where
= find_mem_expr_in_1pdv (expr
, node
->loc
, vars
)))
4609 VALUE_RECURSED_INTO (val
) = false;
4614 /* Return TRUE if the value of MEM may vary across a call. */
4617 mem_dies_at_call (rtx mem
)
4619 tree expr
= MEM_EXPR (mem
);
4625 decl
= get_base_address (expr
);
4633 return (may_be_aliased (decl
)
4634 || (!TREE_READONLY (decl
) && is_global_var (decl
)));
4637 /* Remove all MEMs from the location list of a hash table entry for a
4638 one-part variable, except those whose MEM attributes map back to
4639 the variable itself, directly or within a VALUE. */
4642 dataflow_set_preserve_mem_locs (variable_def
**slot
, dataflow_set
*set
)
4644 variable var
= *slot
;
4646 if (var
->onepart
== ONEPART_VDECL
|| var
->onepart
== ONEPART_DEXPR
)
4648 tree decl
= dv_as_decl (var
->dv
);
4649 location_chain loc
, *locp
;
4650 bool changed
= false;
4652 if (!var
->n_var_parts
)
4655 gcc_assert (var
->n_var_parts
== 1);
4657 if (shared_var_p (var
, set
->vars
))
4659 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4661 /* We want to remove dying MEMs that doesn't refer to DECL. */
4662 if (GET_CODE (loc
->loc
) == MEM
4663 && (MEM_EXPR (loc
->loc
) != decl
4664 || INT_MEM_OFFSET (loc
->loc
) != 0)
4665 && !mem_dies_at_call (loc
->loc
))
4667 /* We want to move here MEMs that do refer to DECL. */
4668 else if (GET_CODE (loc
->loc
) == VALUE
4669 && find_mem_expr_in_1pdv (decl
, loc
->loc
,
4670 shared_hash_htab (set
->vars
)))
4677 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4679 gcc_assert (var
->n_var_parts
== 1);
4682 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4685 rtx old_loc
= loc
->loc
;
4686 if (GET_CODE (old_loc
) == VALUE
)
4688 location_chain mem_node
4689 = find_mem_expr_in_1pdv (decl
, loc
->loc
,
4690 shared_hash_htab (set
->vars
));
4692 /* ??? This picks up only one out of multiple MEMs that
4693 refer to the same variable. Do we ever need to be
4694 concerned about dealing with more than one, or, given
4695 that they should all map to the same variable
4696 location, their addresses will have been merged and
4697 they will be regarded as equivalent? */
4700 loc
->loc
= mem_node
->loc
;
4701 loc
->set_src
= mem_node
->set_src
;
4702 loc
->init
= MIN (loc
->init
, mem_node
->init
);
4706 if (GET_CODE (loc
->loc
) != MEM
4707 || (MEM_EXPR (loc
->loc
) == decl
4708 && INT_MEM_OFFSET (loc
->loc
) == 0)
4709 || !mem_dies_at_call (loc
->loc
))
4711 if (old_loc
!= loc
->loc
&& emit_notes
)
4713 if (old_loc
== var
->var_part
[0].cur_loc
)
4716 var
->var_part
[0].cur_loc
= NULL
;
4725 if (old_loc
== var
->var_part
[0].cur_loc
)
4728 var
->var_part
[0].cur_loc
= NULL
;
4732 pool_free (loc_chain_pool
, loc
);
4735 if (!var
->var_part
[0].loc_chain
)
4741 variable_was_changed (var
, set
);
4747 /* Remove all MEMs from the location list of a hash table entry for a
4751 dataflow_set_remove_mem_locs (variable_def
**slot
, dataflow_set
*set
)
4753 variable var
= *slot
;
4755 if (var
->onepart
== ONEPART_VALUE
)
4757 location_chain loc
, *locp
;
4758 bool changed
= false;
4761 gcc_assert (var
->n_var_parts
== 1);
4763 if (shared_var_p (var
, set
->vars
))
4765 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4766 if (GET_CODE (loc
->loc
) == MEM
4767 && mem_dies_at_call (loc
->loc
))
4773 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4775 gcc_assert (var
->n_var_parts
== 1);
4778 if (VAR_LOC_1PAUX (var
))
4779 cur_loc
= VAR_LOC_FROM (var
);
4781 cur_loc
= var
->var_part
[0].cur_loc
;
4783 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4786 if (GET_CODE (loc
->loc
) != MEM
4787 || !mem_dies_at_call (loc
->loc
))
4794 /* If we have deleted the location which was last emitted
4795 we have to emit new location so add the variable to set
4796 of changed variables. */
4797 if (cur_loc
== loc
->loc
)
4800 var
->var_part
[0].cur_loc
= NULL
;
4801 if (VAR_LOC_1PAUX (var
))
4802 VAR_LOC_FROM (var
) = NULL
;
4804 pool_free (loc_chain_pool
, loc
);
4807 if (!var
->var_part
[0].loc_chain
)
4813 variable_was_changed (var
, set
);
4819 /* Remove all variable-location information about call-clobbered
4820 registers, as well as associations between MEMs and VALUEs. */
4823 dataflow_set_clear_at_call (dataflow_set
*set
)
4826 hard_reg_set_iterator hrsi
;
4828 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call
, 0, r
, hrsi
)
4829 var_regno_delete (set
, r
);
4831 if (MAY_HAVE_DEBUG_INSNS
)
4833 set
->traversed_vars
= set
->vars
;
4834 shared_hash_htab (set
->vars
)
4835 .traverse
<dataflow_set
*, dataflow_set_preserve_mem_locs
> (set
);
4836 set
->traversed_vars
= set
->vars
;
4837 shared_hash_htab (set
->vars
)
4838 .traverse
<dataflow_set
*, dataflow_set_remove_mem_locs
> (set
);
4839 set
->traversed_vars
= NULL
;
4844 variable_part_different_p (variable_part
*vp1
, variable_part
*vp2
)
4846 location_chain lc1
, lc2
;
4848 for (lc1
= vp1
->loc_chain
; lc1
; lc1
= lc1
->next
)
4850 for (lc2
= vp2
->loc_chain
; lc2
; lc2
= lc2
->next
)
4852 if (REG_P (lc1
->loc
) && REG_P (lc2
->loc
))
4854 if (REGNO (lc1
->loc
) == REGNO (lc2
->loc
))
4857 if (rtx_equal_p (lc1
->loc
, lc2
->loc
))
4866 /* Return true if one-part variables VAR1 and VAR2 are different.
4867 They must be in canonical order. */
4870 onepart_variable_different_p (variable var1
, variable var2
)
4872 location_chain lc1
, lc2
;
4877 gcc_assert (var1
->n_var_parts
== 1
4878 && var2
->n_var_parts
== 1);
4880 lc1
= var1
->var_part
[0].loc_chain
;
4881 lc2
= var2
->var_part
[0].loc_chain
;
4883 gcc_assert (lc1
&& lc2
);
4887 if (loc_cmp (lc1
->loc
, lc2
->loc
))
4896 /* Return true if variables VAR1 and VAR2 are different. */
4899 variable_different_p (variable var1
, variable var2
)
4906 if (var1
->onepart
!= var2
->onepart
)
4909 if (var1
->n_var_parts
!= var2
->n_var_parts
)
4912 if (var1
->onepart
&& var1
->n_var_parts
)
4914 gcc_checking_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
)
4915 && var1
->n_var_parts
== 1);
4916 /* One-part values have locations in a canonical order. */
4917 return onepart_variable_different_p (var1
, var2
);
4920 for (i
= 0; i
< var1
->n_var_parts
; i
++)
4922 if (VAR_PART_OFFSET (var1
, i
) != VAR_PART_OFFSET (var2
, i
))
4924 if (variable_part_different_p (&var1
->var_part
[i
], &var2
->var_part
[i
]))
4926 if (variable_part_different_p (&var2
->var_part
[i
], &var1
->var_part
[i
]))
4932 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
4935 dataflow_set_different (dataflow_set
*old_set
, dataflow_set
*new_set
)
4937 variable_iterator_type hi
;
4940 if (old_set
->vars
== new_set
->vars
)
4943 if (shared_hash_htab (old_set
->vars
).elements ()
4944 != shared_hash_htab (new_set
->vars
).elements ())
4947 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (old_set
->vars
),
4950 variable_table_type htab
= shared_hash_htab (new_set
->vars
);
4951 variable var2
= htab
.find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
4954 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4956 fprintf (dump_file
, "dataflow difference found: removal of:\n");
4962 if (variable_different_p (var1
, var2
))
4964 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4966 fprintf (dump_file
, "dataflow difference found: "
4967 "old and new follow:\n");
4975 /* No need to traverse the second hashtab, if both have the same number
4976 of elements and the second one had all entries found in the first one,
4977 then it can't have any extra entries. */
4981 /* Free the contents of dataflow set SET. */
4984 dataflow_set_destroy (dataflow_set
*set
)
4988 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4989 attrs_list_clear (&set
->regs
[i
]);
4991 shared_hash_destroy (set
->vars
);
4995 /* Return true if RTL X contains a SYMBOL_REF. */
4998 contains_symbol_ref (rtx x
)
5007 code
= GET_CODE (x
);
5008 if (code
== SYMBOL_REF
)
5011 fmt
= GET_RTX_FORMAT (code
);
5012 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
5016 if (contains_symbol_ref (XEXP (x
, i
)))
5019 else if (fmt
[i
] == 'E')
5022 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
5023 if (contains_symbol_ref (XVECEXP (x
, i
, j
)))
5031 /* Shall EXPR be tracked? */
5034 track_expr_p (tree expr
, bool need_rtl
)
5039 if (TREE_CODE (expr
) == DEBUG_EXPR_DECL
)
5040 return DECL_RTL_SET_P (expr
);
5042 /* If EXPR is not a parameter or a variable do not track it. */
5043 if (TREE_CODE (expr
) != VAR_DECL
&& TREE_CODE (expr
) != PARM_DECL
)
5046 /* It also must have a name... */
5047 if (!DECL_NAME (expr
) && need_rtl
)
5050 /* ... and a RTL assigned to it. */
5051 decl_rtl
= DECL_RTL_IF_SET (expr
);
5052 if (!decl_rtl
&& need_rtl
)
5055 /* If this expression is really a debug alias of some other declaration, we
5056 don't need to track this expression if the ultimate declaration is
5059 if (TREE_CODE (realdecl
) == VAR_DECL
&& DECL_HAS_DEBUG_EXPR_P (realdecl
))
5061 realdecl
= DECL_DEBUG_EXPR (realdecl
);
5062 if (!DECL_P (realdecl
))
5064 if (handled_component_p (realdecl
)
5065 || (TREE_CODE (realdecl
) == MEM_REF
5066 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5068 HOST_WIDE_INT bitsize
, bitpos
, maxsize
;
5070 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
,
5072 if (!DECL_P (innerdecl
)
5073 || DECL_IGNORED_P (innerdecl
)
5074 /* Do not track declarations for parts of tracked parameters
5075 since we want to track them as a whole instead. */
5076 || (TREE_CODE (innerdecl
) == PARM_DECL
5077 && DECL_MODE (innerdecl
) != BLKmode
5078 && TREE_CODE (TREE_TYPE (innerdecl
)) != UNION_TYPE
)
5079 || TREE_STATIC (innerdecl
)
5081 || bitpos
+ bitsize
> 256
5082 || bitsize
!= maxsize
)
5092 /* Do not track EXPR if REALDECL it should be ignored for debugging
5094 if (DECL_IGNORED_P (realdecl
))
5097 /* Do not track global variables until we are able to emit correct location
5099 if (TREE_STATIC (realdecl
))
5102 /* When the EXPR is a DECL for alias of some variable (see example)
5103 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5104 DECL_RTL contains SYMBOL_REF.
5107 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5110 if (decl_rtl
&& MEM_P (decl_rtl
)
5111 && contains_symbol_ref (XEXP (decl_rtl
, 0)))
5114 /* If RTX is a memory it should not be very large (because it would be
5115 an array or struct). */
5116 if (decl_rtl
&& MEM_P (decl_rtl
))
5118 /* Do not track structures and arrays. */
5119 if (GET_MODE (decl_rtl
) == BLKmode
5120 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl
)))
5122 if (MEM_SIZE_KNOWN_P (decl_rtl
)
5123 && MEM_SIZE (decl_rtl
) > MAX_VAR_PARTS
)
5127 DECL_CHANGED (expr
) = 0;
5128 DECL_CHANGED (realdecl
) = 0;
5132 /* Determine whether a given LOC refers to the same variable part as
5136 same_variable_part_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
)
5139 HOST_WIDE_INT offset2
;
5141 if (! DECL_P (expr
))
5146 expr2
= REG_EXPR (loc
);
5147 offset2
= REG_OFFSET (loc
);
5149 else if (MEM_P (loc
))
5151 expr2
= MEM_EXPR (loc
);
5152 offset2
= INT_MEM_OFFSET (loc
);
5157 if (! expr2
|| ! DECL_P (expr2
))
5160 expr
= var_debug_decl (expr
);
5161 expr2
= var_debug_decl (expr2
);
5163 return (expr
== expr2
&& offset
== offset2
);
5166 /* LOC is a REG or MEM that we would like to track if possible.
5167 If EXPR is null, we don't know what expression LOC refers to,
5168 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5169 LOC is an lvalue register.
5171 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5172 is something we can track. When returning true, store the mode of
5173 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5174 from EXPR in *OFFSET_OUT (if nonnull). */
5177 track_loc_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
, bool store_reg_p
,
5178 enum machine_mode
*mode_out
, HOST_WIDE_INT
*offset_out
)
5180 enum machine_mode mode
;
5182 if (expr
== NULL
|| !track_expr_p (expr
, true))
5185 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5186 whole subreg, but only the old inner part is really relevant. */
5187 mode
= GET_MODE (loc
);
5188 if (REG_P (loc
) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc
)))
5190 enum machine_mode pseudo_mode
;
5192 pseudo_mode
= PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc
));
5193 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (pseudo_mode
))
5195 offset
+= byte_lowpart_offset (pseudo_mode
, mode
);
5200 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5201 Do the same if we are storing to a register and EXPR occupies
5202 the whole of register LOC; in that case, the whole of EXPR is
5203 being changed. We exclude complex modes from the second case
5204 because the real and imaginary parts are represented as separate
5205 pseudo registers, even if the whole complex value fits into one
5207 if ((GET_MODE_SIZE (mode
) > GET_MODE_SIZE (DECL_MODE (expr
))
5209 && !COMPLEX_MODE_P (DECL_MODE (expr
))
5210 && hard_regno_nregs
[REGNO (loc
)][DECL_MODE (expr
)] == 1))
5211 && offset
+ byte_lowpart_offset (DECL_MODE (expr
), mode
) == 0)
5213 mode
= DECL_MODE (expr
);
5217 if (offset
< 0 || offset
>= MAX_VAR_PARTS
)
5223 *offset_out
= offset
;
5227 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5228 want to track. When returning nonnull, make sure that the attributes
5229 on the returned value are updated. */
5232 var_lowpart (enum machine_mode mode
, rtx loc
)
5234 unsigned int offset
, reg_offset
, regno
;
5236 if (GET_MODE (loc
) == mode
)
5239 if (!REG_P (loc
) && !MEM_P (loc
))
5242 offset
= byte_lowpart_offset (mode
, GET_MODE (loc
));
5245 return adjust_address_nv (loc
, mode
, offset
);
5247 reg_offset
= subreg_lowpart_offset (mode
, GET_MODE (loc
));
5248 regno
= REGNO (loc
) + subreg_regno_offset (REGNO (loc
), GET_MODE (loc
),
5250 return gen_rtx_REG_offset (loc
, mode
, regno
, offset
);
5253 /* Carry information about uses and stores while walking rtx. */
5255 struct count_use_info
5257 /* The insn where the RTX is. */
5260 /* The basic block where insn is. */
5263 /* The array of n_sets sets in the insn, as determined by cselib. */
5264 struct cselib_set
*sets
;
5267 /* True if we're counting stores, false otherwise. */
5271 /* Find a VALUE corresponding to X. */
5273 static inline cselib_val
*
5274 find_use_val (rtx x
, enum machine_mode mode
, struct count_use_info
*cui
)
5280 /* This is called after uses are set up and before stores are
5281 processed by cselib, so it's safe to look up srcs, but not
5282 dsts. So we look up expressions that appear in srcs or in
5283 dest expressions, but we search the sets array for dests of
5287 /* Some targets represent memset and memcpy patterns
5288 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5289 (set (mem:BLK ...) (const_int ...)) or
5290 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5291 in that case, otherwise we end up with mode mismatches. */
5292 if (mode
== BLKmode
&& MEM_P (x
))
5294 for (i
= 0; i
< cui
->n_sets
; i
++)
5295 if (cui
->sets
[i
].dest
== x
)
5296 return cui
->sets
[i
].src_elt
;
5299 return cselib_lookup (x
, mode
, 0, VOIDmode
);
5305 /* Replace all registers and addresses in an expression with VALUE
5306 expressions that map back to them, unless the expression is a
5307 register. If no mapping is or can be performed, returns NULL. */
5310 replace_expr_with_values (rtx loc
)
5312 if (REG_P (loc
) || GET_CODE (loc
) == ENTRY_VALUE
)
5314 else if (MEM_P (loc
))
5316 cselib_val
*addr
= cselib_lookup (XEXP (loc
, 0),
5317 get_address_mode (loc
), 0,
5320 return replace_equiv_address_nv (loc
, addr
->val_rtx
);
5325 return cselib_subst_to_values (loc
, VOIDmode
);
5328 /* Return true if *X is a DEBUG_EXPR. Usable as an argument to
5329 for_each_rtx to tell whether there are any DEBUG_EXPRs within
5333 rtx_debug_expr_p (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
5337 return GET_CODE (loc
) == DEBUG_EXPR
;
5340 /* Determine what kind of micro operation to choose for a USE. Return
5341 MO_CLOBBER if no micro operation is to be generated. */
5343 static enum micro_operation_type
5344 use_type (rtx loc
, struct count_use_info
*cui
, enum machine_mode
*modep
)
5348 if (cui
&& cui
->sets
)
5350 if (GET_CODE (loc
) == VAR_LOCATION
)
5352 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc
), false))
5354 rtx ploc
= PAT_VAR_LOCATION_LOC (loc
);
5355 if (! VAR_LOC_UNKNOWN_P (ploc
))
5357 cselib_val
*val
= cselib_lookup (ploc
, GET_MODE (loc
), 1,
5360 /* ??? flag_float_store and volatile mems are never
5361 given values, but we could in theory use them for
5363 gcc_assert (val
|| 1);
5371 if (REG_P (loc
) || MEM_P (loc
))
5374 *modep
= GET_MODE (loc
);
5378 || (find_use_val (loc
, GET_MODE (loc
), cui
)
5379 && cselib_lookup (XEXP (loc
, 0),
5380 get_address_mode (loc
), 0,
5386 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5388 if (val
&& !cselib_preserved_value_p (val
))
5396 gcc_assert (REGNO (loc
) < FIRST_PSEUDO_REGISTER
);
5398 if (loc
== cfa_base_rtx
)
5400 expr
= REG_EXPR (loc
);
5403 return MO_USE_NO_VAR
;
5404 else if (target_for_debug_bind (var_debug_decl (expr
)))
5406 else if (track_loc_p (loc
, expr
, REG_OFFSET (loc
),
5407 false, modep
, NULL
))
5410 return MO_USE_NO_VAR
;
5412 else if (MEM_P (loc
))
5414 expr
= MEM_EXPR (loc
);
5418 else if (target_for_debug_bind (var_debug_decl (expr
)))
5420 else if (track_loc_p (loc
, expr
, INT_MEM_OFFSET (loc
),
5422 /* Multi-part variables shouldn't refer to one-part
5423 variable names such as VALUEs (never happens) or
5424 DEBUG_EXPRs (only happens in the presence of debug
5426 && (!MAY_HAVE_DEBUG_INSNS
5427 || !for_each_rtx (&XEXP (loc
, 0), rtx_debug_expr_p
, NULL
)))
5436 /* Log to OUT information about micro-operation MOPT involving X in
5440 log_op_type (rtx x
, basic_block bb
, rtx insn
,
5441 enum micro_operation_type mopt
, FILE *out
)
5443 fprintf (out
, "bb %i op %i insn %i %s ",
5444 bb
->index
, VTI (bb
)->mos
.length (),
5445 INSN_UID (insn
), micro_operation_type_name
[mopt
]);
5446 print_inline_rtx (out
, x
, 2);
5450 /* Tell whether the CONCAT used to holds a VALUE and its location
5451 needs value resolution, i.e., an attempt of mapping the location
5452 back to other incoming values. */
5453 #define VAL_NEEDS_RESOLUTION(x) \
5454 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5455 /* Whether the location in the CONCAT is a tracked expression, that
5456 should also be handled like a MO_USE. */
5457 #define VAL_HOLDS_TRACK_EXPR(x) \
5458 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5459 /* Whether the location in the CONCAT should be handled like a MO_COPY
5461 #define VAL_EXPR_IS_COPIED(x) \
5462 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5463 /* Whether the location in the CONCAT should be handled like a
5464 MO_CLOBBER as well. */
5465 #define VAL_EXPR_IS_CLOBBERED(x) \
5466 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5468 /* All preserved VALUEs. */
5469 static vec
<rtx
> preserved_values
;
5471 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5474 preserve_value (cselib_val
*val
)
5476 cselib_preserve_value (val
);
5477 preserved_values
.safe_push (val
->val_rtx
);
5480 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5481 any rtxes not suitable for CONST use not replaced by VALUEs
5485 non_suitable_const (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
5490 switch (GET_CODE (*x
))
5501 return !MEM_READONLY_P (*x
);
5507 /* Add uses (register and memory references) LOC which will be tracked
5508 to VTI (bb)->mos. INSN is instruction which the LOC is part of. */
5511 add_uses (rtx
*ploc
, void *data
)
5514 enum machine_mode mode
= VOIDmode
;
5515 struct count_use_info
*cui
= (struct count_use_info
*)data
;
5516 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5518 if (type
!= MO_CLOBBER
)
5520 basic_block bb
= cui
->bb
;
5524 mo
.u
.loc
= type
== MO_USE
? var_lowpart (mode
, loc
) : loc
;
5525 mo
.insn
= cui
->insn
;
5527 if (type
== MO_VAL_LOC
)
5530 rtx vloc
= PAT_VAR_LOCATION_LOC (oloc
);
5533 gcc_assert (cui
->sets
);
5536 && !REG_P (XEXP (vloc
, 0))
5537 && !MEM_P (XEXP (vloc
, 0)))
5540 enum machine_mode address_mode
= get_address_mode (mloc
);
5542 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5545 if (val
&& !cselib_preserved_value_p (val
))
5546 preserve_value (val
);
5549 if (CONSTANT_P (vloc
)
5550 && (GET_CODE (vloc
) != CONST
5551 || for_each_rtx (&vloc
, non_suitable_const
, NULL
)))
5552 /* For constants don't look up any value. */;
5553 else if (!VAR_LOC_UNKNOWN_P (vloc
) && !unsuitable_loc (vloc
)
5554 && (val
= find_use_val (vloc
, GET_MODE (oloc
), cui
)))
5556 enum machine_mode mode2
;
5557 enum micro_operation_type type2
;
5559 bool resolvable
= REG_P (vloc
) || MEM_P (vloc
);
5562 nloc
= replace_expr_with_values (vloc
);
5566 oloc
= shallow_copy_rtx (oloc
);
5567 PAT_VAR_LOCATION_LOC (oloc
) = nloc
;
5570 oloc
= gen_rtx_CONCAT (mode
, val
->val_rtx
, oloc
);
5572 type2
= use_type (vloc
, 0, &mode2
);
5574 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5575 || type2
== MO_CLOBBER
);
5577 if (type2
== MO_CLOBBER
5578 && !cselib_preserved_value_p (val
))
5580 VAL_NEEDS_RESOLUTION (oloc
) = resolvable
;
5581 preserve_value (val
);
5584 else if (!VAR_LOC_UNKNOWN_P (vloc
))
5586 oloc
= shallow_copy_rtx (oloc
);
5587 PAT_VAR_LOCATION_LOC (oloc
) = gen_rtx_UNKNOWN_VAR_LOC ();
5592 else if (type
== MO_VAL_USE
)
5594 enum machine_mode mode2
= VOIDmode
;
5595 enum micro_operation_type type2
;
5596 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5597 rtx vloc
, oloc
= loc
, nloc
;
5599 gcc_assert (cui
->sets
);
5602 && !REG_P (XEXP (oloc
, 0))
5603 && !MEM_P (XEXP (oloc
, 0)))
5606 enum machine_mode address_mode
= get_address_mode (mloc
);
5608 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5611 if (val
&& !cselib_preserved_value_p (val
))
5612 preserve_value (val
);
5615 type2
= use_type (loc
, 0, &mode2
);
5617 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5618 || type2
== MO_CLOBBER
);
5620 if (type2
== MO_USE
)
5621 vloc
= var_lowpart (mode2
, loc
);
5625 /* The loc of a MO_VAL_USE may have two forms:
5627 (concat val src): val is at src, a value-based
5630 (concat (concat val use) src): same as above, with use as
5631 the MO_USE tracked value, if it differs from src.
5635 gcc_checking_assert (REG_P (loc
) || MEM_P (loc
));
5636 nloc
= replace_expr_with_values (loc
);
5641 oloc
= gen_rtx_CONCAT (mode2
, val
->val_rtx
, vloc
);
5643 oloc
= val
->val_rtx
;
5645 mo
.u
.loc
= gen_rtx_CONCAT (mode
, oloc
, nloc
);
5647 if (type2
== MO_USE
)
5648 VAL_HOLDS_TRACK_EXPR (mo
.u
.loc
) = 1;
5649 if (!cselib_preserved_value_p (val
))
5651 VAL_NEEDS_RESOLUTION (mo
.u
.loc
) = 1;
5652 preserve_value (val
);
5656 gcc_assert (type
== MO_USE
|| type
== MO_USE_NO_VAR
);
5658 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5659 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
5660 VTI (bb
)->mos
.safe_push (mo
);
5666 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5669 add_uses_1 (rtx
*x
, void *cui
)
5671 for_each_rtx (x
, add_uses
, cui
);
5674 /* This is the value used during expansion of locations. We want it
5675 to be unbounded, so that variables expanded deep in a recursion
5676 nest are fully evaluated, so that their values are cached
5677 correctly. We avoid recursion cycles through other means, and we
5678 don't unshare RTL, so excess complexity is not a problem. */
5679 #define EXPR_DEPTH (INT_MAX)
5680 /* We use this to keep too-complex expressions from being emitted as
5681 location notes, and then to debug information. Users can trade
5682 compile time for ridiculously complex expressions, although they're
5683 seldom useful, and they may often have to be discarded as not
5684 representable anyway. */
5685 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5687 /* Attempt to reverse the EXPR operation in the debug info and record
5688 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5689 no longer live we can express its value as VAL - 6. */
5692 reverse_op (rtx val
, const_rtx expr
, rtx insn
)
5696 struct elt_loc_list
*l
;
5700 if (GET_CODE (expr
) != SET
)
5703 if (!REG_P (SET_DEST (expr
)) || GET_MODE (val
) != GET_MODE (SET_DEST (expr
)))
5706 src
= SET_SRC (expr
);
5707 switch (GET_CODE (src
))
5714 if (!REG_P (XEXP (src
, 0)))
5719 if (!REG_P (XEXP (src
, 0)) && !MEM_P (XEXP (src
, 0)))
5726 if (!SCALAR_INT_MODE_P (GET_MODE (src
)) || XEXP (src
, 0) == cfa_base_rtx
)
5729 v
= cselib_lookup (XEXP (src
, 0), GET_MODE (XEXP (src
, 0)), 0, VOIDmode
);
5730 if (!v
|| !cselib_preserved_value_p (v
))
5733 /* Use canonical V to avoid creating multiple redundant expressions
5734 for different VALUES equivalent to V. */
5735 v
= canonical_cselib_val (v
);
5737 /* Adding a reverse op isn't useful if V already has an always valid
5738 location. Ignore ENTRY_VALUE, while it is always constant, we should
5739 prefer non-ENTRY_VALUE locations whenever possible. */
5740 for (l
= v
->locs
, count
= 0; l
; l
= l
->next
, count
++)
5741 if (CONSTANT_P (l
->loc
)
5742 && (GET_CODE (l
->loc
) != CONST
|| !references_value_p (l
->loc
, 0)))
5744 /* Avoid creating too large locs lists. */
5745 else if (count
== PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE
))
5748 switch (GET_CODE (src
))
5752 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5754 ret
= gen_rtx_fmt_e (GET_CODE (src
), GET_MODE (val
), val
);
5758 ret
= gen_lowpart_SUBREG (GET_MODE (v
->val_rtx
), val
);
5770 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5772 arg
= XEXP (src
, 1);
5773 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5775 arg
= cselib_expand_value_rtx (arg
, scratch_regs
, 5);
5776 if (arg
== NULL_RTX
)
5778 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5781 ret
= simplify_gen_binary (code
, GET_MODE (val
), val
, arg
);
5783 /* Ensure ret isn't VALUE itself (which can happen e.g. for
5784 (plus (reg1) (reg2)) when reg2 is known to be 0), as that
5785 breaks a lot of routines during var-tracking. */
5786 ret
= gen_rtx_fmt_ee (PLUS
, GET_MODE (val
), val
, const0_rtx
);
5792 cselib_add_permanent_equiv (v
, ret
, insn
);
5795 /* Add stores (register and memory references) LOC which will be tracked
5796 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5797 CUIP->insn is instruction which the LOC is part of. */
5800 add_stores (rtx loc
, const_rtx expr
, void *cuip
)
5802 enum machine_mode mode
= VOIDmode
, mode2
;
5803 struct count_use_info
*cui
= (struct count_use_info
*)cuip
;
5804 basic_block bb
= cui
->bb
;
5806 rtx oloc
= loc
, nloc
, src
= NULL
;
5807 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5808 bool track_p
= false;
5810 bool resolve
, preserve
;
5812 if (type
== MO_CLOBBER
)
5819 gcc_assert (loc
!= cfa_base_rtx
);
5820 if ((GET_CODE (expr
) == CLOBBER
&& type
!= MO_VAL_SET
)
5821 || !(track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5822 || GET_CODE (expr
) == CLOBBER
)
5824 mo
.type
= MO_CLOBBER
;
5826 if (GET_CODE (expr
) == SET
5827 && SET_DEST (expr
) == loc
5828 && !unsuitable_loc (SET_SRC (expr
))
5829 && find_use_val (loc
, mode
, cui
))
5831 gcc_checking_assert (type
== MO_VAL_SET
);
5832 mo
.u
.loc
= gen_rtx_SET (VOIDmode
, loc
, SET_SRC (expr
));
5837 if (GET_CODE (expr
) == SET
5838 && SET_DEST (expr
) == loc
5839 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5840 src
= var_lowpart (mode2
, SET_SRC (expr
));
5841 loc
= var_lowpart (mode2
, loc
);
5850 rtx xexpr
= gen_rtx_SET (VOIDmode
, loc
, src
);
5851 if (same_variable_part_p (src
, REG_EXPR (loc
), REG_OFFSET (loc
)))
5853 /* If this is an instruction copying (part of) a parameter
5854 passed by invisible reference to its register location,
5855 pretend it's a SET so that the initial memory location
5856 is discarded, as the parameter register can be reused
5857 for other purposes and we do not track locations based
5858 on generic registers. */
5861 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5862 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5863 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5864 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0)
5875 mo
.insn
= cui
->insn
;
5877 else if (MEM_P (loc
)
5878 && ((track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5881 if (MEM_P (loc
) && type
== MO_VAL_SET
5882 && !REG_P (XEXP (loc
, 0))
5883 && !MEM_P (XEXP (loc
, 0)))
5886 enum machine_mode address_mode
= get_address_mode (mloc
);
5887 cselib_val
*val
= cselib_lookup (XEXP (mloc
, 0),
5891 if (val
&& !cselib_preserved_value_p (val
))
5892 preserve_value (val
);
5895 if (GET_CODE (expr
) == CLOBBER
|| !track_p
)
5897 mo
.type
= MO_CLOBBER
;
5898 mo
.u
.loc
= track_p
? var_lowpart (mode2
, loc
) : loc
;
5902 if (GET_CODE (expr
) == SET
5903 && SET_DEST (expr
) == loc
5904 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5905 src
= var_lowpart (mode2
, SET_SRC (expr
));
5906 loc
= var_lowpart (mode2
, loc
);
5915 rtx xexpr
= gen_rtx_SET (VOIDmode
, loc
, src
);
5916 if (same_variable_part_p (SET_SRC (xexpr
),
5918 INT_MEM_OFFSET (loc
)))
5925 mo
.insn
= cui
->insn
;
5930 if (type
!= MO_VAL_SET
)
5931 goto log_and_return
;
5933 v
= find_use_val (oloc
, mode
, cui
);
5936 goto log_and_return
;
5938 resolve
= preserve
= !cselib_preserved_value_p (v
);
5940 /* We cannot track values for multiple-part variables, so we track only
5941 locations for tracked parameters passed either by invisible reference
5942 or directly in multiple locations. */
5946 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5947 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5948 && TREE_CODE (TREE_TYPE (REG_EXPR (loc
))) != UNION_TYPE
5949 && ((MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5950 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) != arg_pointer_rtx
)
5951 || (GET_CODE (DECL_INCOMING_RTL (REG_EXPR (loc
))) == PARALLEL
5952 && XVECLEN (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) > 1)))
5954 /* Although we don't use the value here, it could be used later by the
5955 mere virtue of its existence as the operand of the reverse operation
5956 that gave rise to it (typically extension/truncation). Make sure it
5957 is preserved as required by vt_expand_var_loc_chain. */
5960 goto log_and_return
;
5963 if (loc
== stack_pointer_rtx
5964 && hard_frame_pointer_adjustment
!= -1
5966 cselib_set_value_sp_based (v
);
5968 nloc
= replace_expr_with_values (oloc
);
5972 if (GET_CODE (PATTERN (cui
->insn
)) == COND_EXEC
)
5974 cselib_val
*oval
= cselib_lookup (oloc
, GET_MODE (oloc
), 0, VOIDmode
);
5976 gcc_assert (oval
!= v
);
5977 gcc_assert (REG_P (oloc
) || MEM_P (oloc
));
5979 if (oval
&& !cselib_preserved_value_p (oval
))
5981 micro_operation moa
;
5983 preserve_value (oval
);
5985 moa
.type
= MO_VAL_USE
;
5986 moa
.u
.loc
= gen_rtx_CONCAT (mode
, oval
->val_rtx
, oloc
);
5987 VAL_NEEDS_RESOLUTION (moa
.u
.loc
) = 1;
5988 moa
.insn
= cui
->insn
;
5990 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5991 log_op_type (moa
.u
.loc
, cui
->bb
, cui
->insn
,
5992 moa
.type
, dump_file
);
5993 VTI (bb
)->mos
.safe_push (moa
);
5998 else if (resolve
&& GET_CODE (mo
.u
.loc
) == SET
)
6000 if (REG_P (SET_SRC (expr
)) || MEM_P (SET_SRC (expr
)))
6001 nloc
= replace_expr_with_values (SET_SRC (expr
));
6005 /* Avoid the mode mismatch between oexpr and expr. */
6006 if (!nloc
&& mode
!= mode2
)
6008 nloc
= SET_SRC (expr
);
6009 gcc_assert (oloc
== SET_DEST (expr
));
6012 if (nloc
&& nloc
!= SET_SRC (mo
.u
.loc
))
6013 oloc
= gen_rtx_SET (GET_MODE (mo
.u
.loc
), oloc
, nloc
);
6016 if (oloc
== SET_DEST (mo
.u
.loc
))
6017 /* No point in duplicating. */
6019 if (!REG_P (SET_SRC (mo
.u
.loc
)))
6025 if (GET_CODE (mo
.u
.loc
) == SET
6026 && oloc
== SET_DEST (mo
.u
.loc
))
6027 /* No point in duplicating. */
6033 loc
= gen_rtx_CONCAT (mode
, v
->val_rtx
, oloc
);
6035 if (mo
.u
.loc
!= oloc
)
6036 loc
= gen_rtx_CONCAT (GET_MODE (mo
.u
.loc
), loc
, mo
.u
.loc
);
6038 /* The loc of a MO_VAL_SET may have various forms:
6040 (concat val dst): dst now holds val
6042 (concat val (set dst src)): dst now holds val, copied from src
6044 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6045 after replacing mems and non-top-level regs with values.
6047 (concat (concat val dstv) (set dst src)): dst now holds val,
6048 copied from src. dstv is a value-based representation of dst, if
6049 it differs from dst. If resolution is needed, src is a REG, and
6050 its mode is the same as that of val.
6052 (concat (concat val (set dstv srcv)) (set dst src)): src
6053 copied to dst, holding val. dstv and srcv are value-based
6054 representations of dst and src, respectively.
6058 if (GET_CODE (PATTERN (cui
->insn
)) != COND_EXEC
)
6059 reverse_op (v
->val_rtx
, expr
, cui
->insn
);
6064 VAL_HOLDS_TRACK_EXPR (loc
) = 1;
6067 VAL_NEEDS_RESOLUTION (loc
) = resolve
;
6070 if (mo
.type
== MO_CLOBBER
)
6071 VAL_EXPR_IS_CLOBBERED (loc
) = 1;
6072 if (mo
.type
== MO_COPY
)
6073 VAL_EXPR_IS_COPIED (loc
) = 1;
6075 mo
.type
= MO_VAL_SET
;
6078 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6079 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
6080 VTI (bb
)->mos
.safe_push (mo
);
6083 /* Arguments to the call. */
6084 static rtx call_arguments
;
6086 /* Compute call_arguments. */
6089 prepare_call_arguments (basic_block bb
, rtx insn
)
6092 rtx prev
, cur
, next
;
6093 rtx this_arg
= NULL_RTX
;
6094 tree type
= NULL_TREE
, t
, fndecl
= NULL_TREE
;
6095 tree obj_type_ref
= NULL_TREE
;
6096 CUMULATIVE_ARGS args_so_far_v
;
6097 cumulative_args_t args_so_far
;
6099 memset (&args_so_far_v
, 0, sizeof (args_so_far_v
));
6100 args_so_far
= pack_cumulative_args (&args_so_far_v
);
6101 call
= get_call_rtx_from (insn
);
6104 if (GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
6106 rtx symbol
= XEXP (XEXP (call
, 0), 0);
6107 if (SYMBOL_REF_DECL (symbol
))
6108 fndecl
= SYMBOL_REF_DECL (symbol
);
6110 if (fndecl
== NULL_TREE
)
6111 fndecl
= MEM_EXPR (XEXP (call
, 0));
6113 && TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
6114 && TREE_CODE (TREE_TYPE (fndecl
)) != METHOD_TYPE
)
6116 if (fndecl
&& TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6117 type
= TREE_TYPE (fndecl
);
6118 if (fndecl
&& TREE_CODE (fndecl
) != FUNCTION_DECL
)
6120 if (TREE_CODE (fndecl
) == INDIRECT_REF
6121 && TREE_CODE (TREE_OPERAND (fndecl
, 0)) == OBJ_TYPE_REF
)
6122 obj_type_ref
= TREE_OPERAND (fndecl
, 0);
6127 for (t
= TYPE_ARG_TYPES (type
); t
&& t
!= void_list_node
;
6129 if (TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
6130 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t
))))
6132 if ((t
== NULL
|| t
== void_list_node
) && obj_type_ref
== NULL_TREE
)
6136 int nargs ATTRIBUTE_UNUSED
= list_length (TYPE_ARG_TYPES (type
));
6137 link
= CALL_INSN_FUNCTION_USAGE (insn
);
6138 #ifndef PCC_STATIC_STRUCT_RETURN
6139 if (aggregate_value_p (TREE_TYPE (type
), type
)
6140 && targetm
.calls
.struct_value_rtx (type
, 0) == 0)
6142 tree struct_addr
= build_pointer_type (TREE_TYPE (type
));
6143 enum machine_mode mode
= TYPE_MODE (struct_addr
);
6145 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6147 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6149 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6151 if (reg
== NULL_RTX
)
6153 for (; link
; link
= XEXP (link
, 1))
6154 if (GET_CODE (XEXP (link
, 0)) == USE
6155 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6157 link
= XEXP (link
, 1);
6164 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6166 if (obj_type_ref
&& TYPE_ARG_TYPES (type
) != void_list_node
)
6168 enum machine_mode mode
;
6169 t
= TYPE_ARG_TYPES (type
);
6170 mode
= TYPE_MODE (TREE_VALUE (t
));
6171 this_arg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6172 TREE_VALUE (t
), true);
6173 if (this_arg
&& !REG_P (this_arg
))
6174 this_arg
= NULL_RTX
;
6175 else if (this_arg
== NULL_RTX
)
6177 for (; link
; link
= XEXP (link
, 1))
6178 if (GET_CODE (XEXP (link
, 0)) == USE
6179 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6181 this_arg
= XEXP (XEXP (link
, 0), 0);
6189 t
= type
? TYPE_ARG_TYPES (type
) : NULL_TREE
;
6191 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
6192 if (GET_CODE (XEXP (link
, 0)) == USE
)
6194 rtx item
= NULL_RTX
;
6195 x
= XEXP (XEXP (link
, 0), 0);
6196 if (GET_MODE (link
) == VOIDmode
6197 || GET_MODE (link
) == BLKmode
6198 || (GET_MODE (link
) != GET_MODE (x
)
6199 && (GET_MODE_CLASS (GET_MODE (link
)) != MODE_INT
6200 || GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
)))
6201 /* Can't do anything for these, if the original type mode
6202 isn't known or can't be converted. */;
6205 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6206 if (val
&& cselib_preserved_value_p (val
))
6207 item
= val
->val_rtx
;
6208 else if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_INT
)
6210 enum machine_mode mode
= GET_MODE (x
);
6212 while ((mode
= GET_MODE_WIDER_MODE (mode
)) != VOIDmode
6213 && GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
6215 rtx reg
= simplify_subreg (mode
, x
, GET_MODE (x
), 0);
6217 if (reg
== NULL_RTX
|| !REG_P (reg
))
6219 val
= cselib_lookup (reg
, mode
, 0, VOIDmode
);
6220 if (val
&& cselib_preserved_value_p (val
))
6222 item
= val
->val_rtx
;
6233 if (!frame_pointer_needed
)
6235 struct adjust_mem_data amd
;
6236 amd
.mem_mode
= VOIDmode
;
6237 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
6238 amd
.side_effects
= NULL_RTX
;
6240 mem
= simplify_replace_fn_rtx (mem
, NULL_RTX
, adjust_mems
,
6242 gcc_assert (amd
.side_effects
== NULL_RTX
);
6244 val
= cselib_lookup (mem
, GET_MODE (mem
), 0, VOIDmode
);
6245 if (val
&& cselib_preserved_value_p (val
))
6246 item
= val
->val_rtx
;
6247 else if (GET_MODE_CLASS (GET_MODE (mem
)) != MODE_INT
)
6249 /* For non-integer stack argument see also if they weren't
6250 initialized by integers. */
6251 enum machine_mode imode
= int_mode_for_mode (GET_MODE (mem
));
6252 if (imode
!= GET_MODE (mem
) && imode
!= BLKmode
)
6254 val
= cselib_lookup (adjust_address_nv (mem
, imode
, 0),
6255 imode
, 0, VOIDmode
);
6256 if (val
&& cselib_preserved_value_p (val
))
6257 item
= lowpart_subreg (GET_MODE (x
), val
->val_rtx
,
6265 if (GET_MODE (item
) != GET_MODE (link
))
6266 item
= lowpart_subreg (GET_MODE (link
), item
, GET_MODE (item
));
6267 if (GET_MODE (x2
) != GET_MODE (link
))
6268 x2
= lowpart_subreg (GET_MODE (link
), x2
, GET_MODE (x2
));
6269 item
= gen_rtx_CONCAT (GET_MODE (link
), x2
, item
);
6271 = gen_rtx_EXPR_LIST (VOIDmode
, item
, call_arguments
);
6273 if (t
&& t
!= void_list_node
)
6275 tree argtype
= TREE_VALUE (t
);
6276 enum machine_mode mode
= TYPE_MODE (argtype
);
6278 if (pass_by_reference (&args_so_far_v
, mode
, argtype
, true))
6280 argtype
= build_pointer_type (argtype
);
6281 mode
= TYPE_MODE (argtype
);
6283 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6285 if (TREE_CODE (argtype
) == REFERENCE_TYPE
6286 && INTEGRAL_TYPE_P (TREE_TYPE (argtype
))
6289 && GET_MODE (reg
) == mode
6290 && GET_MODE_CLASS (mode
) == MODE_INT
6292 && REGNO (x
) == REGNO (reg
)
6293 && GET_MODE (x
) == mode
6296 enum machine_mode indmode
6297 = TYPE_MODE (TREE_TYPE (argtype
));
6298 rtx mem
= gen_rtx_MEM (indmode
, x
);
6299 cselib_val
*val
= cselib_lookup (mem
, indmode
, 0, VOIDmode
);
6300 if (val
&& cselib_preserved_value_p (val
))
6302 item
= gen_rtx_CONCAT (indmode
, mem
, val
->val_rtx
);
6303 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6308 struct elt_loc_list
*l
;
6311 /* Try harder, when passing address of a constant
6312 pool integer it can be easily read back. */
6313 item
= XEXP (item
, 1);
6314 if (GET_CODE (item
) == SUBREG
)
6315 item
= SUBREG_REG (item
);
6316 gcc_assert (GET_CODE (item
) == VALUE
);
6317 val
= CSELIB_VAL_PTR (item
);
6318 for (l
= val
->locs
; l
; l
= l
->next
)
6319 if (GET_CODE (l
->loc
) == SYMBOL_REF
6320 && TREE_CONSTANT_POOL_ADDRESS_P (l
->loc
)
6321 && SYMBOL_REF_DECL (l
->loc
)
6322 && DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
)))
6324 initial
= DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
));
6325 if (tree_fits_shwi_p (initial
))
6327 item
= GEN_INT (tree_to_shwi (initial
));
6328 item
= gen_rtx_CONCAT (indmode
, mem
, item
);
6330 = gen_rtx_EXPR_LIST (VOIDmode
, item
,
6337 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6343 /* Add debug arguments. */
6345 && TREE_CODE (fndecl
) == FUNCTION_DECL
6346 && DECL_HAS_DEBUG_ARGS_P (fndecl
))
6348 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (fndecl
);
6353 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, ¶m
); ix
+= 2)
6356 tree dtemp
= (**debug_args
)[ix
+ 1];
6357 enum machine_mode mode
= DECL_MODE (dtemp
);
6358 item
= gen_rtx_DEBUG_PARAMETER_REF (mode
, param
);
6359 item
= gen_rtx_CONCAT (mode
, item
, DECL_RTL_KNOWN_SET (dtemp
));
6360 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6366 /* Reverse call_arguments chain. */
6368 for (cur
= call_arguments
; cur
; cur
= next
)
6370 next
= XEXP (cur
, 1);
6371 XEXP (cur
, 1) = prev
;
6374 call_arguments
= prev
;
6376 x
= get_call_rtx_from (insn
);
6379 x
= XEXP (XEXP (x
, 0), 0);
6380 if (GET_CODE (x
) == SYMBOL_REF
)
6381 /* Don't record anything. */;
6382 else if (CONSTANT_P (x
))
6384 x
= gen_rtx_CONCAT (GET_MODE (x
) == VOIDmode
? Pmode
: GET_MODE (x
),
6387 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6391 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6392 if (val
&& cselib_preserved_value_p (val
))
6394 x
= gen_rtx_CONCAT (GET_MODE (x
), pc_rtx
, val
->val_rtx
);
6396 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6402 enum machine_mode mode
6403 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref
)));
6404 rtx clobbered
= gen_rtx_MEM (mode
, this_arg
);
6406 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref
));
6408 clobbered
= plus_constant (mode
, clobbered
,
6409 token
* GET_MODE_SIZE (mode
));
6410 clobbered
= gen_rtx_MEM (mode
, clobbered
);
6411 x
= gen_rtx_CONCAT (mode
, gen_rtx_CLOBBER (VOIDmode
, pc_rtx
), clobbered
);
6413 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6417 /* Callback for cselib_record_sets_hook, that records as micro
6418 operations uses and stores in an insn after cselib_record_sets has
6419 analyzed the sets in an insn, but before it modifies the stored
6420 values in the internal tables, unless cselib_record_sets doesn't
6421 call it directly (perhaps because we're not doing cselib in the
6422 first place, in which case sets and n_sets will be 0). */
6425 add_with_sets (rtx insn
, struct cselib_set
*sets
, int n_sets
)
6427 basic_block bb
= BLOCK_FOR_INSN (insn
);
6429 struct count_use_info cui
;
6430 micro_operation
*mos
;
6432 cselib_hook_called
= true;
6437 cui
.n_sets
= n_sets
;
6439 n1
= VTI (bb
)->mos
.length ();
6440 cui
.store_p
= false;
6441 note_uses (&PATTERN (insn
), add_uses_1
, &cui
);
6442 n2
= VTI (bb
)->mos
.length () - 1;
6443 mos
= VTI (bb
)->mos
.address ();
6445 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6449 while (n1
< n2
&& mos
[n1
].type
== MO_USE
)
6451 while (n1
< n2
&& mos
[n2
].type
!= MO_USE
)
6463 n2
= VTI (bb
)->mos
.length () - 1;
6466 while (n1
< n2
&& mos
[n1
].type
!= MO_VAL_LOC
)
6468 while (n1
< n2
&& mos
[n2
].type
== MO_VAL_LOC
)
6486 mo
.u
.loc
= call_arguments
;
6487 call_arguments
= NULL_RTX
;
6489 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6490 log_op_type (PATTERN (insn
), bb
, insn
, mo
.type
, dump_file
);
6491 VTI (bb
)->mos
.safe_push (mo
);
6494 n1
= VTI (bb
)->mos
.length ();
6495 /* This will record NEXT_INSN (insn), such that we can
6496 insert notes before it without worrying about any
6497 notes that MO_USEs might emit after the insn. */
6499 note_stores (PATTERN (insn
), add_stores
, &cui
);
6500 n2
= VTI (bb
)->mos
.length () - 1;
6501 mos
= VTI (bb
)->mos
.address ();
6503 /* Order the MO_VAL_USEs first (note_stores does nothing
6504 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6505 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6508 while (n1
< n2
&& mos
[n1
].type
== MO_VAL_USE
)
6510 while (n1
< n2
&& mos
[n2
].type
!= MO_VAL_USE
)
6522 n2
= VTI (bb
)->mos
.length () - 1;
6525 while (n1
< n2
&& mos
[n1
].type
== MO_CLOBBER
)
6527 while (n1
< n2
&& mos
[n2
].type
!= MO_CLOBBER
)
6540 static enum var_init_status
6541 find_src_status (dataflow_set
*in
, rtx src
)
6543 tree decl
= NULL_TREE
;
6544 enum var_init_status status
= VAR_INIT_STATUS_UNINITIALIZED
;
6546 if (! flag_var_tracking_uninit
)
6547 status
= VAR_INIT_STATUS_INITIALIZED
;
6549 if (src
&& REG_P (src
))
6550 decl
= var_debug_decl (REG_EXPR (src
));
6551 else if (src
&& MEM_P (src
))
6552 decl
= var_debug_decl (MEM_EXPR (src
));
6555 status
= get_init_value (in
, src
, dv_from_decl (decl
));
6560 /* SRC is the source of an assignment. Use SET to try to find what
6561 was ultimately assigned to SRC. Return that value if known,
6562 otherwise return SRC itself. */
6565 find_src_set_src (dataflow_set
*set
, rtx src
)
6567 tree decl
= NULL_TREE
; /* The variable being copied around. */
6568 rtx set_src
= NULL_RTX
; /* The value for "decl" stored in "src". */
6570 location_chain nextp
;
6574 if (src
&& REG_P (src
))
6575 decl
= var_debug_decl (REG_EXPR (src
));
6576 else if (src
&& MEM_P (src
))
6577 decl
= var_debug_decl (MEM_EXPR (src
));
6581 decl_or_value dv
= dv_from_decl (decl
);
6583 var
= shared_hash_find (set
->vars
, dv
);
6587 for (i
= 0; i
< var
->n_var_parts
&& !found
; i
++)
6588 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
&& !found
;
6589 nextp
= nextp
->next
)
6590 if (rtx_equal_p (nextp
->loc
, src
))
6592 set_src
= nextp
->set_src
;
6602 /* Compute the changes of variable locations in the basic block BB. */
6605 compute_bb_dataflow (basic_block bb
)
6608 micro_operation
*mo
;
6610 dataflow_set old_out
;
6611 dataflow_set
*in
= &VTI (bb
)->in
;
6612 dataflow_set
*out
= &VTI (bb
)->out
;
6614 dataflow_set_init (&old_out
);
6615 dataflow_set_copy (&old_out
, out
);
6616 dataflow_set_copy (out
, in
);
6618 if (MAY_HAVE_DEBUG_INSNS
)
6619 local_get_addr_cache
= pointer_map_create ();
6621 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
6623 rtx insn
= mo
->insn
;
6628 dataflow_set_clear_at_call (out
);
6633 rtx loc
= mo
->u
.loc
;
6636 var_reg_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6637 else if (MEM_P (loc
))
6638 var_mem_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6644 rtx loc
= mo
->u
.loc
;
6648 if (GET_CODE (loc
) == CONCAT
)
6650 val
= XEXP (loc
, 0);
6651 vloc
= XEXP (loc
, 1);
6659 var
= PAT_VAR_LOCATION_DECL (vloc
);
6661 clobber_variable_part (out
, NULL_RTX
,
6662 dv_from_decl (var
), 0, NULL_RTX
);
6665 if (VAL_NEEDS_RESOLUTION (loc
))
6666 val_resolve (out
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
6667 set_variable_part (out
, val
, dv_from_decl (var
), 0,
6668 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6671 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
6672 set_variable_part (out
, PAT_VAR_LOCATION_LOC (vloc
),
6673 dv_from_decl (var
), 0,
6674 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6681 rtx loc
= mo
->u
.loc
;
6682 rtx val
, vloc
, uloc
;
6684 vloc
= uloc
= XEXP (loc
, 1);
6685 val
= XEXP (loc
, 0);
6687 if (GET_CODE (val
) == CONCAT
)
6689 uloc
= XEXP (val
, 1);
6690 val
= XEXP (val
, 0);
6693 if (VAL_NEEDS_RESOLUTION (loc
))
6694 val_resolve (out
, val
, vloc
, insn
);
6696 val_store (out
, val
, uloc
, insn
, false);
6698 if (VAL_HOLDS_TRACK_EXPR (loc
))
6700 if (GET_CODE (uloc
) == REG
)
6701 var_reg_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6703 else if (GET_CODE (uloc
) == MEM
)
6704 var_mem_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6712 rtx loc
= mo
->u
.loc
;
6713 rtx val
, vloc
, uloc
;
6717 uloc
= XEXP (vloc
, 1);
6718 val
= XEXP (vloc
, 0);
6721 if (GET_CODE (uloc
) == SET
)
6723 dstv
= SET_DEST (uloc
);
6724 srcv
= SET_SRC (uloc
);
6732 if (GET_CODE (val
) == CONCAT
)
6734 dstv
= vloc
= XEXP (val
, 1);
6735 val
= XEXP (val
, 0);
6738 if (GET_CODE (vloc
) == SET
)
6740 srcv
= SET_SRC (vloc
);
6742 gcc_assert (val
!= srcv
);
6743 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
6745 dstv
= vloc
= SET_DEST (vloc
);
6747 if (VAL_NEEDS_RESOLUTION (loc
))
6748 val_resolve (out
, val
, srcv
, insn
);
6750 else if (VAL_NEEDS_RESOLUTION (loc
))
6752 gcc_assert (GET_CODE (uloc
) == SET
6753 && GET_CODE (SET_SRC (uloc
)) == REG
);
6754 val_resolve (out
, val
, SET_SRC (uloc
), insn
);
6757 if (VAL_HOLDS_TRACK_EXPR (loc
))
6759 if (VAL_EXPR_IS_CLOBBERED (loc
))
6762 var_reg_delete (out
, uloc
, true);
6763 else if (MEM_P (uloc
))
6765 gcc_assert (MEM_P (dstv
));
6766 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
6767 var_mem_delete (out
, dstv
, true);
6772 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
6773 rtx src
= NULL
, dst
= uloc
;
6774 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
6776 if (GET_CODE (uloc
) == SET
)
6778 src
= SET_SRC (uloc
);
6779 dst
= SET_DEST (uloc
);
6784 if (flag_var_tracking_uninit
)
6786 status
= find_src_status (in
, src
);
6788 if (status
== VAR_INIT_STATUS_UNKNOWN
)
6789 status
= find_src_status (out
, src
);
6792 src
= find_src_set_src (in
, src
);
6796 var_reg_delete_and_set (out
, dst
, !copied_p
,
6798 else if (MEM_P (dst
))
6800 gcc_assert (MEM_P (dstv
));
6801 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
6802 var_mem_delete_and_set (out
, dstv
, !copied_p
,
6807 else if (REG_P (uloc
))
6808 var_regno_delete (out
, REGNO (uloc
));
6809 else if (MEM_P (uloc
))
6811 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
6812 gcc_checking_assert (dstv
== vloc
);
6814 clobber_overlapping_mems (out
, vloc
);
6817 val_store (out
, val
, dstv
, insn
, true);
6823 rtx loc
= mo
->u
.loc
;
6826 if (GET_CODE (loc
) == SET
)
6828 set_src
= SET_SRC (loc
);
6829 loc
= SET_DEST (loc
);
6833 var_reg_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6835 else if (MEM_P (loc
))
6836 var_mem_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6843 rtx loc
= mo
->u
.loc
;
6844 enum var_init_status src_status
;
6847 if (GET_CODE (loc
) == SET
)
6849 set_src
= SET_SRC (loc
);
6850 loc
= SET_DEST (loc
);
6853 if (! flag_var_tracking_uninit
)
6854 src_status
= VAR_INIT_STATUS_INITIALIZED
;
6857 src_status
= find_src_status (in
, set_src
);
6859 if (src_status
== VAR_INIT_STATUS_UNKNOWN
)
6860 src_status
= find_src_status (out
, set_src
);
6863 set_src
= find_src_set_src (in
, set_src
);
6866 var_reg_delete_and_set (out
, loc
, false, src_status
, set_src
);
6867 else if (MEM_P (loc
))
6868 var_mem_delete_and_set (out
, loc
, false, src_status
, set_src
);
6874 rtx loc
= mo
->u
.loc
;
6877 var_reg_delete (out
, loc
, false);
6878 else if (MEM_P (loc
))
6879 var_mem_delete (out
, loc
, false);
6885 rtx loc
= mo
->u
.loc
;
6888 var_reg_delete (out
, loc
, true);
6889 else if (MEM_P (loc
))
6890 var_mem_delete (out
, loc
, true);
6895 out
->stack_adjust
+= mo
->u
.adjust
;
6900 if (MAY_HAVE_DEBUG_INSNS
)
6902 pointer_map_destroy (local_get_addr_cache
);
6903 local_get_addr_cache
= NULL
;
6905 dataflow_set_equiv_regs (out
);
6906 shared_hash_htab (out
->vars
)
6907 .traverse
<dataflow_set
*, canonicalize_values_mark
> (out
);
6908 shared_hash_htab (out
->vars
)
6909 .traverse
<dataflow_set
*, canonicalize_values_star
> (out
);
6911 shared_hash_htab (out
->vars
)
6912 .traverse
<dataflow_set
*, canonicalize_loc_order_check
> (out
);
6915 changed
= dataflow_set_different (&old_out
, out
);
6916 dataflow_set_destroy (&old_out
);
6920 /* Find the locations of variables in the whole function. */
6923 vt_find_locations (void)
6925 fibheap_t worklist
, pending
, fibheap_swap
;
6926 sbitmap visited
, in_worklist
, in_pending
, sbitmap_swap
;
6933 int htabmax
= PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE
);
6934 bool success
= true;
6936 timevar_push (TV_VAR_TRACKING_DATAFLOW
);
6937 /* Compute reverse completion order of depth first search of the CFG
6938 so that the data-flow runs faster. */
6939 rc_order
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
6940 bb_order
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
6941 pre_and_rev_post_order_compute (NULL
, rc_order
, false);
6942 for (i
= 0; i
< n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
; i
++)
6943 bb_order
[rc_order
[i
]] = i
;
6946 worklist
= fibheap_new ();
6947 pending
= fibheap_new ();
6948 visited
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6949 in_worklist
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6950 in_pending
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6951 bitmap_clear (in_worklist
);
6953 FOR_EACH_BB_FN (bb
, cfun
)
6954 fibheap_insert (pending
, bb_order
[bb
->index
], bb
);
6955 bitmap_ones (in_pending
);
6957 while (success
&& !fibheap_empty (pending
))
6959 fibheap_swap
= pending
;
6961 worklist
= fibheap_swap
;
6962 sbitmap_swap
= in_pending
;
6963 in_pending
= in_worklist
;
6964 in_worklist
= sbitmap_swap
;
6966 bitmap_clear (visited
);
6968 while (!fibheap_empty (worklist
))
6970 bb
= (basic_block
) fibheap_extract_min (worklist
);
6971 bitmap_clear_bit (in_worklist
, bb
->index
);
6972 gcc_assert (!bitmap_bit_p (visited
, bb
->index
));
6973 if (!bitmap_bit_p (visited
, bb
->index
))
6977 int oldinsz
, oldoutsz
;
6979 bitmap_set_bit (visited
, bb
->index
);
6981 if (VTI (bb
)->in
.vars
)
6984 -= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
6985 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
6986 oldinsz
= shared_hash_htab (VTI (bb
)->in
.vars
).elements ();
6987 oldoutsz
= shared_hash_htab (VTI (bb
)->out
.vars
).elements ();
6990 oldinsz
= oldoutsz
= 0;
6992 if (MAY_HAVE_DEBUG_INSNS
)
6994 dataflow_set
*in
= &VTI (bb
)->in
, *first_out
= NULL
;
6995 bool first
= true, adjust
= false;
6997 /* Calculate the IN set as the intersection of
6998 predecessor OUT sets. */
7000 dataflow_set_clear (in
);
7001 dst_can_be_shared
= true;
7003 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7004 if (!VTI (e
->src
)->flooded
)
7005 gcc_assert (bb_order
[bb
->index
]
7006 <= bb_order
[e
->src
->index
]);
7009 dataflow_set_copy (in
, &VTI (e
->src
)->out
);
7010 first_out
= &VTI (e
->src
)->out
;
7015 dataflow_set_merge (in
, &VTI (e
->src
)->out
);
7021 dataflow_post_merge_adjust (in
, &VTI (bb
)->permp
);
7023 /* Merge and merge_adjust should keep entries in
7025 shared_hash_htab (in
->vars
)
7026 .traverse
<dataflow_set
*,
7027 canonicalize_loc_order_check
> (in
);
7029 if (dst_can_be_shared
)
7031 shared_hash_destroy (in
->vars
);
7032 in
->vars
= shared_hash_copy (first_out
->vars
);
7036 VTI (bb
)->flooded
= true;
7040 /* Calculate the IN set as union of predecessor OUT sets. */
7041 dataflow_set_clear (&VTI (bb
)->in
);
7042 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7043 dataflow_set_union (&VTI (bb
)->in
, &VTI (e
->src
)->out
);
7046 changed
= compute_bb_dataflow (bb
);
7047 htabsz
+= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
7048 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
7050 if (htabmax
&& htabsz
> htabmax
)
7052 if (MAY_HAVE_DEBUG_INSNS
)
7053 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7054 "variable tracking size limit exceeded with "
7055 "-fvar-tracking-assignments, retrying without");
7057 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7058 "variable tracking size limit exceeded");
7065 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7067 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7070 if (bitmap_bit_p (visited
, e
->dest
->index
))
7072 if (!bitmap_bit_p (in_pending
, e
->dest
->index
))
7074 /* Send E->DEST to next round. */
7075 bitmap_set_bit (in_pending
, e
->dest
->index
);
7076 fibheap_insert (pending
,
7077 bb_order
[e
->dest
->index
],
7081 else if (!bitmap_bit_p (in_worklist
, e
->dest
->index
))
7083 /* Add E->DEST to current round. */
7084 bitmap_set_bit (in_worklist
, e
->dest
->index
);
7085 fibheap_insert (worklist
, bb_order
[e
->dest
->index
],
7093 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7095 (int)shared_hash_htab (VTI (bb
)->in
.vars
).size (),
7097 (int)shared_hash_htab (VTI (bb
)->out
.vars
).size (),
7099 (int)worklist
->nodes
, (int)pending
->nodes
, htabsz
);
7101 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7103 fprintf (dump_file
, "BB %i IN:\n", bb
->index
);
7104 dump_dataflow_set (&VTI (bb
)->in
);
7105 fprintf (dump_file
, "BB %i OUT:\n", bb
->index
);
7106 dump_dataflow_set (&VTI (bb
)->out
);
7112 if (success
&& MAY_HAVE_DEBUG_INSNS
)
7113 FOR_EACH_BB_FN (bb
, cfun
)
7114 gcc_assert (VTI (bb
)->flooded
);
7117 fibheap_delete (worklist
);
7118 fibheap_delete (pending
);
7119 sbitmap_free (visited
);
7120 sbitmap_free (in_worklist
);
7121 sbitmap_free (in_pending
);
7123 timevar_pop (TV_VAR_TRACKING_DATAFLOW
);
7127 /* Print the content of the LIST to dump file. */
7130 dump_attrs_list (attrs list
)
7132 for (; list
; list
= list
->next
)
7134 if (dv_is_decl_p (list
->dv
))
7135 print_mem_expr (dump_file
, dv_as_decl (list
->dv
));
7137 print_rtl_single (dump_file
, dv_as_value (list
->dv
));
7138 fprintf (dump_file
, "+" HOST_WIDE_INT_PRINT_DEC
, list
->offset
);
7140 fprintf (dump_file
, "\n");
7143 /* Print the information about variable *SLOT to dump file. */
7146 dump_var_tracking_slot (variable_def
**slot
, void *data ATTRIBUTE_UNUSED
)
7148 variable var
= *slot
;
7152 /* Continue traversing the hash table. */
7156 /* Print the information about variable VAR to dump file. */
7159 dump_var (variable var
)
7162 location_chain node
;
7164 if (dv_is_decl_p (var
->dv
))
7166 const_tree decl
= dv_as_decl (var
->dv
);
7168 if (DECL_NAME (decl
))
7170 fprintf (dump_file
, " name: %s",
7171 IDENTIFIER_POINTER (DECL_NAME (decl
)));
7172 if (dump_flags
& TDF_UID
)
7173 fprintf (dump_file
, "D.%u", DECL_UID (decl
));
7175 else if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
7176 fprintf (dump_file
, " name: D#%u", DEBUG_TEMP_UID (decl
));
7178 fprintf (dump_file
, " name: D.%u", DECL_UID (decl
));
7179 fprintf (dump_file
, "\n");
7183 fputc (' ', dump_file
);
7184 print_rtl_single (dump_file
, dv_as_value (var
->dv
));
7187 for (i
= 0; i
< var
->n_var_parts
; i
++)
7189 fprintf (dump_file
, " offset %ld\n",
7190 (long)(var
->onepart
? 0 : VAR_PART_OFFSET (var
, i
)));
7191 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
7193 fprintf (dump_file
, " ");
7194 if (node
->init
== VAR_INIT_STATUS_UNINITIALIZED
)
7195 fprintf (dump_file
, "[uninit]");
7196 print_rtl_single (dump_file
, node
->loc
);
7201 /* Print the information about variables from hash table VARS to dump file. */
7204 dump_vars (variable_table_type vars
)
7206 if (vars
.elements () > 0)
7208 fprintf (dump_file
, "Variables:\n");
7209 vars
.traverse
<void *, dump_var_tracking_slot
> (NULL
);
7213 /* Print the dataflow set SET to dump file. */
7216 dump_dataflow_set (dataflow_set
*set
)
7220 fprintf (dump_file
, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC
"\n",
7222 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
7226 fprintf (dump_file
, "Reg %d:", i
);
7227 dump_attrs_list (set
->regs
[i
]);
7230 dump_vars (shared_hash_htab (set
->vars
));
7231 fprintf (dump_file
, "\n");
7234 /* Print the IN and OUT sets for each basic block to dump file. */
7237 dump_dataflow_sets (void)
7241 FOR_EACH_BB_FN (bb
, cfun
)
7243 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
7244 fprintf (dump_file
, "IN:\n");
7245 dump_dataflow_set (&VTI (bb
)->in
);
7246 fprintf (dump_file
, "OUT:\n");
7247 dump_dataflow_set (&VTI (bb
)->out
);
7251 /* Return the variable for DV in dropped_values, inserting one if
7252 requested with INSERT. */
7254 static inline variable
7255 variable_from_dropped (decl_or_value dv
, enum insert_option insert
)
7257 variable_def
**slot
;
7259 onepart_enum_t onepart
;
7261 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
), insert
);
7269 gcc_checking_assert (insert
== INSERT
);
7271 onepart
= dv_onepart_p (dv
);
7273 gcc_checking_assert (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
);
7275 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7277 empty_var
->refcount
= 1;
7278 empty_var
->n_var_parts
= 0;
7279 empty_var
->onepart
= onepart
;
7280 empty_var
->in_changed_variables
= false;
7281 empty_var
->var_part
[0].loc_chain
= NULL
;
7282 empty_var
->var_part
[0].cur_loc
= NULL
;
7283 VAR_LOC_1PAUX (empty_var
) = NULL
;
7284 set_dv_changed (dv
, true);
7291 /* Recover the one-part aux from dropped_values. */
7293 static struct onepart_aux
*
7294 recover_dropped_1paux (variable var
)
7298 gcc_checking_assert (var
->onepart
);
7300 if (VAR_LOC_1PAUX (var
))
7301 return VAR_LOC_1PAUX (var
);
7303 if (var
->onepart
== ONEPART_VDECL
)
7306 dvar
= variable_from_dropped (var
->dv
, NO_INSERT
);
7311 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (dvar
);
7312 VAR_LOC_1PAUX (dvar
) = NULL
;
7314 return VAR_LOC_1PAUX (var
);
7317 /* Add variable VAR to the hash table of changed variables and
7318 if it has no locations delete it from SET's hash table. */
7321 variable_was_changed (variable var
, dataflow_set
*set
)
7323 hashval_t hash
= dv_htab_hash (var
->dv
);
7327 variable_def
**slot
;
7329 /* Remember this decl or VALUE has been added to changed_variables. */
7330 set_dv_changed (var
->dv
, true);
7332 slot
= changed_variables
.find_slot_with_hash (var
->dv
, hash
, INSERT
);
7336 variable old_var
= *slot
;
7337 gcc_assert (old_var
->in_changed_variables
);
7338 old_var
->in_changed_variables
= false;
7339 if (var
!= old_var
&& var
->onepart
)
7341 /* Restore the auxiliary info from an empty variable
7342 previously created for changed_variables, so it is
7344 gcc_checking_assert (!VAR_LOC_1PAUX (var
));
7345 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (old_var
);
7346 VAR_LOC_1PAUX (old_var
) = NULL
;
7348 variable_htab_free (*slot
);
7351 if (set
&& var
->n_var_parts
== 0)
7353 onepart_enum_t onepart
= var
->onepart
;
7354 variable empty_var
= NULL
;
7355 variable_def
**dslot
= NULL
;
7357 if (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
)
7359 dslot
= dropped_values
.find_slot_with_hash (var
->dv
,
7360 dv_htab_hash (var
->dv
),
7366 gcc_checking_assert (!empty_var
->in_changed_variables
);
7367 if (!VAR_LOC_1PAUX (var
))
7369 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (empty_var
);
7370 VAR_LOC_1PAUX (empty_var
) = NULL
;
7373 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
7379 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7380 empty_var
->dv
= var
->dv
;
7381 empty_var
->refcount
= 1;
7382 empty_var
->n_var_parts
= 0;
7383 empty_var
->onepart
= onepart
;
7386 empty_var
->refcount
++;
7391 empty_var
->refcount
++;
7392 empty_var
->in_changed_variables
= true;
7396 empty_var
->var_part
[0].loc_chain
= NULL
;
7397 empty_var
->var_part
[0].cur_loc
= NULL
;
7398 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (var
);
7399 VAR_LOC_1PAUX (var
) = NULL
;
7405 if (var
->onepart
&& !VAR_LOC_1PAUX (var
))
7406 recover_dropped_1paux (var
);
7408 var
->in_changed_variables
= true;
7415 if (var
->n_var_parts
== 0)
7417 variable_def
**slot
;
7420 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
7423 if (shared_hash_shared (set
->vars
))
7424 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
,
7426 shared_hash_htab (set
->vars
).clear_slot (slot
);
7432 /* Look for the index in VAR->var_part corresponding to OFFSET.
7433 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7434 referenced int will be set to the index that the part has or should
7435 have, if it should be inserted. */
7438 find_variable_location_part (variable var
, HOST_WIDE_INT offset
,
7439 int *insertion_point
)
7448 if (insertion_point
)
7449 *insertion_point
= 0;
7451 return var
->n_var_parts
- 1;
7454 /* Find the location part. */
7456 high
= var
->n_var_parts
;
7459 pos
= (low
+ high
) / 2;
7460 if (VAR_PART_OFFSET (var
, pos
) < offset
)
7467 if (insertion_point
)
7468 *insertion_point
= pos
;
7470 if (pos
< var
->n_var_parts
&& VAR_PART_OFFSET (var
, pos
) == offset
)
7476 static variable_def
**
7477 set_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7478 decl_or_value dv
, HOST_WIDE_INT offset
,
7479 enum var_init_status initialized
, rtx set_src
)
7482 location_chain node
, next
;
7483 location_chain
*nextp
;
7485 onepart_enum_t onepart
;
7490 onepart
= var
->onepart
;
7492 onepart
= dv_onepart_p (dv
);
7494 gcc_checking_assert (offset
== 0 || !onepart
);
7495 gcc_checking_assert (loc
!= dv_as_opaque (dv
));
7497 if (! flag_var_tracking_uninit
)
7498 initialized
= VAR_INIT_STATUS_INITIALIZED
;
7502 /* Create new variable information. */
7503 var
= (variable
) pool_alloc (onepart_pool (onepart
));
7506 var
->n_var_parts
= 1;
7507 var
->onepart
= onepart
;
7508 var
->in_changed_variables
= false;
7510 VAR_LOC_1PAUX (var
) = NULL
;
7512 VAR_PART_OFFSET (var
, 0) = offset
;
7513 var
->var_part
[0].loc_chain
= NULL
;
7514 var
->var_part
[0].cur_loc
= NULL
;
7517 nextp
= &var
->var_part
[0].loc_chain
;
7523 gcc_assert (dv_as_opaque (var
->dv
) == dv_as_opaque (dv
));
7527 if (GET_CODE (loc
) == VALUE
)
7529 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7530 nextp
= &node
->next
)
7531 if (GET_CODE (node
->loc
) == VALUE
)
7533 if (node
->loc
== loc
)
7538 if (canon_value_cmp (node
->loc
, loc
))
7546 else if (REG_P (node
->loc
) || MEM_P (node
->loc
))
7554 else if (REG_P (loc
))
7556 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7557 nextp
= &node
->next
)
7558 if (REG_P (node
->loc
))
7560 if (REGNO (node
->loc
) < REGNO (loc
))
7564 if (REGNO (node
->loc
) == REGNO (loc
))
7577 else if (MEM_P (loc
))
7579 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7580 nextp
= &node
->next
)
7581 if (REG_P (node
->loc
))
7583 else if (MEM_P (node
->loc
))
7585 if ((r
= loc_cmp (XEXP (node
->loc
, 0), XEXP (loc
, 0))) >= 0)
7597 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7598 nextp
= &node
->next
)
7599 if ((r
= loc_cmp (node
->loc
, loc
)) >= 0)
7607 if (shared_var_p (var
, set
->vars
))
7609 slot
= unshare_variable (set
, slot
, var
, initialized
);
7611 for (nextp
= &var
->var_part
[0].loc_chain
; c
;
7612 nextp
= &(*nextp
)->next
)
7614 gcc_assert ((!node
&& !*nextp
) || node
->loc
== (*nextp
)->loc
);
7621 gcc_assert (dv_as_decl (var
->dv
) == dv_as_decl (dv
));
7623 pos
= find_variable_location_part (var
, offset
, &inspos
);
7627 node
= var
->var_part
[pos
].loc_chain
;
7630 && ((REG_P (node
->loc
) && REG_P (loc
)
7631 && REGNO (node
->loc
) == REGNO (loc
))
7632 || rtx_equal_p (node
->loc
, loc
)))
7634 /* LOC is in the beginning of the chain so we have nothing
7636 if (node
->init
< initialized
)
7637 node
->init
= initialized
;
7638 if (set_src
!= NULL
)
7639 node
->set_src
= set_src
;
7645 /* We have to make a copy of a shared variable. */
7646 if (shared_var_p (var
, set
->vars
))
7648 slot
= unshare_variable (set
, slot
, var
, initialized
);
7655 /* We have not found the location part, new one will be created. */
7657 /* We have to make a copy of the shared variable. */
7658 if (shared_var_p (var
, set
->vars
))
7660 slot
= unshare_variable (set
, slot
, var
, initialized
);
7664 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7665 thus there are at most MAX_VAR_PARTS different offsets. */
7666 gcc_assert (var
->n_var_parts
< MAX_VAR_PARTS
7667 && (!var
->n_var_parts
|| !onepart
));
7669 /* We have to move the elements of array starting at index
7670 inspos to the next position. */
7671 for (pos
= var
->n_var_parts
; pos
> inspos
; pos
--)
7672 var
->var_part
[pos
] = var
->var_part
[pos
- 1];
7675 gcc_checking_assert (!onepart
);
7676 VAR_PART_OFFSET (var
, pos
) = offset
;
7677 var
->var_part
[pos
].loc_chain
= NULL
;
7678 var
->var_part
[pos
].cur_loc
= NULL
;
7681 /* Delete the location from the list. */
7682 nextp
= &var
->var_part
[pos
].loc_chain
;
7683 for (node
= var
->var_part
[pos
].loc_chain
; node
; node
= next
)
7686 if ((REG_P (node
->loc
) && REG_P (loc
)
7687 && REGNO (node
->loc
) == REGNO (loc
))
7688 || rtx_equal_p (node
->loc
, loc
))
7690 /* Save these values, to assign to the new node, before
7691 deleting this one. */
7692 if (node
->init
> initialized
)
7693 initialized
= node
->init
;
7694 if (node
->set_src
!= NULL
&& set_src
== NULL
)
7695 set_src
= node
->set_src
;
7696 if (var
->var_part
[pos
].cur_loc
== node
->loc
)
7697 var
->var_part
[pos
].cur_loc
= NULL
;
7698 pool_free (loc_chain_pool
, node
);
7703 nextp
= &node
->next
;
7706 nextp
= &var
->var_part
[pos
].loc_chain
;
7709 /* Add the location to the beginning. */
7710 node
= (location_chain
) pool_alloc (loc_chain_pool
);
7712 node
->init
= initialized
;
7713 node
->set_src
= set_src
;
7714 node
->next
= *nextp
;
7717 /* If no location was emitted do so. */
7718 if (var
->var_part
[pos
].cur_loc
== NULL
)
7719 variable_was_changed (var
, set
);
7724 /* Set the part of variable's location in the dataflow set SET. The
7725 variable part is specified by variable's declaration in DV and
7726 offset OFFSET and the part's location by LOC. IOPT should be
7727 NO_INSERT if the variable is known to be in SET already and the
7728 variable hash table must not be resized, and INSERT otherwise. */
7731 set_variable_part (dataflow_set
*set
, rtx loc
,
7732 decl_or_value dv
, HOST_WIDE_INT offset
,
7733 enum var_init_status initialized
, rtx set_src
,
7734 enum insert_option iopt
)
7736 variable_def
**slot
;
7738 if (iopt
== NO_INSERT
)
7739 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7742 slot
= shared_hash_find_slot (set
->vars
, dv
);
7744 slot
= shared_hash_find_slot_unshare (&set
->vars
, dv
, iopt
);
7746 set_slot_part (set
, loc
, slot
, dv
, offset
, initialized
, set_src
);
7749 /* Remove all recorded register locations for the given variable part
7750 from dataflow set SET, except for those that are identical to loc.
7751 The variable part is specified by variable's declaration or value
7752 DV and offset OFFSET. */
7754 static variable_def
**
7755 clobber_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7756 HOST_WIDE_INT offset
, rtx set_src
)
7758 variable var
= *slot
;
7759 int pos
= find_variable_location_part (var
, offset
, NULL
);
7763 location_chain node
, next
;
7765 /* Remove the register locations from the dataflow set. */
7766 next
= var
->var_part
[pos
].loc_chain
;
7767 for (node
= next
; node
; node
= next
)
7770 if (node
->loc
!= loc
7771 && (!flag_var_tracking_uninit
7774 || !rtx_equal_p (set_src
, node
->set_src
)))
7776 if (REG_P (node
->loc
))
7781 /* Remove the variable part from the register's
7782 list, but preserve any other variable parts
7783 that might be regarded as live in that same
7785 anextp
= &set
->regs
[REGNO (node
->loc
)];
7786 for (anode
= *anextp
; anode
; anode
= anext
)
7788 anext
= anode
->next
;
7789 if (dv_as_opaque (anode
->dv
) == dv_as_opaque (var
->dv
)
7790 && anode
->offset
== offset
)
7792 pool_free (attrs_pool
, anode
);
7796 anextp
= &anode
->next
;
7800 slot
= delete_slot_part (set
, node
->loc
, slot
, offset
);
7808 /* Remove all recorded register locations for the given variable part
7809 from dataflow set SET, except for those that are identical to loc.
7810 The variable part is specified by variable's declaration or value
7811 DV and offset OFFSET. */
7814 clobber_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7815 HOST_WIDE_INT offset
, rtx set_src
)
7817 variable_def
**slot
;
7819 if (!dv_as_opaque (dv
)
7820 || (!dv_is_value_p (dv
) && ! DECL_P (dv_as_decl (dv
))))
7823 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7827 clobber_slot_part (set
, loc
, slot
, offset
, set_src
);
7830 /* Delete the part of variable's location from dataflow set SET. The
7831 variable part is specified by its SET->vars slot SLOT and offset
7832 OFFSET and the part's location by LOC. */
7834 static variable_def
**
7835 delete_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7836 HOST_WIDE_INT offset
)
7838 variable var
= *slot
;
7839 int pos
= find_variable_location_part (var
, offset
, NULL
);
7843 location_chain node
, next
;
7844 location_chain
*nextp
;
7848 if (shared_var_p (var
, set
->vars
))
7850 /* If the variable contains the location part we have to
7851 make a copy of the variable. */
7852 for (node
= var
->var_part
[pos
].loc_chain
; node
;
7855 if ((REG_P (node
->loc
) && REG_P (loc
)
7856 && REGNO (node
->loc
) == REGNO (loc
))
7857 || rtx_equal_p (node
->loc
, loc
))
7859 slot
= unshare_variable (set
, slot
, var
,
7860 VAR_INIT_STATUS_UNKNOWN
);
7867 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7868 cur_loc
= VAR_LOC_FROM (var
);
7870 cur_loc
= var
->var_part
[pos
].cur_loc
;
7872 /* Delete the location part. */
7874 nextp
= &var
->var_part
[pos
].loc_chain
;
7875 for (node
= *nextp
; node
; node
= next
)
7878 if ((REG_P (node
->loc
) && REG_P (loc
)
7879 && REGNO (node
->loc
) == REGNO (loc
))
7880 || rtx_equal_p (node
->loc
, loc
))
7882 /* If we have deleted the location which was last emitted
7883 we have to emit new location so add the variable to set
7884 of changed variables. */
7885 if (cur_loc
== node
->loc
)
7888 var
->var_part
[pos
].cur_loc
= NULL
;
7889 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7890 VAR_LOC_FROM (var
) = NULL
;
7892 pool_free (loc_chain_pool
, node
);
7897 nextp
= &node
->next
;
7900 if (var
->var_part
[pos
].loc_chain
== NULL
)
7904 while (pos
< var
->n_var_parts
)
7906 var
->var_part
[pos
] = var
->var_part
[pos
+ 1];
7911 variable_was_changed (var
, set
);
7917 /* Delete the part of variable's location from dataflow set SET. The
7918 variable part is specified by variable's declaration or value DV
7919 and offset OFFSET and the part's location by LOC. */
7922 delete_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7923 HOST_WIDE_INT offset
)
7925 variable_def
**slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7929 delete_slot_part (set
, loc
, slot
, offset
);
7933 /* Structure for passing some other parameters to function
7934 vt_expand_loc_callback. */
7935 struct expand_loc_callback_data
7937 /* The variables and values active at this point. */
7938 variable_table_type vars
;
7940 /* Stack of values and debug_exprs under expansion, and their
7942 auto_vec
<rtx
, 4> expanding
;
7944 /* Stack of values and debug_exprs whose expansion hit recursion
7945 cycles. They will have VALUE_RECURSED_INTO marked when added to
7946 this list. This flag will be cleared if any of its dependencies
7947 resolves to a valid location. So, if the flag remains set at the
7948 end of the search, we know no valid location for this one can
7950 auto_vec
<rtx
, 4> pending
;
7952 /* The maximum depth among the sub-expressions under expansion.
7953 Zero indicates no expansion so far. */
7957 /* Allocate the one-part auxiliary data structure for VAR, with enough
7958 room for COUNT dependencies. */
7961 loc_exp_dep_alloc (variable var
, int count
)
7965 gcc_checking_assert (var
->onepart
);
7967 /* We can be called with COUNT == 0 to allocate the data structure
7968 without any dependencies, e.g. for the backlinks only. However,
7969 if we are specifying a COUNT, then the dependency list must have
7970 been emptied before. It would be possible to adjust pointers or
7971 force it empty here, but this is better done at an earlier point
7972 in the algorithm, so we instead leave an assertion to catch
7974 gcc_checking_assert (!count
7975 || VAR_LOC_DEP_VEC (var
) == NULL
7976 || VAR_LOC_DEP_VEC (var
)->is_empty ());
7978 if (VAR_LOC_1PAUX (var
) && VAR_LOC_DEP_VEC (var
)->space (count
))
7981 allocsize
= offsetof (struct onepart_aux
, deps
)
7982 + vec
<loc_exp_dep
, va_heap
, vl_embed
>::embedded_size (count
);
7984 if (VAR_LOC_1PAUX (var
))
7986 VAR_LOC_1PAUX (var
) = XRESIZEVAR (struct onepart_aux
,
7987 VAR_LOC_1PAUX (var
), allocsize
);
7988 /* If the reallocation moves the onepaux structure, the
7989 back-pointer to BACKLINKS in the first list member will still
7990 point to its old location. Adjust it. */
7991 if (VAR_LOC_DEP_LST (var
))
7992 VAR_LOC_DEP_LST (var
)->pprev
= VAR_LOC_DEP_LSTP (var
);
7996 VAR_LOC_1PAUX (var
) = XNEWVAR (struct onepart_aux
, allocsize
);
7997 *VAR_LOC_DEP_LSTP (var
) = NULL
;
7998 VAR_LOC_FROM (var
) = NULL
;
7999 VAR_LOC_DEPTH (var
).complexity
= 0;
8000 VAR_LOC_DEPTH (var
).entryvals
= 0;
8002 VAR_LOC_DEP_VEC (var
)->embedded_init (count
);
8005 /* Remove all entries from the vector of active dependencies of VAR,
8006 removing them from the back-links lists too. */
8009 loc_exp_dep_clear (variable var
)
8011 while (VAR_LOC_DEP_VEC (var
) && !VAR_LOC_DEP_VEC (var
)->is_empty ())
8013 loc_exp_dep
*led
= &VAR_LOC_DEP_VEC (var
)->last ();
8015 led
->next
->pprev
= led
->pprev
;
8017 *led
->pprev
= led
->next
;
8018 VAR_LOC_DEP_VEC (var
)->pop ();
8022 /* Insert an active dependency from VAR on X to the vector of
8023 dependencies, and add the corresponding back-link to X's list of
8024 back-links in VARS. */
8027 loc_exp_insert_dep (variable var
, rtx x
, variable_table_type vars
)
8033 dv
= dv_from_rtx (x
);
8035 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8036 an additional look up? */
8037 xvar
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8041 xvar
= variable_from_dropped (dv
, NO_INSERT
);
8042 gcc_checking_assert (xvar
);
8045 /* No point in adding the same backlink more than once. This may
8046 arise if say the same value appears in two complex expressions in
8047 the same loc_list, or even more than once in a single
8049 if (VAR_LOC_DEP_LST (xvar
) && VAR_LOC_DEP_LST (xvar
)->dv
== var
->dv
)
8052 if (var
->onepart
== NOT_ONEPART
)
8053 led
= (loc_exp_dep
*) pool_alloc (loc_exp_dep_pool
);
8057 memset (&empty
, 0, sizeof (empty
));
8058 VAR_LOC_DEP_VEC (var
)->quick_push (empty
);
8059 led
= &VAR_LOC_DEP_VEC (var
)->last ();
8064 loc_exp_dep_alloc (xvar
, 0);
8065 led
->pprev
= VAR_LOC_DEP_LSTP (xvar
);
8066 led
->next
= *led
->pprev
;
8068 led
->next
->pprev
= &led
->next
;
8072 /* Create active dependencies of VAR on COUNT values starting at
8073 VALUE, and corresponding back-links to the entries in VARS. Return
8074 true if we found any pending-recursion results. */
8077 loc_exp_dep_set (variable var
, rtx result
, rtx
*value
, int count
,
8078 variable_table_type vars
)
8080 bool pending_recursion
= false;
8082 gcc_checking_assert (VAR_LOC_DEP_VEC (var
) == NULL
8083 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8085 /* Set up all dependencies from last_child (as set up at the end of
8086 the loop above) to the end. */
8087 loc_exp_dep_alloc (var
, count
);
8093 if (!pending_recursion
)
8094 pending_recursion
= !result
&& VALUE_RECURSED_INTO (x
);
8096 loc_exp_insert_dep (var
, x
, vars
);
8099 return pending_recursion
;
8102 /* Notify the back-links of IVAR that are pending recursion that we
8103 have found a non-NIL value for it, so they are cleared for another
8104 attempt to compute a current location. */
8107 notify_dependents_of_resolved_value (variable ivar
, variable_table_type vars
)
8109 loc_exp_dep
*led
, *next
;
8111 for (led
= VAR_LOC_DEP_LST (ivar
); led
; led
= next
)
8113 decl_or_value dv
= led
->dv
;
8118 if (dv_is_value_p (dv
))
8120 rtx value
= dv_as_value (dv
);
8122 /* If we have already resolved it, leave it alone. */
8123 if (!VALUE_RECURSED_INTO (value
))
8126 /* Check that VALUE_RECURSED_INTO, true from the test above,
8127 implies NO_LOC_P. */
8128 gcc_checking_assert (NO_LOC_P (value
));
8130 /* We won't notify variables that are being expanded,
8131 because their dependency list is cleared before
8133 NO_LOC_P (value
) = false;
8134 VALUE_RECURSED_INTO (value
) = false;
8136 gcc_checking_assert (dv_changed_p (dv
));
8140 gcc_checking_assert (dv_onepart_p (dv
) != NOT_ONEPART
);
8141 if (!dv_changed_p (dv
))
8145 var
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8148 var
= variable_from_dropped (dv
, NO_INSERT
);
8151 notify_dependents_of_resolved_value (var
, vars
);
8154 next
->pprev
= led
->pprev
;
8162 static rtx
vt_expand_loc_callback (rtx x
, bitmap regs
,
8163 int max_depth
, void *data
);
8165 /* Return the combined depth, when one sub-expression evaluated to
8166 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8168 static inline expand_depth
8169 update_depth (expand_depth saved_depth
, expand_depth best_depth
)
8171 /* If we didn't find anything, stick with what we had. */
8172 if (!best_depth
.complexity
)
8175 /* If we found hadn't found anything, use the depth of the current
8176 expression. Do NOT add one extra level, we want to compute the
8177 maximum depth among sub-expressions. We'll increment it later,
8179 if (!saved_depth
.complexity
)
8182 /* Combine the entryval count so that regardless of which one we
8183 return, the entryval count is accurate. */
8184 best_depth
.entryvals
= saved_depth
.entryvals
8185 = best_depth
.entryvals
+ saved_depth
.entryvals
;
8187 if (saved_depth
.complexity
< best_depth
.complexity
)
8193 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8194 DATA for cselib expand callback. If PENDRECP is given, indicate in
8195 it whether any sub-expression couldn't be fully evaluated because
8196 it is pending recursion resolution. */
8199 vt_expand_var_loc_chain (variable var
, bitmap regs
, void *data
, bool *pendrecp
)
8201 struct expand_loc_callback_data
*elcd
8202 = (struct expand_loc_callback_data
*) data
;
8203 location_chain loc
, next
;
8205 int first_child
, result_first_child
, last_child
;
8206 bool pending_recursion
;
8207 rtx loc_from
= NULL
;
8208 struct elt_loc_list
*cloc
= NULL
;
8209 expand_depth depth
= { 0, 0 }, saved_depth
= elcd
->depth
;
8210 int wanted_entryvals
, found_entryvals
= 0;
8212 /* Clear all backlinks pointing at this, so that we're not notified
8213 while we're active. */
8214 loc_exp_dep_clear (var
);
8217 if (var
->onepart
== ONEPART_VALUE
)
8219 cselib_val
*val
= CSELIB_VAL_PTR (dv_as_value (var
->dv
));
8221 gcc_checking_assert (cselib_preserved_value_p (val
));
8226 first_child
= result_first_child
= last_child
8227 = elcd
->expanding
.length ();
8229 wanted_entryvals
= found_entryvals
;
8231 /* Attempt to expand each available location in turn. */
8232 for (next
= loc
= var
->n_var_parts
? var
->var_part
[0].loc_chain
: NULL
;
8233 loc
|| cloc
; loc
= next
)
8235 result_first_child
= last_child
;
8239 loc_from
= cloc
->loc
;
8242 if (unsuitable_loc (loc_from
))
8247 loc_from
= loc
->loc
;
8251 gcc_checking_assert (!unsuitable_loc (loc_from
));
8253 elcd
->depth
.complexity
= elcd
->depth
.entryvals
= 0;
8254 result
= cselib_expand_value_rtx_cb (loc_from
, regs
, EXPR_DEPTH
,
8255 vt_expand_loc_callback
, data
);
8256 last_child
= elcd
->expanding
.length ();
8260 depth
= elcd
->depth
;
8262 gcc_checking_assert (depth
.complexity
8263 || result_first_child
== last_child
);
8265 if (last_child
- result_first_child
!= 1)
8267 if (!depth
.complexity
&& GET_CODE (result
) == ENTRY_VALUE
)
8272 if (depth
.complexity
<= EXPR_USE_DEPTH
)
8274 if (depth
.entryvals
<= wanted_entryvals
)
8276 else if (!found_entryvals
|| depth
.entryvals
< found_entryvals
)
8277 found_entryvals
= depth
.entryvals
;
8283 /* Set it up in case we leave the loop. */
8284 depth
.complexity
= depth
.entryvals
= 0;
8286 result_first_child
= first_child
;
8289 if (!loc_from
&& wanted_entryvals
< found_entryvals
)
8291 /* We found entries with ENTRY_VALUEs and skipped them. Since
8292 we could not find any expansions without ENTRY_VALUEs, but we
8293 found at least one with them, go back and get an entry with
8294 the minimum number ENTRY_VALUE count that we found. We could
8295 avoid looping, but since each sub-loc is already resolved,
8296 the re-expansion should be trivial. ??? Should we record all
8297 attempted locs as dependencies, so that we retry the
8298 expansion should any of them change, in the hope it can give
8299 us a new entry without an ENTRY_VALUE? */
8300 elcd
->expanding
.truncate (first_child
);
8304 /* Register all encountered dependencies as active. */
8305 pending_recursion
= loc_exp_dep_set
8306 (var
, result
, elcd
->expanding
.address () + result_first_child
,
8307 last_child
- result_first_child
, elcd
->vars
);
8309 elcd
->expanding
.truncate (first_child
);
8311 /* Record where the expansion came from. */
8312 gcc_checking_assert (!result
|| !pending_recursion
);
8313 VAR_LOC_FROM (var
) = loc_from
;
8314 VAR_LOC_DEPTH (var
) = depth
;
8316 gcc_checking_assert (!depth
.complexity
== !result
);
8318 elcd
->depth
= update_depth (saved_depth
, depth
);
8320 /* Indicate whether any of the dependencies are pending recursion
8323 *pendrecp
= pending_recursion
;
8325 if (!pendrecp
|| !pending_recursion
)
8326 var
->var_part
[0].cur_loc
= result
;
8331 /* Callback for cselib_expand_value, that looks for expressions
8332 holding the value in the var-tracking hash tables. Return X for
8333 standard processing, anything else is to be used as-is. */
8336 vt_expand_loc_callback (rtx x
, bitmap regs
,
8337 int max_depth ATTRIBUTE_UNUSED
,
8340 struct expand_loc_callback_data
*elcd
8341 = (struct expand_loc_callback_data
*) data
;
8345 bool pending_recursion
= false;
8346 bool from_empty
= false;
8348 switch (GET_CODE (x
))
8351 subreg
= cselib_expand_value_rtx_cb (SUBREG_REG (x
), regs
,
8353 vt_expand_loc_callback
, data
);
8358 result
= simplify_gen_subreg (GET_MODE (x
), subreg
,
8359 GET_MODE (SUBREG_REG (x
)),
8362 /* Invalid SUBREGs are ok in debug info. ??? We could try
8363 alternate expansions for the VALUE as well. */
8365 result
= gen_rtx_raw_SUBREG (GET_MODE (x
), subreg
, SUBREG_BYTE (x
));
8371 dv
= dv_from_rtx (x
);
8378 elcd
->expanding
.safe_push (x
);
8380 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8381 gcc_checking_assert (!VALUE_RECURSED_INTO (x
) || NO_LOC_P (x
));
8385 gcc_checking_assert (VALUE_RECURSED_INTO (x
) || !dv_changed_p (dv
));
8389 var
= elcd
->vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8394 var
= variable_from_dropped (dv
, INSERT
);
8397 gcc_checking_assert (var
);
8399 if (!dv_changed_p (dv
))
8401 gcc_checking_assert (!NO_LOC_P (x
));
8402 gcc_checking_assert (var
->var_part
[0].cur_loc
);
8403 gcc_checking_assert (VAR_LOC_1PAUX (var
));
8404 gcc_checking_assert (VAR_LOC_1PAUX (var
)->depth
.complexity
);
8406 elcd
->depth
= update_depth (elcd
->depth
, VAR_LOC_1PAUX (var
)->depth
);
8408 return var
->var_part
[0].cur_loc
;
8411 VALUE_RECURSED_INTO (x
) = true;
8412 /* This is tentative, but it makes some tests simpler. */
8413 NO_LOC_P (x
) = true;
8415 gcc_checking_assert (var
->n_var_parts
== 1 || from_empty
);
8417 result
= vt_expand_var_loc_chain (var
, regs
, data
, &pending_recursion
);
8419 if (pending_recursion
)
8421 gcc_checking_assert (!result
);
8422 elcd
->pending
.safe_push (x
);
8426 NO_LOC_P (x
) = !result
;
8427 VALUE_RECURSED_INTO (x
) = false;
8428 set_dv_changed (dv
, false);
8431 notify_dependents_of_resolved_value (var
, elcd
->vars
);
8437 /* While expanding variables, we may encounter recursion cycles
8438 because of mutual (possibly indirect) dependencies between two
8439 particular variables (or values), say A and B. If we're trying to
8440 expand A when we get to B, which in turn attempts to expand A, if
8441 we can't find any other expansion for B, we'll add B to this
8442 pending-recursion stack, and tentatively return NULL for its
8443 location. This tentative value will be used for any other
8444 occurrences of B, unless A gets some other location, in which case
8445 it will notify B that it is worth another try at computing a
8446 location for it, and it will use the location computed for A then.
8447 At the end of the expansion, the tentative NULL locations become
8448 final for all members of PENDING that didn't get a notification.
8449 This function performs this finalization of NULL locations. */
8452 resolve_expansions_pending_recursion (vec
<rtx
, va_heap
> *pending
)
8454 while (!pending
->is_empty ())
8456 rtx x
= pending
->pop ();
8459 if (!VALUE_RECURSED_INTO (x
))
8462 gcc_checking_assert (NO_LOC_P (x
));
8463 VALUE_RECURSED_INTO (x
) = false;
8464 dv
= dv_from_rtx (x
);
8465 gcc_checking_assert (dv_changed_p (dv
));
8466 set_dv_changed (dv
, false);
8470 /* Initialize expand_loc_callback_data D with variable hash table V.
8471 It must be a macro because of alloca (vec stack). */
8472 #define INIT_ELCD(d, v) \
8476 (d).depth.complexity = (d).depth.entryvals = 0; \
8479 /* Finalize expand_loc_callback_data D, resolved to location L. */
8480 #define FINI_ELCD(d, l) \
8483 resolve_expansions_pending_recursion (&(d).pending); \
8484 (d).pending.release (); \
8485 (d).expanding.release (); \
8487 if ((l) && MEM_P (l)) \
8488 (l) = targetm.delegitimize_address (l); \
8492 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8493 equivalences in VARS, updating their CUR_LOCs in the process. */
8496 vt_expand_loc (rtx loc
, variable_table_type vars
)
8498 struct expand_loc_callback_data data
;
8501 if (!MAY_HAVE_DEBUG_INSNS
)
8504 INIT_ELCD (data
, vars
);
8506 result
= cselib_expand_value_rtx_cb (loc
, scratch_regs
, EXPR_DEPTH
,
8507 vt_expand_loc_callback
, &data
);
8509 FINI_ELCD (data
, result
);
8514 /* Expand the one-part VARiable to a location, using the equivalences
8515 in VARS, updating their CUR_LOCs in the process. */
8518 vt_expand_1pvar (variable var
, variable_table_type vars
)
8520 struct expand_loc_callback_data data
;
8523 gcc_checking_assert (var
->onepart
&& var
->n_var_parts
== 1);
8525 if (!dv_changed_p (var
->dv
))
8526 return var
->var_part
[0].cur_loc
;
8528 INIT_ELCD (data
, vars
);
8530 loc
= vt_expand_var_loc_chain (var
, scratch_regs
, &data
, NULL
);
8532 gcc_checking_assert (data
.expanding
.is_empty ());
8534 FINI_ELCD (data
, loc
);
8539 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8540 additional parameters: WHERE specifies whether the note shall be emitted
8541 before or after instruction INSN. */
8544 emit_note_insn_var_location (variable_def
**varp
, emit_note_data
*data
)
8546 variable var
= *varp
;
8547 rtx insn
= data
->insn
;
8548 enum emit_note_where where
= data
->where
;
8549 variable_table_type vars
= data
->vars
;
8551 int i
, j
, n_var_parts
;
8553 enum var_init_status initialized
= VAR_INIT_STATUS_UNINITIALIZED
;
8554 HOST_WIDE_INT last_limit
;
8555 tree type_size_unit
;
8556 HOST_WIDE_INT offsets
[MAX_VAR_PARTS
];
8557 rtx loc
[MAX_VAR_PARTS
];
8561 gcc_checking_assert (var
->onepart
== NOT_ONEPART
8562 || var
->onepart
== ONEPART_VDECL
);
8564 decl
= dv_as_decl (var
->dv
);
8570 for (i
= 0; i
< var
->n_var_parts
; i
++)
8571 if (var
->var_part
[i
].cur_loc
== NULL
&& var
->var_part
[i
].loc_chain
)
8572 var
->var_part
[i
].cur_loc
= var
->var_part
[i
].loc_chain
->loc
;
8573 for (i
= 0; i
< var
->n_var_parts
; i
++)
8575 enum machine_mode mode
, wider_mode
;
8577 HOST_WIDE_INT offset
;
8579 if (i
== 0 && var
->onepart
)
8581 gcc_checking_assert (var
->n_var_parts
== 1);
8583 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8584 loc2
= vt_expand_1pvar (var
, vars
);
8588 if (last_limit
< VAR_PART_OFFSET (var
, i
))
8593 else if (last_limit
> VAR_PART_OFFSET (var
, i
))
8595 offset
= VAR_PART_OFFSET (var
, i
);
8596 loc2
= var
->var_part
[i
].cur_loc
;
8597 if (loc2
&& GET_CODE (loc2
) == MEM
8598 && GET_CODE (XEXP (loc2
, 0)) == VALUE
)
8600 rtx depval
= XEXP (loc2
, 0);
8602 loc2
= vt_expand_loc (loc2
, vars
);
8605 loc_exp_insert_dep (var
, depval
, vars
);
8612 gcc_checking_assert (GET_CODE (loc2
) != VALUE
);
8613 for (lc
= var
->var_part
[i
].loc_chain
; lc
; lc
= lc
->next
)
8614 if (var
->var_part
[i
].cur_loc
== lc
->loc
)
8616 initialized
= lc
->init
;
8622 offsets
[n_var_parts
] = offset
;
8628 loc
[n_var_parts
] = loc2
;
8629 mode
= GET_MODE (var
->var_part
[i
].cur_loc
);
8630 if (mode
== VOIDmode
&& var
->onepart
)
8631 mode
= DECL_MODE (decl
);
8632 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8634 /* Attempt to merge adjacent registers or memory. */
8635 wider_mode
= GET_MODE_WIDER_MODE (mode
);
8636 for (j
= i
+ 1; j
< var
->n_var_parts
; j
++)
8637 if (last_limit
<= VAR_PART_OFFSET (var
, j
))
8639 if (j
< var
->n_var_parts
8640 && wider_mode
!= VOIDmode
8641 && var
->var_part
[j
].cur_loc
8642 && mode
== GET_MODE (var
->var_part
[j
].cur_loc
)
8643 && (REG_P (loc
[n_var_parts
]) || MEM_P (loc
[n_var_parts
]))
8644 && last_limit
== (var
->onepart
? 0 : VAR_PART_OFFSET (var
, j
))
8645 && (loc2
= vt_expand_loc (var
->var_part
[j
].cur_loc
, vars
))
8646 && GET_CODE (loc
[n_var_parts
]) == GET_CODE (loc2
))
8650 if (REG_P (loc
[n_var_parts
])
8651 && hard_regno_nregs
[REGNO (loc
[n_var_parts
])][mode
] * 2
8652 == hard_regno_nregs
[REGNO (loc
[n_var_parts
])][wider_mode
]
8653 && end_hard_regno (mode
, REGNO (loc
[n_var_parts
]))
8656 if (! WORDS_BIG_ENDIAN
&& ! BYTES_BIG_ENDIAN
)
8657 new_loc
= simplify_subreg (wider_mode
, loc
[n_var_parts
],
8659 else if (WORDS_BIG_ENDIAN
&& BYTES_BIG_ENDIAN
)
8660 new_loc
= simplify_subreg (wider_mode
, loc2
, mode
, 0);
8663 if (!REG_P (new_loc
)
8664 || REGNO (new_loc
) != REGNO (loc
[n_var_parts
]))
8667 REG_ATTRS (new_loc
) = REG_ATTRS (loc
[n_var_parts
]);
8670 else if (MEM_P (loc
[n_var_parts
])
8671 && GET_CODE (XEXP (loc2
, 0)) == PLUS
8672 && REG_P (XEXP (XEXP (loc2
, 0), 0))
8673 && CONST_INT_P (XEXP (XEXP (loc2
, 0), 1)))
8675 if ((REG_P (XEXP (loc
[n_var_parts
], 0))
8676 && rtx_equal_p (XEXP (loc
[n_var_parts
], 0),
8677 XEXP (XEXP (loc2
, 0), 0))
8678 && INTVAL (XEXP (XEXP (loc2
, 0), 1))
8679 == GET_MODE_SIZE (mode
))
8680 || (GET_CODE (XEXP (loc
[n_var_parts
], 0)) == PLUS
8681 && CONST_INT_P (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8682 && rtx_equal_p (XEXP (XEXP (loc
[n_var_parts
], 0), 0),
8683 XEXP (XEXP (loc2
, 0), 0))
8684 && INTVAL (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8685 + GET_MODE_SIZE (mode
)
8686 == INTVAL (XEXP (XEXP (loc2
, 0), 1))))
8687 new_loc
= adjust_address_nv (loc
[n_var_parts
],
8693 loc
[n_var_parts
] = new_loc
;
8695 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8701 type_size_unit
= TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8702 if ((unsigned HOST_WIDE_INT
) last_limit
< TREE_INT_CST_LOW (type_size_unit
))
8705 if (! flag_var_tracking_uninit
)
8706 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8710 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, NULL_RTX
,
8712 else if (n_var_parts
== 1)
8716 if (offsets
[0] || GET_CODE (loc
[0]) == PARALLEL
)
8717 expr_list
= gen_rtx_EXPR_LIST (VOIDmode
, loc
[0], GEN_INT (offsets
[0]));
8721 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, expr_list
,
8724 else if (n_var_parts
)
8728 for (i
= 0; i
< n_var_parts
; i
++)
8730 = gen_rtx_EXPR_LIST (VOIDmode
, loc
[i
], GEN_INT (offsets
[i
]));
8732 parallel
= gen_rtx_PARALLEL (VOIDmode
,
8733 gen_rtvec_v (n_var_parts
, loc
));
8734 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
,
8735 parallel
, (int) initialized
);
8738 if (where
!= EMIT_NOTE_BEFORE_INSN
)
8740 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8741 if (where
== EMIT_NOTE_AFTER_CALL_INSN
)
8742 NOTE_DURING_CALL_P (note
) = true;
8746 /* Make sure that the call related notes come first. */
8747 while (NEXT_INSN (insn
)
8749 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8750 && NOTE_DURING_CALL_P (insn
))
8751 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8752 insn
= NEXT_INSN (insn
);
8754 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8755 && NOTE_DURING_CALL_P (insn
))
8756 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8757 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8759 note
= emit_note_before (NOTE_INSN_VAR_LOCATION
, insn
);
8761 NOTE_VAR_LOCATION (note
) = note_vl
;
8763 set_dv_changed (var
->dv
, false);
8764 gcc_assert (var
->in_changed_variables
);
8765 var
->in_changed_variables
= false;
8766 changed_variables
.clear_slot (varp
);
8768 /* Continue traversing the hash table. */
8772 /* While traversing changed_variables, push onto DATA (a stack of RTX
8773 values) entries that aren't user variables. */
8776 var_track_values_to_stack (variable_def
**slot
,
8777 vec
<rtx
, va_heap
> *changed_values_stack
)
8779 variable var
= *slot
;
8781 if (var
->onepart
== ONEPART_VALUE
)
8782 changed_values_stack
->safe_push (dv_as_value (var
->dv
));
8783 else if (var
->onepart
== ONEPART_DEXPR
)
8784 changed_values_stack
->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var
->dv
)));
8789 /* Remove from changed_variables the entry whose DV corresponds to
8790 value or debug_expr VAL. */
8792 remove_value_from_changed_variables (rtx val
)
8794 decl_or_value dv
= dv_from_rtx (val
);
8795 variable_def
**slot
;
8798 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8801 var
->in_changed_variables
= false;
8802 changed_variables
.clear_slot (slot
);
8805 /* If VAL (a value or debug_expr) has backlinks to variables actively
8806 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8807 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8808 have dependencies of their own to notify. */
8811 notify_dependents_of_changed_value (rtx val
, variable_table_type htab
,
8812 vec
<rtx
, va_heap
> *changed_values_stack
)
8814 variable_def
**slot
;
8817 decl_or_value dv
= dv_from_rtx (val
);
8819 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8822 slot
= htab
.find_slot_with_hash (dv
, dv_htab_hash (dv
), NO_INSERT
);
8824 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8828 while ((led
= VAR_LOC_DEP_LST (var
)))
8830 decl_or_value ldv
= led
->dv
;
8833 /* Deactivate and remove the backlink, as it was “used up”. It
8834 makes no sense to attempt to notify the same entity again:
8835 either it will be recomputed and re-register an active
8836 dependency, or it will still have the changed mark. */
8838 led
->next
->pprev
= led
->pprev
;
8840 *led
->pprev
= led
->next
;
8844 if (dv_changed_p (ldv
))
8847 switch (dv_onepart_p (ldv
))
8851 set_dv_changed (ldv
, true);
8852 changed_values_stack
->safe_push (dv_as_rtx (ldv
));
8856 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8857 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar
));
8858 variable_was_changed (ivar
, NULL
);
8862 pool_free (loc_exp_dep_pool
, led
);
8863 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8866 int i
= ivar
->n_var_parts
;
8869 rtx loc
= ivar
->var_part
[i
].cur_loc
;
8871 if (loc
&& GET_CODE (loc
) == MEM
8872 && XEXP (loc
, 0) == val
)
8874 variable_was_changed (ivar
, NULL
);
8887 /* Take out of changed_variables any entries that don't refer to use
8888 variables. Back-propagate change notifications from values and
8889 debug_exprs to their active dependencies in HTAB or in
8890 CHANGED_VARIABLES. */
8893 process_changed_values (variable_table_type htab
)
8897 auto_vec
<rtx
, 20> changed_values_stack
;
8899 /* Move values from changed_variables to changed_values_stack. */
8901 .traverse
<vec
<rtx
, va_heap
>*, var_track_values_to_stack
>
8902 (&changed_values_stack
);
8904 /* Back-propagate change notifications in values while popping
8905 them from the stack. */
8906 for (n
= i
= changed_values_stack
.length ();
8907 i
> 0; i
= changed_values_stack
.length ())
8909 val
= changed_values_stack
.pop ();
8910 notify_dependents_of_changed_value (val
, htab
, &changed_values_stack
);
8912 /* This condition will hold when visiting each of the entries
8913 originally in changed_variables. We can't remove them
8914 earlier because this could drop the backlinks before we got a
8915 chance to use them. */
8918 remove_value_from_changed_variables (val
);
8924 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
8925 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
8926 the notes shall be emitted before of after instruction INSN. */
8929 emit_notes_for_changes (rtx insn
, enum emit_note_where where
,
8932 emit_note_data data
;
8933 variable_table_type htab
= shared_hash_htab (vars
);
8935 if (!changed_variables
.elements ())
8938 if (MAY_HAVE_DEBUG_INSNS
)
8939 process_changed_values (htab
);
8946 .traverse
<emit_note_data
*, emit_note_insn_var_location
> (&data
);
8949 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
8950 same variable in hash table DATA or is not there at all. */
8953 emit_notes_for_differences_1 (variable_def
**slot
, variable_table_type new_vars
)
8955 variable old_var
, new_var
;
8958 new_var
= new_vars
.find_with_hash (old_var
->dv
, dv_htab_hash (old_var
->dv
));
8962 /* Variable has disappeared. */
8963 variable empty_var
= NULL
;
8965 if (old_var
->onepart
== ONEPART_VALUE
8966 || old_var
->onepart
== ONEPART_DEXPR
)
8968 empty_var
= variable_from_dropped (old_var
->dv
, NO_INSERT
);
8971 gcc_checking_assert (!empty_var
->in_changed_variables
);
8972 if (!VAR_LOC_1PAUX (old_var
))
8974 VAR_LOC_1PAUX (old_var
) = VAR_LOC_1PAUX (empty_var
);
8975 VAR_LOC_1PAUX (empty_var
) = NULL
;
8978 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
8984 empty_var
= (variable
) pool_alloc (onepart_pool (old_var
->onepart
));
8985 empty_var
->dv
= old_var
->dv
;
8986 empty_var
->refcount
= 0;
8987 empty_var
->n_var_parts
= 0;
8988 empty_var
->onepart
= old_var
->onepart
;
8989 empty_var
->in_changed_variables
= false;
8992 if (empty_var
->onepart
)
8994 /* Propagate the auxiliary data to (ultimately)
8995 changed_variables. */
8996 empty_var
->var_part
[0].loc_chain
= NULL
;
8997 empty_var
->var_part
[0].cur_loc
= NULL
;
8998 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (old_var
);
8999 VAR_LOC_1PAUX (old_var
) = NULL
;
9001 variable_was_changed (empty_var
, NULL
);
9002 /* Continue traversing the hash table. */
9005 /* Update cur_loc and one-part auxiliary data, before new_var goes
9006 through variable_was_changed. */
9007 if (old_var
!= new_var
&& new_var
->onepart
)
9009 gcc_checking_assert (VAR_LOC_1PAUX (new_var
) == NULL
);
9010 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (old_var
);
9011 VAR_LOC_1PAUX (old_var
) = NULL
;
9012 new_var
->var_part
[0].cur_loc
= old_var
->var_part
[0].cur_loc
;
9014 if (variable_different_p (old_var
, new_var
))
9015 variable_was_changed (new_var
, NULL
);
9017 /* Continue traversing the hash table. */
9021 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9025 emit_notes_for_differences_2 (variable_def
**slot
, variable_table_type old_vars
)
9027 variable old_var
, new_var
;
9030 old_var
= old_vars
.find_with_hash (new_var
->dv
, dv_htab_hash (new_var
->dv
));
9034 for (i
= 0; i
< new_var
->n_var_parts
; i
++)
9035 new_var
->var_part
[i
].cur_loc
= NULL
;
9036 variable_was_changed (new_var
, NULL
);
9039 /* Continue traversing the hash table. */
9043 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9047 emit_notes_for_differences (rtx insn
, dataflow_set
*old_set
,
9048 dataflow_set
*new_set
)
9050 shared_hash_htab (old_set
->vars
)
9051 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9052 (shared_hash_htab (new_set
->vars
));
9053 shared_hash_htab (new_set
->vars
)
9054 .traverse
<variable_table_type
, emit_notes_for_differences_2
>
9055 (shared_hash_htab (old_set
->vars
));
9056 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, new_set
->vars
);
9059 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9062 next_non_note_insn_var_location (rtx insn
)
9066 insn
= NEXT_INSN (insn
);
9069 || NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
)
9076 /* Emit the notes for changes of location parts in the basic block BB. */
9079 emit_notes_in_bb (basic_block bb
, dataflow_set
*set
)
9082 micro_operation
*mo
;
9084 dataflow_set_clear (set
);
9085 dataflow_set_copy (set
, &VTI (bb
)->in
);
9087 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
9089 rtx insn
= mo
->insn
;
9090 rtx next_insn
= next_non_note_insn_var_location (insn
);
9095 dataflow_set_clear_at_call (set
);
9096 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_CALL_INSN
, set
->vars
);
9098 rtx arguments
= mo
->u
.loc
, *p
= &arguments
, note
;
9101 XEXP (XEXP (*p
, 0), 1)
9102 = vt_expand_loc (XEXP (XEXP (*p
, 0), 1),
9103 shared_hash_htab (set
->vars
));
9104 /* If expansion is successful, keep it in the list. */
9105 if (XEXP (XEXP (*p
, 0), 1))
9107 /* Otherwise, if the following item is data_value for it,
9109 else if (XEXP (*p
, 1)
9110 && REG_P (XEXP (XEXP (*p
, 0), 0))
9111 && MEM_P (XEXP (XEXP (XEXP (*p
, 1), 0), 0))
9112 && REG_P (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0), 0),
9114 && REGNO (XEXP (XEXP (*p
, 0), 0))
9115 == REGNO (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0),
9117 *p
= XEXP (XEXP (*p
, 1), 1);
9118 /* Just drop this item. */
9122 note
= emit_note_after (NOTE_INSN_CALL_ARG_LOCATION
, insn
);
9123 NOTE_VAR_LOCATION (note
) = arguments
;
9129 rtx loc
= mo
->u
.loc
;
9132 var_reg_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9134 var_mem_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9136 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9142 rtx loc
= mo
->u
.loc
;
9146 if (GET_CODE (loc
) == CONCAT
)
9148 val
= XEXP (loc
, 0);
9149 vloc
= XEXP (loc
, 1);
9157 var
= PAT_VAR_LOCATION_DECL (vloc
);
9159 clobber_variable_part (set
, NULL_RTX
,
9160 dv_from_decl (var
), 0, NULL_RTX
);
9163 if (VAL_NEEDS_RESOLUTION (loc
))
9164 val_resolve (set
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
9165 set_variable_part (set
, val
, dv_from_decl (var
), 0,
9166 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9169 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
9170 set_variable_part (set
, PAT_VAR_LOCATION_LOC (vloc
),
9171 dv_from_decl (var
), 0,
9172 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9175 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9181 rtx loc
= mo
->u
.loc
;
9182 rtx val
, vloc
, uloc
;
9184 vloc
= uloc
= XEXP (loc
, 1);
9185 val
= XEXP (loc
, 0);
9187 if (GET_CODE (val
) == CONCAT
)
9189 uloc
= XEXP (val
, 1);
9190 val
= XEXP (val
, 0);
9193 if (VAL_NEEDS_RESOLUTION (loc
))
9194 val_resolve (set
, val
, vloc
, insn
);
9196 val_store (set
, val
, uloc
, insn
, false);
9198 if (VAL_HOLDS_TRACK_EXPR (loc
))
9200 if (GET_CODE (uloc
) == REG
)
9201 var_reg_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9203 else if (GET_CODE (uloc
) == MEM
)
9204 var_mem_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9208 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9214 rtx loc
= mo
->u
.loc
;
9215 rtx val
, vloc
, uloc
;
9219 uloc
= XEXP (vloc
, 1);
9220 val
= XEXP (vloc
, 0);
9223 if (GET_CODE (uloc
) == SET
)
9225 dstv
= SET_DEST (uloc
);
9226 srcv
= SET_SRC (uloc
);
9234 if (GET_CODE (val
) == CONCAT
)
9236 dstv
= vloc
= XEXP (val
, 1);
9237 val
= XEXP (val
, 0);
9240 if (GET_CODE (vloc
) == SET
)
9242 srcv
= SET_SRC (vloc
);
9244 gcc_assert (val
!= srcv
);
9245 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
9247 dstv
= vloc
= SET_DEST (vloc
);
9249 if (VAL_NEEDS_RESOLUTION (loc
))
9250 val_resolve (set
, val
, srcv
, insn
);
9252 else if (VAL_NEEDS_RESOLUTION (loc
))
9254 gcc_assert (GET_CODE (uloc
) == SET
9255 && GET_CODE (SET_SRC (uloc
)) == REG
);
9256 val_resolve (set
, val
, SET_SRC (uloc
), insn
);
9259 if (VAL_HOLDS_TRACK_EXPR (loc
))
9261 if (VAL_EXPR_IS_CLOBBERED (loc
))
9264 var_reg_delete (set
, uloc
, true);
9265 else if (MEM_P (uloc
))
9267 gcc_assert (MEM_P (dstv
));
9268 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
9269 var_mem_delete (set
, dstv
, true);
9274 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
9275 rtx src
= NULL
, dst
= uloc
;
9276 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
9278 if (GET_CODE (uloc
) == SET
)
9280 src
= SET_SRC (uloc
);
9281 dst
= SET_DEST (uloc
);
9286 status
= find_src_status (set
, src
);
9288 src
= find_src_set_src (set
, src
);
9292 var_reg_delete_and_set (set
, dst
, !copied_p
,
9294 else if (MEM_P (dst
))
9296 gcc_assert (MEM_P (dstv
));
9297 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
9298 var_mem_delete_and_set (set
, dstv
, !copied_p
,
9303 else if (REG_P (uloc
))
9304 var_regno_delete (set
, REGNO (uloc
));
9305 else if (MEM_P (uloc
))
9307 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
9308 gcc_checking_assert (vloc
== dstv
);
9310 clobber_overlapping_mems (set
, vloc
);
9313 val_store (set
, val
, dstv
, insn
, true);
9315 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9322 rtx loc
= mo
->u
.loc
;
9325 if (GET_CODE (loc
) == SET
)
9327 set_src
= SET_SRC (loc
);
9328 loc
= SET_DEST (loc
);
9332 var_reg_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9335 var_mem_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9338 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9345 rtx loc
= mo
->u
.loc
;
9346 enum var_init_status src_status
;
9349 if (GET_CODE (loc
) == SET
)
9351 set_src
= SET_SRC (loc
);
9352 loc
= SET_DEST (loc
);
9355 src_status
= find_src_status (set
, set_src
);
9356 set_src
= find_src_set_src (set
, set_src
);
9359 var_reg_delete_and_set (set
, loc
, false, src_status
, set_src
);
9361 var_mem_delete_and_set (set
, loc
, false, src_status
, set_src
);
9363 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9370 rtx loc
= mo
->u
.loc
;
9373 var_reg_delete (set
, loc
, false);
9375 var_mem_delete (set
, loc
, false);
9377 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9383 rtx loc
= mo
->u
.loc
;
9386 var_reg_delete (set
, loc
, true);
9388 var_mem_delete (set
, loc
, true);
9390 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9396 set
->stack_adjust
+= mo
->u
.adjust
;
9402 /* Emit notes for the whole function. */
9405 vt_emit_notes (void)
9410 gcc_assert (!changed_variables
.elements ());
9412 /* Free memory occupied by the out hash tables, as they aren't used
9414 FOR_EACH_BB_FN (bb
, cfun
)
9415 dataflow_set_clear (&VTI (bb
)->out
);
9417 /* Enable emitting notes by functions (mainly by set_variable_part and
9418 delete_variable_part). */
9421 if (MAY_HAVE_DEBUG_INSNS
)
9423 dropped_values
.create (cselib_get_next_uid () * 2);
9424 loc_exp_dep_pool
= create_alloc_pool ("loc_exp_dep pool",
9425 sizeof (loc_exp_dep
), 64);
9428 dataflow_set_init (&cur
);
9430 FOR_EACH_BB_FN (bb
, cfun
)
9432 /* Emit the notes for changes of variable locations between two
9433 subsequent basic blocks. */
9434 emit_notes_for_differences (BB_HEAD (bb
), &cur
, &VTI (bb
)->in
);
9436 if (MAY_HAVE_DEBUG_INSNS
)
9437 local_get_addr_cache
= pointer_map_create ();
9439 /* Emit the notes for the changes in the basic block itself. */
9440 emit_notes_in_bb (bb
, &cur
);
9442 if (MAY_HAVE_DEBUG_INSNS
)
9443 pointer_map_destroy (local_get_addr_cache
);
9444 local_get_addr_cache
= NULL
;
9446 /* Free memory occupied by the in hash table, we won't need it
9448 dataflow_set_clear (&VTI (bb
)->in
);
9450 #ifdef ENABLE_CHECKING
9451 shared_hash_htab (cur
.vars
)
9452 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9453 (shared_hash_htab (empty_shared_hash
));
9455 dataflow_set_destroy (&cur
);
9457 if (MAY_HAVE_DEBUG_INSNS
)
9458 dropped_values
.dispose ();
9463 /* If there is a declaration and offset associated with register/memory RTL
9464 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9467 vt_get_decl_and_offset (rtx rtl
, tree
*declp
, HOST_WIDE_INT
*offsetp
)
9471 if (REG_ATTRS (rtl
))
9473 *declp
= REG_EXPR (rtl
);
9474 *offsetp
= REG_OFFSET (rtl
);
9478 else if (GET_CODE (rtl
) == PARALLEL
)
9480 tree decl
= NULL_TREE
;
9481 HOST_WIDE_INT offset
= MAX_VAR_PARTS
;
9482 int len
= XVECLEN (rtl
, 0), i
;
9484 for (i
= 0; i
< len
; i
++)
9486 rtx reg
= XEXP (XVECEXP (rtl
, 0, i
), 0);
9487 if (!REG_P (reg
) || !REG_ATTRS (reg
))
9490 decl
= REG_EXPR (reg
);
9491 if (REG_EXPR (reg
) != decl
)
9493 if (REG_OFFSET (reg
) < offset
)
9494 offset
= REG_OFFSET (reg
);
9504 else if (MEM_P (rtl
))
9506 if (MEM_ATTRS (rtl
))
9508 *declp
= MEM_EXPR (rtl
);
9509 *offsetp
= INT_MEM_OFFSET (rtl
);
9516 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9520 record_entry_value (cselib_val
*val
, rtx rtl
)
9522 rtx ev
= gen_rtx_ENTRY_VALUE (GET_MODE (rtl
));
9524 ENTRY_VALUE_EXP (ev
) = rtl
;
9526 cselib_add_permanent_equiv (val
, ev
, get_insns ());
9529 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9532 vt_add_function_parameter (tree parm
)
9534 rtx decl_rtl
= DECL_RTL_IF_SET (parm
);
9535 rtx incoming
= DECL_INCOMING_RTL (parm
);
9537 enum machine_mode mode
;
9538 HOST_WIDE_INT offset
;
9542 if (TREE_CODE (parm
) != PARM_DECL
)
9545 if (!decl_rtl
|| !incoming
)
9548 if (GET_MODE (decl_rtl
) == BLKmode
|| GET_MODE (incoming
) == BLKmode
)
9551 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9552 rewrite the incoming location of parameters passed on the stack
9553 into MEMs based on the argument pointer, so that incoming doesn't
9554 depend on a pseudo. */
9555 if (MEM_P (incoming
)
9556 && (XEXP (incoming
, 0) == crtl
->args
.internal_arg_pointer
9557 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
9558 && XEXP (XEXP (incoming
, 0), 0)
9559 == crtl
->args
.internal_arg_pointer
9560 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
9562 HOST_WIDE_INT off
= -FIRST_PARM_OFFSET (current_function_decl
);
9563 if (GET_CODE (XEXP (incoming
, 0)) == PLUS
)
9564 off
+= INTVAL (XEXP (XEXP (incoming
, 0), 1));
9566 = replace_equiv_address_nv (incoming
,
9567 plus_constant (Pmode
,
9568 arg_pointer_rtx
, off
));
9571 #ifdef HAVE_window_save
9572 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9573 If the target machine has an explicit window save instruction, the
9574 actual entry value is the corresponding OUTGOING_REGNO instead. */
9575 if (HAVE_window_save
&& !crtl
->uses_only_leaf_regs
)
9577 if (REG_P (incoming
)
9578 && HARD_REGISTER_P (incoming
)
9579 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
9582 p
.incoming
= incoming
;
9584 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
9585 OUTGOING_REGNO (REGNO (incoming
)), 0);
9586 p
.outgoing
= incoming
;
9587 vec_safe_push (windowed_parm_regs
, p
);
9589 else if (GET_CODE (incoming
) == PARALLEL
)
9592 = gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (XVECLEN (incoming
, 0)));
9595 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9597 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9600 reg
= gen_rtx_REG_offset (reg
, GET_MODE (reg
),
9601 OUTGOING_REGNO (REGNO (reg
)), 0);
9603 XVECEXP (outgoing
, 0, i
)
9604 = gen_rtx_EXPR_LIST (VOIDmode
, reg
,
9605 XEXP (XVECEXP (incoming
, 0, i
), 1));
9606 vec_safe_push (windowed_parm_regs
, p
);
9609 incoming
= outgoing
;
9611 else if (MEM_P (incoming
)
9612 && REG_P (XEXP (incoming
, 0))
9613 && HARD_REGISTER_P (XEXP (incoming
, 0)))
9615 rtx reg
= XEXP (incoming
, 0);
9616 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
9620 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
9622 vec_safe_push (windowed_parm_regs
, p
);
9623 incoming
= replace_equiv_address_nv (incoming
, reg
);
9629 if (!vt_get_decl_and_offset (incoming
, &decl
, &offset
))
9631 if (MEM_P (incoming
))
9633 /* This means argument is passed by invisible reference. */
9639 if (!vt_get_decl_and_offset (decl_rtl
, &decl
, &offset
))
9641 offset
+= byte_lowpart_offset (GET_MODE (incoming
),
9642 GET_MODE (decl_rtl
));
9651 /* If that DECL_RTL wasn't a pseudo that got spilled to
9652 memory, bail out. Otherwise, the spill slot sharing code
9653 will force the memory to reference spill_slot_decl (%sfp),
9654 so we don't match above. That's ok, the pseudo must have
9655 referenced the entire parameter, so just reset OFFSET. */
9656 if (decl
!= get_spill_slot_decl (false))
9661 if (!track_loc_p (incoming
, parm
, offset
, false, &mode
, &offset
))
9664 out
= &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
;
9666 dv
= dv_from_decl (parm
);
9668 if (target_for_debug_bind (parm
)
9669 /* We can't deal with these right now, because this kind of
9670 variable is single-part. ??? We could handle parallels
9671 that describe multiple locations for the same single
9672 value, but ATM we don't. */
9673 && GET_CODE (incoming
) != PARALLEL
)
9678 /* ??? We shouldn't ever hit this, but it may happen because
9679 arguments passed by invisible reference aren't dealt with
9680 above: incoming-rtl will have Pmode rather than the
9681 expected mode for the type. */
9685 lowpart
= var_lowpart (mode
, incoming
);
9689 val
= cselib_lookup_from_insn (lowpart
, mode
, true,
9690 VOIDmode
, get_insns ());
9692 /* ??? Float-typed values in memory are not handled by
9696 preserve_value (val
);
9697 set_variable_part (out
, val
->val_rtx
, dv
, offset
,
9698 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9699 dv
= dv_from_value (val
->val_rtx
);
9702 if (MEM_P (incoming
))
9704 val
= cselib_lookup_from_insn (XEXP (incoming
, 0), mode
, true,
9705 VOIDmode
, get_insns ());
9708 preserve_value (val
);
9709 incoming
= replace_equiv_address_nv (incoming
, val
->val_rtx
);
9714 if (REG_P (incoming
))
9716 incoming
= var_lowpart (mode
, incoming
);
9717 gcc_assert (REGNO (incoming
) < FIRST_PSEUDO_REGISTER
);
9718 attrs_list_insert (&out
->regs
[REGNO (incoming
)], dv
, offset
,
9720 set_variable_part (out
, incoming
, dv
, offset
,
9721 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9722 if (dv_is_value_p (dv
))
9724 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv
)), incoming
);
9725 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
9726 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm
))))
9728 enum machine_mode indmode
9729 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm
)));
9730 rtx mem
= gen_rtx_MEM (indmode
, incoming
);
9731 cselib_val
*val
= cselib_lookup_from_insn (mem
, indmode
, true,
9736 preserve_value (val
);
9737 record_entry_value (val
, mem
);
9738 set_variable_part (out
, mem
, dv_from_value (val
->val_rtx
), 0,
9739 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9744 else if (GET_CODE (incoming
) == PARALLEL
&& !dv_onepart_p (dv
))
9748 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9750 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9751 offset
= REG_OFFSET (reg
);
9752 gcc_assert (REGNO (reg
) < FIRST_PSEUDO_REGISTER
);
9753 attrs_list_insert (&out
->regs
[REGNO (reg
)], dv
, offset
, reg
);
9754 set_variable_part (out
, reg
, dv
, offset
,
9755 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9758 else if (MEM_P (incoming
))
9760 incoming
= var_lowpart (mode
, incoming
);
9761 set_variable_part (out
, incoming
, dv
, offset
,
9762 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9766 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9769 vt_add_function_parameters (void)
9773 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9774 parm
; parm
= DECL_CHAIN (parm
))
9775 vt_add_function_parameter (parm
);
9777 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl
)))
9779 tree vexpr
= DECL_VALUE_EXPR (DECL_RESULT (current_function_decl
));
9781 if (TREE_CODE (vexpr
) == INDIRECT_REF
)
9782 vexpr
= TREE_OPERAND (vexpr
, 0);
9784 if (TREE_CODE (vexpr
) == PARM_DECL
9785 && DECL_ARTIFICIAL (vexpr
)
9786 && !DECL_IGNORED_P (vexpr
)
9787 && DECL_NAMELESS (vexpr
))
9788 vt_add_function_parameter (vexpr
);
9792 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9793 ensure it isn't flushed during cselib_reset_table.
9794 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9795 has been eliminated. */
9798 vt_init_cfa_base (void)
9802 #ifdef FRAME_POINTER_CFA_OFFSET
9803 cfa_base_rtx
= frame_pointer_rtx
;
9804 cfa_base_offset
= -FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9806 cfa_base_rtx
= arg_pointer_rtx
;
9807 cfa_base_offset
= -ARG_POINTER_CFA_OFFSET (current_function_decl
);
9809 if (cfa_base_rtx
== hard_frame_pointer_rtx
9810 || !fixed_regs
[REGNO (cfa_base_rtx
)])
9812 cfa_base_rtx
= NULL_RTX
;
9815 if (!MAY_HAVE_DEBUG_INSNS
)
9818 /* Tell alias analysis that cfa_base_rtx should share
9819 find_base_term value with stack pointer or hard frame pointer. */
9820 if (!frame_pointer_needed
)
9821 vt_equate_reg_base_value (cfa_base_rtx
, stack_pointer_rtx
);
9822 else if (!crtl
->stack_realign_tried
)
9823 vt_equate_reg_base_value (cfa_base_rtx
, hard_frame_pointer_rtx
);
9825 val
= cselib_lookup_from_insn (cfa_base_rtx
, GET_MODE (cfa_base_rtx
), 1,
9826 VOIDmode
, get_insns ());
9827 preserve_value (val
);
9828 cselib_preserve_cfa_base_value (val
, REGNO (cfa_base_rtx
));
9831 /* Allocate and initialize the data structures for variable tracking
9832 and parse the RTL to get the micro operations. */
9835 vt_initialize (void)
9838 HOST_WIDE_INT fp_cfa_offset
= -1;
9840 alloc_aux_for_blocks (sizeof (struct variable_tracking_info_def
));
9842 attrs_pool
= create_alloc_pool ("attrs_def pool",
9843 sizeof (struct attrs_def
), 1024);
9844 var_pool
= create_alloc_pool ("variable_def pool",
9845 sizeof (struct variable_def
)
9846 + (MAX_VAR_PARTS
- 1)
9847 * sizeof (((variable
)NULL
)->var_part
[0]), 64);
9848 loc_chain_pool
= create_alloc_pool ("location_chain_def pool",
9849 sizeof (struct location_chain_def
),
9851 shared_hash_pool
= create_alloc_pool ("shared_hash_def pool",
9852 sizeof (struct shared_hash_def
), 256);
9853 empty_shared_hash
= (shared_hash
) pool_alloc (shared_hash_pool
);
9854 empty_shared_hash
->refcount
= 1;
9855 empty_shared_hash
->htab
.create (1);
9856 changed_variables
.create (10);
9858 /* Init the IN and OUT sets. */
9859 FOR_ALL_BB_FN (bb
, cfun
)
9861 VTI (bb
)->visited
= false;
9862 VTI (bb
)->flooded
= false;
9863 dataflow_set_init (&VTI (bb
)->in
);
9864 dataflow_set_init (&VTI (bb
)->out
);
9865 VTI (bb
)->permp
= NULL
;
9868 if (MAY_HAVE_DEBUG_INSNS
)
9870 cselib_init (CSELIB_RECORD_MEMORY
| CSELIB_PRESERVE_CONSTANTS
);
9871 scratch_regs
= BITMAP_ALLOC (NULL
);
9872 valvar_pool
= create_alloc_pool ("small variable_def pool",
9873 sizeof (struct variable_def
), 256);
9874 preserved_values
.create (256);
9875 global_get_addr_cache
= pointer_map_create ();
9879 scratch_regs
= NULL
;
9881 global_get_addr_cache
= NULL
;
9884 if (MAY_HAVE_DEBUG_INSNS
)
9890 #ifdef FRAME_POINTER_CFA_OFFSET
9891 reg
= frame_pointer_rtx
;
9892 ofst
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9894 reg
= arg_pointer_rtx
;
9895 ofst
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9898 ofst
-= INCOMING_FRAME_SP_OFFSET
;
9900 val
= cselib_lookup_from_insn (reg
, GET_MODE (reg
), 1,
9901 VOIDmode
, get_insns ());
9902 preserve_value (val
);
9903 cselib_preserve_cfa_base_value (val
, REGNO (reg
));
9904 expr
= plus_constant (GET_MODE (stack_pointer_rtx
),
9905 stack_pointer_rtx
, -ofst
);
9906 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9910 val
= cselib_lookup_from_insn (stack_pointer_rtx
,
9911 GET_MODE (stack_pointer_rtx
), 1,
9912 VOIDmode
, get_insns ());
9913 preserve_value (val
);
9914 expr
= plus_constant (GET_MODE (reg
), reg
, ofst
);
9915 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9919 /* In order to factor out the adjustments made to the stack pointer or to
9920 the hard frame pointer and thus be able to use DW_OP_fbreg operations
9921 instead of individual location lists, we're going to rewrite MEMs based
9922 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
9923 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
9924 resp. arg_pointer_rtx. We can do this either when there is no frame
9925 pointer in the function and stack adjustments are consistent for all
9926 basic blocks or when there is a frame pointer and no stack realignment.
9927 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
9928 has been eliminated. */
9929 if (!frame_pointer_needed
)
9933 if (!vt_stack_adjustments ())
9936 #ifdef FRAME_POINTER_CFA_OFFSET
9937 reg
= frame_pointer_rtx
;
9939 reg
= arg_pointer_rtx
;
9941 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9944 if (GET_CODE (elim
) == PLUS
)
9945 elim
= XEXP (elim
, 0);
9946 if (elim
== stack_pointer_rtx
)
9947 vt_init_cfa_base ();
9950 else if (!crtl
->stack_realign_tried
)
9954 #ifdef FRAME_POINTER_CFA_OFFSET
9955 reg
= frame_pointer_rtx
;
9956 fp_cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9958 reg
= arg_pointer_rtx
;
9959 fp_cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9961 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9964 if (GET_CODE (elim
) == PLUS
)
9966 fp_cfa_offset
-= INTVAL (XEXP (elim
, 1));
9967 elim
= XEXP (elim
, 0);
9969 if (elim
!= hard_frame_pointer_rtx
)
9976 /* If the stack is realigned and a DRAP register is used, we're going to
9977 rewrite MEMs based on it representing incoming locations of parameters
9978 passed on the stack into MEMs based on the argument pointer. Although
9979 we aren't going to rewrite other MEMs, we still need to initialize the
9980 virtual CFA pointer in order to ensure that the argument pointer will
9981 be seen as a constant throughout the function.
9983 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
9984 else if (stack_realign_drap
)
9988 #ifdef FRAME_POINTER_CFA_OFFSET
9989 reg
= frame_pointer_rtx
;
9991 reg
= arg_pointer_rtx
;
9993 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9996 if (GET_CODE (elim
) == PLUS
)
9997 elim
= XEXP (elim
, 0);
9998 if (elim
== hard_frame_pointer_rtx
)
9999 vt_init_cfa_base ();
10003 hard_frame_pointer_adjustment
= -1;
10005 vt_add_function_parameters ();
10007 FOR_EACH_BB_FN (bb
, cfun
)
10010 HOST_WIDE_INT pre
, post
= 0;
10011 basic_block first_bb
, last_bb
;
10013 if (MAY_HAVE_DEBUG_INSNS
)
10015 cselib_record_sets_hook
= add_with_sets
;
10016 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10017 fprintf (dump_file
, "first value: %i\n",
10018 cselib_get_next_uid ());
10025 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
10026 || ! single_pred_p (bb
->next_bb
))
10028 e
= find_edge (bb
, bb
->next_bb
);
10029 if (! e
|| (e
->flags
& EDGE_FALLTHRU
) == 0)
10035 /* Add the micro-operations to the vector. */
10036 FOR_BB_BETWEEN (bb
, first_bb
, last_bb
->next_bb
, next_bb
)
10038 HOST_WIDE_INT offset
= VTI (bb
)->out
.stack_adjust
;
10039 VTI (bb
)->out
.stack_adjust
= VTI (bb
)->in
.stack_adjust
;
10040 for (insn
= BB_HEAD (bb
); insn
!= NEXT_INSN (BB_END (bb
));
10041 insn
= NEXT_INSN (insn
))
10045 if (!frame_pointer_needed
)
10047 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
10050 micro_operation mo
;
10051 mo
.type
= MO_ADJUST
;
10054 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10055 log_op_type (PATTERN (insn
), bb
, insn
,
10056 MO_ADJUST
, dump_file
);
10057 VTI (bb
)->mos
.safe_push (mo
);
10058 VTI (bb
)->out
.stack_adjust
+= pre
;
10062 cselib_hook_called
= false;
10063 adjust_insn (bb
, insn
);
10064 if (MAY_HAVE_DEBUG_INSNS
)
10067 prepare_call_arguments (bb
, insn
);
10068 cselib_process_insn (insn
);
10069 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10071 print_rtl_single (dump_file
, insn
);
10072 dump_cselib_table (dump_file
);
10075 if (!cselib_hook_called
)
10076 add_with_sets (insn
, 0, 0);
10077 cancel_changes (0);
10079 if (!frame_pointer_needed
&& post
)
10081 micro_operation mo
;
10082 mo
.type
= MO_ADJUST
;
10083 mo
.u
.adjust
= post
;
10085 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10086 log_op_type (PATTERN (insn
), bb
, insn
,
10087 MO_ADJUST
, dump_file
);
10088 VTI (bb
)->mos
.safe_push (mo
);
10089 VTI (bb
)->out
.stack_adjust
+= post
;
10092 if (fp_cfa_offset
!= -1
10093 && hard_frame_pointer_adjustment
== -1
10094 && fp_setter_insn (insn
))
10096 vt_init_cfa_base ();
10097 hard_frame_pointer_adjustment
= fp_cfa_offset
;
10098 /* Disassociate sp from fp now. */
10099 if (MAY_HAVE_DEBUG_INSNS
)
10102 cselib_invalidate_rtx (stack_pointer_rtx
);
10103 v
= cselib_lookup (stack_pointer_rtx
, Pmode
, 1,
10105 if (v
&& !cselib_preserved_value_p (v
))
10107 cselib_set_value_sp_based (v
);
10108 preserve_value (v
);
10114 gcc_assert (offset
== VTI (bb
)->out
.stack_adjust
);
10119 if (MAY_HAVE_DEBUG_INSNS
)
10121 cselib_preserve_only_values ();
10122 cselib_reset_table (cselib_get_next_uid ());
10123 cselib_record_sets_hook
= NULL
;
10127 hard_frame_pointer_adjustment
= -1;
10128 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flooded
= true;
10129 cfa_base_rtx
= NULL_RTX
;
10133 /* This is *not* reset after each function. It gives each
10134 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10135 a unique label number. */
10137 static int debug_label_num
= 1;
10139 /* Get rid of all debug insns from the insn stream. */
10142 delete_debug_insns (void)
10147 if (!MAY_HAVE_DEBUG_INSNS
)
10150 FOR_EACH_BB_FN (bb
, cfun
)
10152 FOR_BB_INSNS_SAFE (bb
, insn
, next
)
10153 if (DEBUG_INSN_P (insn
))
10155 tree decl
= INSN_VAR_LOCATION_DECL (insn
);
10156 if (TREE_CODE (decl
) == LABEL_DECL
10157 && DECL_NAME (decl
)
10158 && !DECL_RTL_SET_P (decl
))
10160 PUT_CODE (insn
, NOTE
);
10161 NOTE_KIND (insn
) = NOTE_INSN_DELETED_DEBUG_LABEL
;
10162 NOTE_DELETED_LABEL_NAME (insn
)
10163 = IDENTIFIER_POINTER (DECL_NAME (decl
));
10164 SET_DECL_RTL (decl
, insn
);
10165 CODE_LABEL_NUMBER (insn
) = debug_label_num
++;
10168 delete_insn (insn
);
10173 /* Run a fast, BB-local only version of var tracking, to take care of
10174 information that we don't do global analysis on, such that not all
10175 information is lost. If SKIPPED holds, we're skipping the global
10176 pass entirely, so we should try to use information it would have
10177 handled as well.. */
10180 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED
)
10182 /* ??? Just skip it all for now. */
10183 delete_debug_insns ();
10186 /* Free the data structures needed for variable tracking. */
10193 FOR_EACH_BB_FN (bb
, cfun
)
10195 VTI (bb
)->mos
.release ();
10198 FOR_ALL_BB_FN (bb
, cfun
)
10200 dataflow_set_destroy (&VTI (bb
)->in
);
10201 dataflow_set_destroy (&VTI (bb
)->out
);
10202 if (VTI (bb
)->permp
)
10204 dataflow_set_destroy (VTI (bb
)->permp
);
10205 XDELETE (VTI (bb
)->permp
);
10208 free_aux_for_blocks ();
10209 empty_shared_hash
->htab
.dispose ();
10210 changed_variables
.dispose ();
10211 free_alloc_pool (attrs_pool
);
10212 free_alloc_pool (var_pool
);
10213 free_alloc_pool (loc_chain_pool
);
10214 free_alloc_pool (shared_hash_pool
);
10216 if (MAY_HAVE_DEBUG_INSNS
)
10218 if (global_get_addr_cache
)
10219 pointer_map_destroy (global_get_addr_cache
);
10220 global_get_addr_cache
= NULL
;
10221 if (loc_exp_dep_pool
)
10222 free_alloc_pool (loc_exp_dep_pool
);
10223 loc_exp_dep_pool
= NULL
;
10224 free_alloc_pool (valvar_pool
);
10225 preserved_values
.release ();
10227 BITMAP_FREE (scratch_regs
);
10228 scratch_regs
= NULL
;
10231 #ifdef HAVE_window_save
10232 vec_free (windowed_parm_regs
);
10236 XDELETEVEC (vui_vec
);
10241 /* The entry point to variable tracking pass. */
10243 static inline unsigned int
10244 variable_tracking_main_1 (void)
10248 if (flag_var_tracking_assignments
< 0)
10250 delete_debug_insns ();
10254 if (n_basic_blocks_for_fn (cfun
) > 500 &&
10255 n_edges_for_fn (cfun
) / n_basic_blocks_for_fn (cfun
) >= 20)
10257 vt_debug_insns_local (true);
10261 mark_dfs_back_edges ();
10262 if (!vt_initialize ())
10265 vt_debug_insns_local (true);
10269 success
= vt_find_locations ();
10271 if (!success
&& flag_var_tracking_assignments
> 0)
10275 delete_debug_insns ();
10277 /* This is later restored by our caller. */
10278 flag_var_tracking_assignments
= 0;
10280 success
= vt_initialize ();
10281 gcc_assert (success
);
10283 success
= vt_find_locations ();
10289 vt_debug_insns_local (false);
10293 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10295 dump_dataflow_sets ();
10296 dump_reg_info (dump_file
);
10297 dump_flow_info (dump_file
, dump_flags
);
10300 timevar_push (TV_VAR_TRACKING_EMIT
);
10302 timevar_pop (TV_VAR_TRACKING_EMIT
);
10305 vt_debug_insns_local (false);
10310 variable_tracking_main (void)
10313 int save
= flag_var_tracking_assignments
;
10315 ret
= variable_tracking_main_1 ();
10317 flag_var_tracking_assignments
= save
;
10323 gate_handle_var_tracking (void)
10325 return (flag_var_tracking
&& !targetm
.delay_vartrack
);
10332 const pass_data pass_data_variable_tracking
=
10334 RTL_PASS
, /* type */
10335 "vartrack", /* name */
10336 OPTGROUP_NONE
, /* optinfo_flags */
10337 true, /* has_gate */
10338 true, /* has_execute */
10339 TV_VAR_TRACKING
, /* tv_id */
10340 0, /* properties_required */
10341 0, /* properties_provided */
10342 0, /* properties_destroyed */
10343 0, /* todo_flags_start */
10344 ( TODO_verify_rtl_sharing
| TODO_verify_flow
), /* todo_flags_finish */
10347 class pass_variable_tracking
: public rtl_opt_pass
10350 pass_variable_tracking (gcc::context
*ctxt
)
10351 : rtl_opt_pass (pass_data_variable_tracking
, ctxt
)
10354 /* opt_pass methods: */
10355 bool gate () { return gate_handle_var_tracking (); }
10356 unsigned int execute () { return variable_tracking_main (); }
10358 }; // class pass_variable_tracking
10360 } // anon namespace
10363 make_pass_variable_tracking (gcc::context
*ctxt
)
10365 return new pass_variable_tracking (ctxt
);