1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2013 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 /* We cannot track values for multiple-part variables, so we track only
5934 locations for tracked parameters passed either by invisible reference
5935 or directly in multiple locations. */
5939 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5940 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5941 && TREE_CODE (TREE_TYPE (REG_EXPR (loc
))) != UNION_TYPE
5942 && ((MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5943 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) != arg_pointer_rtx
)
5944 || (GET_CODE (DECL_INCOMING_RTL (REG_EXPR (loc
))) == PARALLEL
5945 && XVECLEN (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) > 1)))
5946 goto log_and_return
;
5948 v
= find_use_val (oloc
, mode
, cui
);
5951 goto log_and_return
;
5953 resolve
= preserve
= !cselib_preserved_value_p (v
);
5955 if (loc
== stack_pointer_rtx
5956 && hard_frame_pointer_adjustment
!= -1
5958 cselib_set_value_sp_based (v
);
5960 nloc
= replace_expr_with_values (oloc
);
5964 if (GET_CODE (PATTERN (cui
->insn
)) == COND_EXEC
)
5966 cselib_val
*oval
= cselib_lookup (oloc
, GET_MODE (oloc
), 0, VOIDmode
);
5968 gcc_assert (oval
!= v
);
5969 gcc_assert (REG_P (oloc
) || MEM_P (oloc
));
5971 if (oval
&& !cselib_preserved_value_p (oval
))
5973 micro_operation moa
;
5975 preserve_value (oval
);
5977 moa
.type
= MO_VAL_USE
;
5978 moa
.u
.loc
= gen_rtx_CONCAT (mode
, oval
->val_rtx
, oloc
);
5979 VAL_NEEDS_RESOLUTION (moa
.u
.loc
) = 1;
5980 moa
.insn
= cui
->insn
;
5982 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5983 log_op_type (moa
.u
.loc
, cui
->bb
, cui
->insn
,
5984 moa
.type
, dump_file
);
5985 VTI (bb
)->mos
.safe_push (moa
);
5990 else if (resolve
&& GET_CODE (mo
.u
.loc
) == SET
)
5992 if (REG_P (SET_SRC (expr
)) || MEM_P (SET_SRC (expr
)))
5993 nloc
= replace_expr_with_values (SET_SRC (expr
));
5997 /* Avoid the mode mismatch between oexpr and expr. */
5998 if (!nloc
&& mode
!= mode2
)
6000 nloc
= SET_SRC (expr
);
6001 gcc_assert (oloc
== SET_DEST (expr
));
6004 if (nloc
&& nloc
!= SET_SRC (mo
.u
.loc
))
6005 oloc
= gen_rtx_SET (GET_MODE (mo
.u
.loc
), oloc
, nloc
);
6008 if (oloc
== SET_DEST (mo
.u
.loc
))
6009 /* No point in duplicating. */
6011 if (!REG_P (SET_SRC (mo
.u
.loc
)))
6017 if (GET_CODE (mo
.u
.loc
) == SET
6018 && oloc
== SET_DEST (mo
.u
.loc
))
6019 /* No point in duplicating. */
6025 loc
= gen_rtx_CONCAT (mode
, v
->val_rtx
, oloc
);
6027 if (mo
.u
.loc
!= oloc
)
6028 loc
= gen_rtx_CONCAT (GET_MODE (mo
.u
.loc
), loc
, mo
.u
.loc
);
6030 /* The loc of a MO_VAL_SET may have various forms:
6032 (concat val dst): dst now holds val
6034 (concat val (set dst src)): dst now holds val, copied from src
6036 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6037 after replacing mems and non-top-level regs with values.
6039 (concat (concat val dstv) (set dst src)): dst now holds val,
6040 copied from src. dstv is a value-based representation of dst, if
6041 it differs from dst. If resolution is needed, src is a REG, and
6042 its mode is the same as that of val.
6044 (concat (concat val (set dstv srcv)) (set dst src)): src
6045 copied to dst, holding val. dstv and srcv are value-based
6046 representations of dst and src, respectively.
6050 if (GET_CODE (PATTERN (cui
->insn
)) != COND_EXEC
)
6051 reverse_op (v
->val_rtx
, expr
, cui
->insn
);
6056 VAL_HOLDS_TRACK_EXPR (loc
) = 1;
6059 VAL_NEEDS_RESOLUTION (loc
) = resolve
;
6062 if (mo
.type
== MO_CLOBBER
)
6063 VAL_EXPR_IS_CLOBBERED (loc
) = 1;
6064 if (mo
.type
== MO_COPY
)
6065 VAL_EXPR_IS_COPIED (loc
) = 1;
6067 mo
.type
= MO_VAL_SET
;
6070 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6071 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
6072 VTI (bb
)->mos
.safe_push (mo
);
6075 /* Arguments to the call. */
6076 static rtx call_arguments
;
6078 /* Compute call_arguments. */
6081 prepare_call_arguments (basic_block bb
, rtx insn
)
6084 rtx prev
, cur
, next
;
6085 rtx this_arg
= NULL_RTX
;
6086 tree type
= NULL_TREE
, t
, fndecl
= NULL_TREE
;
6087 tree obj_type_ref
= NULL_TREE
;
6088 CUMULATIVE_ARGS args_so_far_v
;
6089 cumulative_args_t args_so_far
;
6091 memset (&args_so_far_v
, 0, sizeof (args_so_far_v
));
6092 args_so_far
= pack_cumulative_args (&args_so_far_v
);
6093 call
= get_call_rtx_from (insn
);
6096 if (GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
6098 rtx symbol
= XEXP (XEXP (call
, 0), 0);
6099 if (SYMBOL_REF_DECL (symbol
))
6100 fndecl
= SYMBOL_REF_DECL (symbol
);
6102 if (fndecl
== NULL_TREE
)
6103 fndecl
= MEM_EXPR (XEXP (call
, 0));
6105 && TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
6106 && TREE_CODE (TREE_TYPE (fndecl
)) != METHOD_TYPE
)
6108 if (fndecl
&& TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6109 type
= TREE_TYPE (fndecl
);
6110 if (fndecl
&& TREE_CODE (fndecl
) != FUNCTION_DECL
)
6112 if (TREE_CODE (fndecl
) == INDIRECT_REF
6113 && TREE_CODE (TREE_OPERAND (fndecl
, 0)) == OBJ_TYPE_REF
)
6114 obj_type_ref
= TREE_OPERAND (fndecl
, 0);
6119 for (t
= TYPE_ARG_TYPES (type
); t
&& t
!= void_list_node
;
6121 if (TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
6122 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t
))))
6124 if ((t
== NULL
|| t
== void_list_node
) && obj_type_ref
== NULL_TREE
)
6128 int nargs ATTRIBUTE_UNUSED
= list_length (TYPE_ARG_TYPES (type
));
6129 link
= CALL_INSN_FUNCTION_USAGE (insn
);
6130 #ifndef PCC_STATIC_STRUCT_RETURN
6131 if (aggregate_value_p (TREE_TYPE (type
), type
)
6132 && targetm
.calls
.struct_value_rtx (type
, 0) == 0)
6134 tree struct_addr
= build_pointer_type (TREE_TYPE (type
));
6135 enum machine_mode mode
= TYPE_MODE (struct_addr
);
6137 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6139 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6141 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6143 if (reg
== NULL_RTX
)
6145 for (; link
; link
= XEXP (link
, 1))
6146 if (GET_CODE (XEXP (link
, 0)) == USE
6147 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6149 link
= XEXP (link
, 1);
6156 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6158 if (obj_type_ref
&& TYPE_ARG_TYPES (type
) != void_list_node
)
6160 enum machine_mode mode
;
6161 t
= TYPE_ARG_TYPES (type
);
6162 mode
= TYPE_MODE (TREE_VALUE (t
));
6163 this_arg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6164 TREE_VALUE (t
), true);
6165 if (this_arg
&& !REG_P (this_arg
))
6166 this_arg
= NULL_RTX
;
6167 else if (this_arg
== NULL_RTX
)
6169 for (; link
; link
= XEXP (link
, 1))
6170 if (GET_CODE (XEXP (link
, 0)) == USE
6171 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6173 this_arg
= XEXP (XEXP (link
, 0), 0);
6181 t
= type
? TYPE_ARG_TYPES (type
) : NULL_TREE
;
6183 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
6184 if (GET_CODE (XEXP (link
, 0)) == USE
)
6186 rtx item
= NULL_RTX
;
6187 x
= XEXP (XEXP (link
, 0), 0);
6188 if (GET_MODE (link
) == VOIDmode
6189 || GET_MODE (link
) == BLKmode
6190 || (GET_MODE (link
) != GET_MODE (x
)
6191 && (GET_MODE_CLASS (GET_MODE (link
)) != MODE_INT
6192 || GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
)))
6193 /* Can't do anything for these, if the original type mode
6194 isn't known or can't be converted. */;
6197 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6198 if (val
&& cselib_preserved_value_p (val
))
6199 item
= val
->val_rtx
;
6200 else if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_INT
)
6202 enum machine_mode mode
= GET_MODE (x
);
6204 while ((mode
= GET_MODE_WIDER_MODE (mode
)) != VOIDmode
6205 && GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
6207 rtx reg
= simplify_subreg (mode
, x
, GET_MODE (x
), 0);
6209 if (reg
== NULL_RTX
|| !REG_P (reg
))
6211 val
= cselib_lookup (reg
, mode
, 0, VOIDmode
);
6212 if (val
&& cselib_preserved_value_p (val
))
6214 item
= val
->val_rtx
;
6225 if (!frame_pointer_needed
)
6227 struct adjust_mem_data amd
;
6228 amd
.mem_mode
= VOIDmode
;
6229 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
6230 amd
.side_effects
= NULL_RTX
;
6232 mem
= simplify_replace_fn_rtx (mem
, NULL_RTX
, adjust_mems
,
6234 gcc_assert (amd
.side_effects
== NULL_RTX
);
6236 val
= cselib_lookup (mem
, GET_MODE (mem
), 0, VOIDmode
);
6237 if (val
&& cselib_preserved_value_p (val
))
6238 item
= val
->val_rtx
;
6239 else if (GET_MODE_CLASS (GET_MODE (mem
)) != MODE_INT
)
6241 /* For non-integer stack argument see also if they weren't
6242 initialized by integers. */
6243 enum machine_mode imode
= int_mode_for_mode (GET_MODE (mem
));
6244 if (imode
!= GET_MODE (mem
) && imode
!= BLKmode
)
6246 val
= cselib_lookup (adjust_address_nv (mem
, imode
, 0),
6247 imode
, 0, VOIDmode
);
6248 if (val
&& cselib_preserved_value_p (val
))
6249 item
= lowpart_subreg (GET_MODE (x
), val
->val_rtx
,
6257 if (GET_MODE (item
) != GET_MODE (link
))
6258 item
= lowpart_subreg (GET_MODE (link
), item
, GET_MODE (item
));
6259 if (GET_MODE (x2
) != GET_MODE (link
))
6260 x2
= lowpart_subreg (GET_MODE (link
), x2
, GET_MODE (x2
));
6261 item
= gen_rtx_CONCAT (GET_MODE (link
), x2
, item
);
6263 = gen_rtx_EXPR_LIST (VOIDmode
, item
, call_arguments
);
6265 if (t
&& t
!= void_list_node
)
6267 tree argtype
= TREE_VALUE (t
);
6268 enum machine_mode mode
= TYPE_MODE (argtype
);
6270 if (pass_by_reference (&args_so_far_v
, mode
, argtype
, true))
6272 argtype
= build_pointer_type (argtype
);
6273 mode
= TYPE_MODE (argtype
);
6275 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6277 if (TREE_CODE (argtype
) == REFERENCE_TYPE
6278 && INTEGRAL_TYPE_P (TREE_TYPE (argtype
))
6281 && GET_MODE (reg
) == mode
6282 && GET_MODE_CLASS (mode
) == MODE_INT
6284 && REGNO (x
) == REGNO (reg
)
6285 && GET_MODE (x
) == mode
6288 enum machine_mode indmode
6289 = TYPE_MODE (TREE_TYPE (argtype
));
6290 rtx mem
= gen_rtx_MEM (indmode
, x
);
6291 cselib_val
*val
= cselib_lookup (mem
, indmode
, 0, VOIDmode
);
6292 if (val
&& cselib_preserved_value_p (val
))
6294 item
= gen_rtx_CONCAT (indmode
, mem
, val
->val_rtx
);
6295 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6300 struct elt_loc_list
*l
;
6303 /* Try harder, when passing address of a constant
6304 pool integer it can be easily read back. */
6305 item
= XEXP (item
, 1);
6306 if (GET_CODE (item
) == SUBREG
)
6307 item
= SUBREG_REG (item
);
6308 gcc_assert (GET_CODE (item
) == VALUE
);
6309 val
= CSELIB_VAL_PTR (item
);
6310 for (l
= val
->locs
; l
; l
= l
->next
)
6311 if (GET_CODE (l
->loc
) == SYMBOL_REF
6312 && TREE_CONSTANT_POOL_ADDRESS_P (l
->loc
)
6313 && SYMBOL_REF_DECL (l
->loc
)
6314 && DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
)))
6316 initial
= DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
));
6317 if (tree_fits_shwi_p (initial
))
6319 item
= GEN_INT (tree_to_shwi (initial
));
6320 item
= gen_rtx_CONCAT (indmode
, mem
, item
);
6322 = gen_rtx_EXPR_LIST (VOIDmode
, item
,
6329 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6335 /* Add debug arguments. */
6337 && TREE_CODE (fndecl
) == FUNCTION_DECL
6338 && DECL_HAS_DEBUG_ARGS_P (fndecl
))
6340 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (fndecl
);
6345 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, ¶m
); ix
+= 2)
6348 tree dtemp
= (**debug_args
)[ix
+ 1];
6349 enum machine_mode mode
= DECL_MODE (dtemp
);
6350 item
= gen_rtx_DEBUG_PARAMETER_REF (mode
, param
);
6351 item
= gen_rtx_CONCAT (mode
, item
, DECL_RTL_KNOWN_SET (dtemp
));
6352 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6358 /* Reverse call_arguments chain. */
6360 for (cur
= call_arguments
; cur
; cur
= next
)
6362 next
= XEXP (cur
, 1);
6363 XEXP (cur
, 1) = prev
;
6366 call_arguments
= prev
;
6368 x
= get_call_rtx_from (insn
);
6371 x
= XEXP (XEXP (x
, 0), 0);
6372 if (GET_CODE (x
) == SYMBOL_REF
)
6373 /* Don't record anything. */;
6374 else if (CONSTANT_P (x
))
6376 x
= gen_rtx_CONCAT (GET_MODE (x
) == VOIDmode
? Pmode
: GET_MODE (x
),
6379 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6383 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6384 if (val
&& cselib_preserved_value_p (val
))
6386 x
= gen_rtx_CONCAT (GET_MODE (x
), pc_rtx
, val
->val_rtx
);
6388 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6394 enum machine_mode mode
6395 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref
)));
6396 rtx clobbered
= gen_rtx_MEM (mode
, this_arg
);
6398 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref
));
6400 clobbered
= plus_constant (mode
, clobbered
,
6401 token
* GET_MODE_SIZE (mode
));
6402 clobbered
= gen_rtx_MEM (mode
, clobbered
);
6403 x
= gen_rtx_CONCAT (mode
, gen_rtx_CLOBBER (VOIDmode
, pc_rtx
), clobbered
);
6405 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6409 /* Callback for cselib_record_sets_hook, that records as micro
6410 operations uses and stores in an insn after cselib_record_sets has
6411 analyzed the sets in an insn, but before it modifies the stored
6412 values in the internal tables, unless cselib_record_sets doesn't
6413 call it directly (perhaps because we're not doing cselib in the
6414 first place, in which case sets and n_sets will be 0). */
6417 add_with_sets (rtx insn
, struct cselib_set
*sets
, int n_sets
)
6419 basic_block bb
= BLOCK_FOR_INSN (insn
);
6421 struct count_use_info cui
;
6422 micro_operation
*mos
;
6424 cselib_hook_called
= true;
6429 cui
.n_sets
= n_sets
;
6431 n1
= VTI (bb
)->mos
.length ();
6432 cui
.store_p
= false;
6433 note_uses (&PATTERN (insn
), add_uses_1
, &cui
);
6434 n2
= VTI (bb
)->mos
.length () - 1;
6435 mos
= VTI (bb
)->mos
.address ();
6437 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6441 while (n1
< n2
&& mos
[n1
].type
== MO_USE
)
6443 while (n1
< n2
&& mos
[n2
].type
!= MO_USE
)
6455 n2
= VTI (bb
)->mos
.length () - 1;
6458 while (n1
< n2
&& mos
[n1
].type
!= MO_VAL_LOC
)
6460 while (n1
< n2
&& mos
[n2
].type
== MO_VAL_LOC
)
6478 mo
.u
.loc
= call_arguments
;
6479 call_arguments
= NULL_RTX
;
6481 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6482 log_op_type (PATTERN (insn
), bb
, insn
, mo
.type
, dump_file
);
6483 VTI (bb
)->mos
.safe_push (mo
);
6486 n1
= VTI (bb
)->mos
.length ();
6487 /* This will record NEXT_INSN (insn), such that we can
6488 insert notes before it without worrying about any
6489 notes that MO_USEs might emit after the insn. */
6491 note_stores (PATTERN (insn
), add_stores
, &cui
);
6492 n2
= VTI (bb
)->mos
.length () - 1;
6493 mos
= VTI (bb
)->mos
.address ();
6495 /* Order the MO_VAL_USEs first (note_stores does nothing
6496 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6497 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6500 while (n1
< n2
&& mos
[n1
].type
== MO_VAL_USE
)
6502 while (n1
< n2
&& mos
[n2
].type
!= MO_VAL_USE
)
6514 n2
= VTI (bb
)->mos
.length () - 1;
6517 while (n1
< n2
&& mos
[n1
].type
== MO_CLOBBER
)
6519 while (n1
< n2
&& mos
[n2
].type
!= MO_CLOBBER
)
6532 static enum var_init_status
6533 find_src_status (dataflow_set
*in
, rtx src
)
6535 tree decl
= NULL_TREE
;
6536 enum var_init_status status
= VAR_INIT_STATUS_UNINITIALIZED
;
6538 if (! flag_var_tracking_uninit
)
6539 status
= VAR_INIT_STATUS_INITIALIZED
;
6541 if (src
&& REG_P (src
))
6542 decl
= var_debug_decl (REG_EXPR (src
));
6543 else if (src
&& MEM_P (src
))
6544 decl
= var_debug_decl (MEM_EXPR (src
));
6547 status
= get_init_value (in
, src
, dv_from_decl (decl
));
6552 /* SRC is the source of an assignment. Use SET to try to find what
6553 was ultimately assigned to SRC. Return that value if known,
6554 otherwise return SRC itself. */
6557 find_src_set_src (dataflow_set
*set
, rtx src
)
6559 tree decl
= NULL_TREE
; /* The variable being copied around. */
6560 rtx set_src
= NULL_RTX
; /* The value for "decl" stored in "src". */
6562 location_chain nextp
;
6566 if (src
&& REG_P (src
))
6567 decl
= var_debug_decl (REG_EXPR (src
));
6568 else if (src
&& MEM_P (src
))
6569 decl
= var_debug_decl (MEM_EXPR (src
));
6573 decl_or_value dv
= dv_from_decl (decl
);
6575 var
= shared_hash_find (set
->vars
, dv
);
6579 for (i
= 0; i
< var
->n_var_parts
&& !found
; i
++)
6580 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
&& !found
;
6581 nextp
= nextp
->next
)
6582 if (rtx_equal_p (nextp
->loc
, src
))
6584 set_src
= nextp
->set_src
;
6594 /* Compute the changes of variable locations in the basic block BB. */
6597 compute_bb_dataflow (basic_block bb
)
6600 micro_operation
*mo
;
6602 dataflow_set old_out
;
6603 dataflow_set
*in
= &VTI (bb
)->in
;
6604 dataflow_set
*out
= &VTI (bb
)->out
;
6606 dataflow_set_init (&old_out
);
6607 dataflow_set_copy (&old_out
, out
);
6608 dataflow_set_copy (out
, in
);
6610 if (MAY_HAVE_DEBUG_INSNS
)
6611 local_get_addr_cache
= pointer_map_create ();
6613 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
6615 rtx insn
= mo
->insn
;
6620 dataflow_set_clear_at_call (out
);
6625 rtx loc
= mo
->u
.loc
;
6628 var_reg_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6629 else if (MEM_P (loc
))
6630 var_mem_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6636 rtx loc
= mo
->u
.loc
;
6640 if (GET_CODE (loc
) == CONCAT
)
6642 val
= XEXP (loc
, 0);
6643 vloc
= XEXP (loc
, 1);
6651 var
= PAT_VAR_LOCATION_DECL (vloc
);
6653 clobber_variable_part (out
, NULL_RTX
,
6654 dv_from_decl (var
), 0, NULL_RTX
);
6657 if (VAL_NEEDS_RESOLUTION (loc
))
6658 val_resolve (out
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
6659 set_variable_part (out
, val
, dv_from_decl (var
), 0,
6660 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6663 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
6664 set_variable_part (out
, PAT_VAR_LOCATION_LOC (vloc
),
6665 dv_from_decl (var
), 0,
6666 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6673 rtx loc
= mo
->u
.loc
;
6674 rtx val
, vloc
, uloc
;
6676 vloc
= uloc
= XEXP (loc
, 1);
6677 val
= XEXP (loc
, 0);
6679 if (GET_CODE (val
) == CONCAT
)
6681 uloc
= XEXP (val
, 1);
6682 val
= XEXP (val
, 0);
6685 if (VAL_NEEDS_RESOLUTION (loc
))
6686 val_resolve (out
, val
, vloc
, insn
);
6688 val_store (out
, val
, uloc
, insn
, false);
6690 if (VAL_HOLDS_TRACK_EXPR (loc
))
6692 if (GET_CODE (uloc
) == REG
)
6693 var_reg_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6695 else if (GET_CODE (uloc
) == MEM
)
6696 var_mem_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6704 rtx loc
= mo
->u
.loc
;
6705 rtx val
, vloc
, uloc
;
6709 uloc
= XEXP (vloc
, 1);
6710 val
= XEXP (vloc
, 0);
6713 if (GET_CODE (uloc
) == SET
)
6715 dstv
= SET_DEST (uloc
);
6716 srcv
= SET_SRC (uloc
);
6724 if (GET_CODE (val
) == CONCAT
)
6726 dstv
= vloc
= XEXP (val
, 1);
6727 val
= XEXP (val
, 0);
6730 if (GET_CODE (vloc
) == SET
)
6732 srcv
= SET_SRC (vloc
);
6734 gcc_assert (val
!= srcv
);
6735 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
6737 dstv
= vloc
= SET_DEST (vloc
);
6739 if (VAL_NEEDS_RESOLUTION (loc
))
6740 val_resolve (out
, val
, srcv
, insn
);
6742 else if (VAL_NEEDS_RESOLUTION (loc
))
6744 gcc_assert (GET_CODE (uloc
) == SET
6745 && GET_CODE (SET_SRC (uloc
)) == REG
);
6746 val_resolve (out
, val
, SET_SRC (uloc
), insn
);
6749 if (VAL_HOLDS_TRACK_EXPR (loc
))
6751 if (VAL_EXPR_IS_CLOBBERED (loc
))
6754 var_reg_delete (out
, uloc
, true);
6755 else if (MEM_P (uloc
))
6757 gcc_assert (MEM_P (dstv
));
6758 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
6759 var_mem_delete (out
, dstv
, true);
6764 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
6765 rtx src
= NULL
, dst
= uloc
;
6766 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
6768 if (GET_CODE (uloc
) == SET
)
6770 src
= SET_SRC (uloc
);
6771 dst
= SET_DEST (uloc
);
6776 if (flag_var_tracking_uninit
)
6778 status
= find_src_status (in
, src
);
6780 if (status
== VAR_INIT_STATUS_UNKNOWN
)
6781 status
= find_src_status (out
, src
);
6784 src
= find_src_set_src (in
, src
);
6788 var_reg_delete_and_set (out
, dst
, !copied_p
,
6790 else if (MEM_P (dst
))
6792 gcc_assert (MEM_P (dstv
));
6793 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
6794 var_mem_delete_and_set (out
, dstv
, !copied_p
,
6799 else if (REG_P (uloc
))
6800 var_regno_delete (out
, REGNO (uloc
));
6801 else if (MEM_P (uloc
))
6803 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
6804 gcc_checking_assert (dstv
== vloc
);
6806 clobber_overlapping_mems (out
, vloc
);
6809 val_store (out
, val
, dstv
, insn
, true);
6815 rtx loc
= mo
->u
.loc
;
6818 if (GET_CODE (loc
) == SET
)
6820 set_src
= SET_SRC (loc
);
6821 loc
= SET_DEST (loc
);
6825 var_reg_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6827 else if (MEM_P (loc
))
6828 var_mem_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6835 rtx loc
= mo
->u
.loc
;
6836 enum var_init_status src_status
;
6839 if (GET_CODE (loc
) == SET
)
6841 set_src
= SET_SRC (loc
);
6842 loc
= SET_DEST (loc
);
6845 if (! flag_var_tracking_uninit
)
6846 src_status
= VAR_INIT_STATUS_INITIALIZED
;
6849 src_status
= find_src_status (in
, set_src
);
6851 if (src_status
== VAR_INIT_STATUS_UNKNOWN
)
6852 src_status
= find_src_status (out
, set_src
);
6855 set_src
= find_src_set_src (in
, set_src
);
6858 var_reg_delete_and_set (out
, loc
, false, src_status
, set_src
);
6859 else if (MEM_P (loc
))
6860 var_mem_delete_and_set (out
, loc
, false, src_status
, set_src
);
6866 rtx loc
= mo
->u
.loc
;
6869 var_reg_delete (out
, loc
, false);
6870 else if (MEM_P (loc
))
6871 var_mem_delete (out
, loc
, false);
6877 rtx loc
= mo
->u
.loc
;
6880 var_reg_delete (out
, loc
, true);
6881 else if (MEM_P (loc
))
6882 var_mem_delete (out
, loc
, true);
6887 out
->stack_adjust
+= mo
->u
.adjust
;
6892 if (MAY_HAVE_DEBUG_INSNS
)
6894 pointer_map_destroy (local_get_addr_cache
);
6895 local_get_addr_cache
= NULL
;
6897 dataflow_set_equiv_regs (out
);
6898 shared_hash_htab (out
->vars
)
6899 .traverse
<dataflow_set
*, canonicalize_values_mark
> (out
);
6900 shared_hash_htab (out
->vars
)
6901 .traverse
<dataflow_set
*, canonicalize_values_star
> (out
);
6903 shared_hash_htab (out
->vars
)
6904 .traverse
<dataflow_set
*, canonicalize_loc_order_check
> (out
);
6907 changed
= dataflow_set_different (&old_out
, out
);
6908 dataflow_set_destroy (&old_out
);
6912 /* Find the locations of variables in the whole function. */
6915 vt_find_locations (void)
6917 fibheap_t worklist
, pending
, fibheap_swap
;
6918 sbitmap visited
, in_worklist
, in_pending
, sbitmap_swap
;
6925 int htabmax
= PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE
);
6926 bool success
= true;
6928 timevar_push (TV_VAR_TRACKING_DATAFLOW
);
6929 /* Compute reverse completion order of depth first search of the CFG
6930 so that the data-flow runs faster. */
6931 rc_order
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
6932 bb_order
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
6933 pre_and_rev_post_order_compute (NULL
, rc_order
, false);
6934 for (i
= 0; i
< n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
; i
++)
6935 bb_order
[rc_order
[i
]] = i
;
6938 worklist
= fibheap_new ();
6939 pending
= fibheap_new ();
6940 visited
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6941 in_worklist
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6942 in_pending
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6943 bitmap_clear (in_worklist
);
6945 FOR_EACH_BB_FN (bb
, cfun
)
6946 fibheap_insert (pending
, bb_order
[bb
->index
], bb
);
6947 bitmap_ones (in_pending
);
6949 while (success
&& !fibheap_empty (pending
))
6951 fibheap_swap
= pending
;
6953 worklist
= fibheap_swap
;
6954 sbitmap_swap
= in_pending
;
6955 in_pending
= in_worklist
;
6956 in_worklist
= sbitmap_swap
;
6958 bitmap_clear (visited
);
6960 while (!fibheap_empty (worklist
))
6962 bb
= (basic_block
) fibheap_extract_min (worklist
);
6963 bitmap_clear_bit (in_worklist
, bb
->index
);
6964 gcc_assert (!bitmap_bit_p (visited
, bb
->index
));
6965 if (!bitmap_bit_p (visited
, bb
->index
))
6969 int oldinsz
, oldoutsz
;
6971 bitmap_set_bit (visited
, bb
->index
);
6973 if (VTI (bb
)->in
.vars
)
6976 -= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
6977 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
6978 oldinsz
= shared_hash_htab (VTI (bb
)->in
.vars
).elements ();
6979 oldoutsz
= shared_hash_htab (VTI (bb
)->out
.vars
).elements ();
6982 oldinsz
= oldoutsz
= 0;
6984 if (MAY_HAVE_DEBUG_INSNS
)
6986 dataflow_set
*in
= &VTI (bb
)->in
, *first_out
= NULL
;
6987 bool first
= true, adjust
= false;
6989 /* Calculate the IN set as the intersection of
6990 predecessor OUT sets. */
6992 dataflow_set_clear (in
);
6993 dst_can_be_shared
= true;
6995 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
6996 if (!VTI (e
->src
)->flooded
)
6997 gcc_assert (bb_order
[bb
->index
]
6998 <= bb_order
[e
->src
->index
]);
7001 dataflow_set_copy (in
, &VTI (e
->src
)->out
);
7002 first_out
= &VTI (e
->src
)->out
;
7007 dataflow_set_merge (in
, &VTI (e
->src
)->out
);
7013 dataflow_post_merge_adjust (in
, &VTI (bb
)->permp
);
7015 /* Merge and merge_adjust should keep entries in
7017 shared_hash_htab (in
->vars
)
7018 .traverse
<dataflow_set
*,
7019 canonicalize_loc_order_check
> (in
);
7021 if (dst_can_be_shared
)
7023 shared_hash_destroy (in
->vars
);
7024 in
->vars
= shared_hash_copy (first_out
->vars
);
7028 VTI (bb
)->flooded
= true;
7032 /* Calculate the IN set as union of predecessor OUT sets. */
7033 dataflow_set_clear (&VTI (bb
)->in
);
7034 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7035 dataflow_set_union (&VTI (bb
)->in
, &VTI (e
->src
)->out
);
7038 changed
= compute_bb_dataflow (bb
);
7039 htabsz
+= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
7040 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
7042 if (htabmax
&& htabsz
> htabmax
)
7044 if (MAY_HAVE_DEBUG_INSNS
)
7045 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7046 "variable tracking size limit exceeded with "
7047 "-fvar-tracking-assignments, retrying without");
7049 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7050 "variable tracking size limit exceeded");
7057 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7059 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7062 if (bitmap_bit_p (visited
, e
->dest
->index
))
7064 if (!bitmap_bit_p (in_pending
, e
->dest
->index
))
7066 /* Send E->DEST to next round. */
7067 bitmap_set_bit (in_pending
, e
->dest
->index
);
7068 fibheap_insert (pending
,
7069 bb_order
[e
->dest
->index
],
7073 else if (!bitmap_bit_p (in_worklist
, e
->dest
->index
))
7075 /* Add E->DEST to current round. */
7076 bitmap_set_bit (in_worklist
, e
->dest
->index
);
7077 fibheap_insert (worklist
, bb_order
[e
->dest
->index
],
7085 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7087 (int)shared_hash_htab (VTI (bb
)->in
.vars
).size (),
7089 (int)shared_hash_htab (VTI (bb
)->out
.vars
).size (),
7091 (int)worklist
->nodes
, (int)pending
->nodes
, htabsz
);
7093 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7095 fprintf (dump_file
, "BB %i IN:\n", bb
->index
);
7096 dump_dataflow_set (&VTI (bb
)->in
);
7097 fprintf (dump_file
, "BB %i OUT:\n", bb
->index
);
7098 dump_dataflow_set (&VTI (bb
)->out
);
7104 if (success
&& MAY_HAVE_DEBUG_INSNS
)
7105 FOR_EACH_BB_FN (bb
, cfun
)
7106 gcc_assert (VTI (bb
)->flooded
);
7109 fibheap_delete (worklist
);
7110 fibheap_delete (pending
);
7111 sbitmap_free (visited
);
7112 sbitmap_free (in_worklist
);
7113 sbitmap_free (in_pending
);
7115 timevar_pop (TV_VAR_TRACKING_DATAFLOW
);
7119 /* Print the content of the LIST to dump file. */
7122 dump_attrs_list (attrs list
)
7124 for (; list
; list
= list
->next
)
7126 if (dv_is_decl_p (list
->dv
))
7127 print_mem_expr (dump_file
, dv_as_decl (list
->dv
));
7129 print_rtl_single (dump_file
, dv_as_value (list
->dv
));
7130 fprintf (dump_file
, "+" HOST_WIDE_INT_PRINT_DEC
, list
->offset
);
7132 fprintf (dump_file
, "\n");
7135 /* Print the information about variable *SLOT to dump file. */
7138 dump_var_tracking_slot (variable_def
**slot
, void *data ATTRIBUTE_UNUSED
)
7140 variable var
= *slot
;
7144 /* Continue traversing the hash table. */
7148 /* Print the information about variable VAR to dump file. */
7151 dump_var (variable var
)
7154 location_chain node
;
7156 if (dv_is_decl_p (var
->dv
))
7158 const_tree decl
= dv_as_decl (var
->dv
);
7160 if (DECL_NAME (decl
))
7162 fprintf (dump_file
, " name: %s",
7163 IDENTIFIER_POINTER (DECL_NAME (decl
)));
7164 if (dump_flags
& TDF_UID
)
7165 fprintf (dump_file
, "D.%u", DECL_UID (decl
));
7167 else if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
7168 fprintf (dump_file
, " name: D#%u", DEBUG_TEMP_UID (decl
));
7170 fprintf (dump_file
, " name: D.%u", DECL_UID (decl
));
7171 fprintf (dump_file
, "\n");
7175 fputc (' ', dump_file
);
7176 print_rtl_single (dump_file
, dv_as_value (var
->dv
));
7179 for (i
= 0; i
< var
->n_var_parts
; i
++)
7181 fprintf (dump_file
, " offset %ld\n",
7182 (long)(var
->onepart
? 0 : VAR_PART_OFFSET (var
, i
)));
7183 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
7185 fprintf (dump_file
, " ");
7186 if (node
->init
== VAR_INIT_STATUS_UNINITIALIZED
)
7187 fprintf (dump_file
, "[uninit]");
7188 print_rtl_single (dump_file
, node
->loc
);
7193 /* Print the information about variables from hash table VARS to dump file. */
7196 dump_vars (variable_table_type vars
)
7198 if (vars
.elements () > 0)
7200 fprintf (dump_file
, "Variables:\n");
7201 vars
.traverse
<void *, dump_var_tracking_slot
> (NULL
);
7205 /* Print the dataflow set SET to dump file. */
7208 dump_dataflow_set (dataflow_set
*set
)
7212 fprintf (dump_file
, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC
"\n",
7214 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
7218 fprintf (dump_file
, "Reg %d:", i
);
7219 dump_attrs_list (set
->regs
[i
]);
7222 dump_vars (shared_hash_htab (set
->vars
));
7223 fprintf (dump_file
, "\n");
7226 /* Print the IN and OUT sets for each basic block to dump file. */
7229 dump_dataflow_sets (void)
7233 FOR_EACH_BB_FN (bb
, cfun
)
7235 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
7236 fprintf (dump_file
, "IN:\n");
7237 dump_dataflow_set (&VTI (bb
)->in
);
7238 fprintf (dump_file
, "OUT:\n");
7239 dump_dataflow_set (&VTI (bb
)->out
);
7243 /* Return the variable for DV in dropped_values, inserting one if
7244 requested with INSERT. */
7246 static inline variable
7247 variable_from_dropped (decl_or_value dv
, enum insert_option insert
)
7249 variable_def
**slot
;
7251 onepart_enum_t onepart
;
7253 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
), insert
);
7261 gcc_checking_assert (insert
== INSERT
);
7263 onepart
= dv_onepart_p (dv
);
7265 gcc_checking_assert (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
);
7267 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7269 empty_var
->refcount
= 1;
7270 empty_var
->n_var_parts
= 0;
7271 empty_var
->onepart
= onepart
;
7272 empty_var
->in_changed_variables
= false;
7273 empty_var
->var_part
[0].loc_chain
= NULL
;
7274 empty_var
->var_part
[0].cur_loc
= NULL
;
7275 VAR_LOC_1PAUX (empty_var
) = NULL
;
7276 set_dv_changed (dv
, true);
7283 /* Recover the one-part aux from dropped_values. */
7285 static struct onepart_aux
*
7286 recover_dropped_1paux (variable var
)
7290 gcc_checking_assert (var
->onepart
);
7292 if (VAR_LOC_1PAUX (var
))
7293 return VAR_LOC_1PAUX (var
);
7295 if (var
->onepart
== ONEPART_VDECL
)
7298 dvar
= variable_from_dropped (var
->dv
, NO_INSERT
);
7303 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (dvar
);
7304 VAR_LOC_1PAUX (dvar
) = NULL
;
7306 return VAR_LOC_1PAUX (var
);
7309 /* Add variable VAR to the hash table of changed variables and
7310 if it has no locations delete it from SET's hash table. */
7313 variable_was_changed (variable var
, dataflow_set
*set
)
7315 hashval_t hash
= dv_htab_hash (var
->dv
);
7319 variable_def
**slot
;
7321 /* Remember this decl or VALUE has been added to changed_variables. */
7322 set_dv_changed (var
->dv
, true);
7324 slot
= changed_variables
.find_slot_with_hash (var
->dv
, hash
, INSERT
);
7328 variable old_var
= *slot
;
7329 gcc_assert (old_var
->in_changed_variables
);
7330 old_var
->in_changed_variables
= false;
7331 if (var
!= old_var
&& var
->onepart
)
7333 /* Restore the auxiliary info from an empty variable
7334 previously created for changed_variables, so it is
7336 gcc_checking_assert (!VAR_LOC_1PAUX (var
));
7337 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (old_var
);
7338 VAR_LOC_1PAUX (old_var
) = NULL
;
7340 variable_htab_free (*slot
);
7343 if (set
&& var
->n_var_parts
== 0)
7345 onepart_enum_t onepart
= var
->onepart
;
7346 variable empty_var
= NULL
;
7347 variable_def
**dslot
= NULL
;
7349 if (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
)
7351 dslot
= dropped_values
.find_slot_with_hash (var
->dv
,
7352 dv_htab_hash (var
->dv
),
7358 gcc_checking_assert (!empty_var
->in_changed_variables
);
7359 if (!VAR_LOC_1PAUX (var
))
7361 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (empty_var
);
7362 VAR_LOC_1PAUX (empty_var
) = NULL
;
7365 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
7371 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7372 empty_var
->dv
= var
->dv
;
7373 empty_var
->refcount
= 1;
7374 empty_var
->n_var_parts
= 0;
7375 empty_var
->onepart
= onepart
;
7378 empty_var
->refcount
++;
7383 empty_var
->refcount
++;
7384 empty_var
->in_changed_variables
= true;
7388 empty_var
->var_part
[0].loc_chain
= NULL
;
7389 empty_var
->var_part
[0].cur_loc
= NULL
;
7390 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (var
);
7391 VAR_LOC_1PAUX (var
) = NULL
;
7397 if (var
->onepart
&& !VAR_LOC_1PAUX (var
))
7398 recover_dropped_1paux (var
);
7400 var
->in_changed_variables
= true;
7407 if (var
->n_var_parts
== 0)
7409 variable_def
**slot
;
7412 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
7415 if (shared_hash_shared (set
->vars
))
7416 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
,
7418 shared_hash_htab (set
->vars
).clear_slot (slot
);
7424 /* Look for the index in VAR->var_part corresponding to OFFSET.
7425 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7426 referenced int will be set to the index that the part has or should
7427 have, if it should be inserted. */
7430 find_variable_location_part (variable var
, HOST_WIDE_INT offset
,
7431 int *insertion_point
)
7440 if (insertion_point
)
7441 *insertion_point
= 0;
7443 return var
->n_var_parts
- 1;
7446 /* Find the location part. */
7448 high
= var
->n_var_parts
;
7451 pos
= (low
+ high
) / 2;
7452 if (VAR_PART_OFFSET (var
, pos
) < offset
)
7459 if (insertion_point
)
7460 *insertion_point
= pos
;
7462 if (pos
< var
->n_var_parts
&& VAR_PART_OFFSET (var
, pos
) == offset
)
7468 static variable_def
**
7469 set_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7470 decl_or_value dv
, HOST_WIDE_INT offset
,
7471 enum var_init_status initialized
, rtx set_src
)
7474 location_chain node
, next
;
7475 location_chain
*nextp
;
7477 onepart_enum_t onepart
;
7482 onepart
= var
->onepart
;
7484 onepart
= dv_onepart_p (dv
);
7486 gcc_checking_assert (offset
== 0 || !onepart
);
7487 gcc_checking_assert (loc
!= dv_as_opaque (dv
));
7489 if (! flag_var_tracking_uninit
)
7490 initialized
= VAR_INIT_STATUS_INITIALIZED
;
7494 /* Create new variable information. */
7495 var
= (variable
) pool_alloc (onepart_pool (onepart
));
7498 var
->n_var_parts
= 1;
7499 var
->onepart
= onepart
;
7500 var
->in_changed_variables
= false;
7502 VAR_LOC_1PAUX (var
) = NULL
;
7504 VAR_PART_OFFSET (var
, 0) = offset
;
7505 var
->var_part
[0].loc_chain
= NULL
;
7506 var
->var_part
[0].cur_loc
= NULL
;
7509 nextp
= &var
->var_part
[0].loc_chain
;
7515 gcc_assert (dv_as_opaque (var
->dv
) == dv_as_opaque (dv
));
7519 if (GET_CODE (loc
) == VALUE
)
7521 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7522 nextp
= &node
->next
)
7523 if (GET_CODE (node
->loc
) == VALUE
)
7525 if (node
->loc
== loc
)
7530 if (canon_value_cmp (node
->loc
, loc
))
7538 else if (REG_P (node
->loc
) || MEM_P (node
->loc
))
7546 else if (REG_P (loc
))
7548 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7549 nextp
= &node
->next
)
7550 if (REG_P (node
->loc
))
7552 if (REGNO (node
->loc
) < REGNO (loc
))
7556 if (REGNO (node
->loc
) == REGNO (loc
))
7569 else if (MEM_P (loc
))
7571 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7572 nextp
= &node
->next
)
7573 if (REG_P (node
->loc
))
7575 else if (MEM_P (node
->loc
))
7577 if ((r
= loc_cmp (XEXP (node
->loc
, 0), XEXP (loc
, 0))) >= 0)
7589 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7590 nextp
= &node
->next
)
7591 if ((r
= loc_cmp (node
->loc
, loc
)) >= 0)
7599 if (shared_var_p (var
, set
->vars
))
7601 slot
= unshare_variable (set
, slot
, var
, initialized
);
7603 for (nextp
= &var
->var_part
[0].loc_chain
; c
;
7604 nextp
= &(*nextp
)->next
)
7606 gcc_assert ((!node
&& !*nextp
) || node
->loc
== (*nextp
)->loc
);
7613 gcc_assert (dv_as_decl (var
->dv
) == dv_as_decl (dv
));
7615 pos
= find_variable_location_part (var
, offset
, &inspos
);
7619 node
= var
->var_part
[pos
].loc_chain
;
7622 && ((REG_P (node
->loc
) && REG_P (loc
)
7623 && REGNO (node
->loc
) == REGNO (loc
))
7624 || rtx_equal_p (node
->loc
, loc
)))
7626 /* LOC is in the beginning of the chain so we have nothing
7628 if (node
->init
< initialized
)
7629 node
->init
= initialized
;
7630 if (set_src
!= NULL
)
7631 node
->set_src
= set_src
;
7637 /* We have to make a copy of a shared variable. */
7638 if (shared_var_p (var
, set
->vars
))
7640 slot
= unshare_variable (set
, slot
, var
, initialized
);
7647 /* We have not found the location part, new one will be created. */
7649 /* We have to make a copy of the shared variable. */
7650 if (shared_var_p (var
, set
->vars
))
7652 slot
= unshare_variable (set
, slot
, var
, initialized
);
7656 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7657 thus there are at most MAX_VAR_PARTS different offsets. */
7658 gcc_assert (var
->n_var_parts
< MAX_VAR_PARTS
7659 && (!var
->n_var_parts
|| !onepart
));
7661 /* We have to move the elements of array starting at index
7662 inspos to the next position. */
7663 for (pos
= var
->n_var_parts
; pos
> inspos
; pos
--)
7664 var
->var_part
[pos
] = var
->var_part
[pos
- 1];
7667 gcc_checking_assert (!onepart
);
7668 VAR_PART_OFFSET (var
, pos
) = offset
;
7669 var
->var_part
[pos
].loc_chain
= NULL
;
7670 var
->var_part
[pos
].cur_loc
= NULL
;
7673 /* Delete the location from the list. */
7674 nextp
= &var
->var_part
[pos
].loc_chain
;
7675 for (node
= var
->var_part
[pos
].loc_chain
; node
; node
= next
)
7678 if ((REG_P (node
->loc
) && REG_P (loc
)
7679 && REGNO (node
->loc
) == REGNO (loc
))
7680 || rtx_equal_p (node
->loc
, loc
))
7682 /* Save these values, to assign to the new node, before
7683 deleting this one. */
7684 if (node
->init
> initialized
)
7685 initialized
= node
->init
;
7686 if (node
->set_src
!= NULL
&& set_src
== NULL
)
7687 set_src
= node
->set_src
;
7688 if (var
->var_part
[pos
].cur_loc
== node
->loc
)
7689 var
->var_part
[pos
].cur_loc
= NULL
;
7690 pool_free (loc_chain_pool
, node
);
7695 nextp
= &node
->next
;
7698 nextp
= &var
->var_part
[pos
].loc_chain
;
7701 /* Add the location to the beginning. */
7702 node
= (location_chain
) pool_alloc (loc_chain_pool
);
7704 node
->init
= initialized
;
7705 node
->set_src
= set_src
;
7706 node
->next
= *nextp
;
7709 /* If no location was emitted do so. */
7710 if (var
->var_part
[pos
].cur_loc
== NULL
)
7711 variable_was_changed (var
, set
);
7716 /* Set the part of variable's location in the dataflow set SET. The
7717 variable part is specified by variable's declaration in DV and
7718 offset OFFSET and the part's location by LOC. IOPT should be
7719 NO_INSERT if the variable is known to be in SET already and the
7720 variable hash table must not be resized, and INSERT otherwise. */
7723 set_variable_part (dataflow_set
*set
, rtx loc
,
7724 decl_or_value dv
, HOST_WIDE_INT offset
,
7725 enum var_init_status initialized
, rtx set_src
,
7726 enum insert_option iopt
)
7728 variable_def
**slot
;
7730 if (iopt
== NO_INSERT
)
7731 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7734 slot
= shared_hash_find_slot (set
->vars
, dv
);
7736 slot
= shared_hash_find_slot_unshare (&set
->vars
, dv
, iopt
);
7738 set_slot_part (set
, loc
, slot
, dv
, offset
, initialized
, set_src
);
7741 /* Remove all recorded register locations for the given variable part
7742 from dataflow set SET, except for those that are identical to loc.
7743 The variable part is specified by variable's declaration or value
7744 DV and offset OFFSET. */
7746 static variable_def
**
7747 clobber_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7748 HOST_WIDE_INT offset
, rtx set_src
)
7750 variable var
= *slot
;
7751 int pos
= find_variable_location_part (var
, offset
, NULL
);
7755 location_chain node
, next
;
7757 /* Remove the register locations from the dataflow set. */
7758 next
= var
->var_part
[pos
].loc_chain
;
7759 for (node
= next
; node
; node
= next
)
7762 if (node
->loc
!= loc
7763 && (!flag_var_tracking_uninit
7766 || !rtx_equal_p (set_src
, node
->set_src
)))
7768 if (REG_P (node
->loc
))
7773 /* Remove the variable part from the register's
7774 list, but preserve any other variable parts
7775 that might be regarded as live in that same
7777 anextp
= &set
->regs
[REGNO (node
->loc
)];
7778 for (anode
= *anextp
; anode
; anode
= anext
)
7780 anext
= anode
->next
;
7781 if (dv_as_opaque (anode
->dv
) == dv_as_opaque (var
->dv
)
7782 && anode
->offset
== offset
)
7784 pool_free (attrs_pool
, anode
);
7788 anextp
= &anode
->next
;
7792 slot
= delete_slot_part (set
, node
->loc
, slot
, offset
);
7800 /* Remove all recorded register locations for the given variable part
7801 from dataflow set SET, except for those that are identical to loc.
7802 The variable part is specified by variable's declaration or value
7803 DV and offset OFFSET. */
7806 clobber_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7807 HOST_WIDE_INT offset
, rtx set_src
)
7809 variable_def
**slot
;
7811 if (!dv_as_opaque (dv
)
7812 || (!dv_is_value_p (dv
) && ! DECL_P (dv_as_decl (dv
))))
7815 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7819 clobber_slot_part (set
, loc
, slot
, offset
, set_src
);
7822 /* Delete the part of variable's location from dataflow set SET. The
7823 variable part is specified by its SET->vars slot SLOT and offset
7824 OFFSET and the part's location by LOC. */
7826 static variable_def
**
7827 delete_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7828 HOST_WIDE_INT offset
)
7830 variable var
= *slot
;
7831 int pos
= find_variable_location_part (var
, offset
, NULL
);
7835 location_chain node
, next
;
7836 location_chain
*nextp
;
7840 if (shared_var_p (var
, set
->vars
))
7842 /* If the variable contains the location part we have to
7843 make a copy of the variable. */
7844 for (node
= var
->var_part
[pos
].loc_chain
; node
;
7847 if ((REG_P (node
->loc
) && REG_P (loc
)
7848 && REGNO (node
->loc
) == REGNO (loc
))
7849 || rtx_equal_p (node
->loc
, loc
))
7851 slot
= unshare_variable (set
, slot
, var
,
7852 VAR_INIT_STATUS_UNKNOWN
);
7859 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7860 cur_loc
= VAR_LOC_FROM (var
);
7862 cur_loc
= var
->var_part
[pos
].cur_loc
;
7864 /* Delete the location part. */
7866 nextp
= &var
->var_part
[pos
].loc_chain
;
7867 for (node
= *nextp
; node
; node
= next
)
7870 if ((REG_P (node
->loc
) && REG_P (loc
)
7871 && REGNO (node
->loc
) == REGNO (loc
))
7872 || rtx_equal_p (node
->loc
, loc
))
7874 /* If we have deleted the location which was last emitted
7875 we have to emit new location so add the variable to set
7876 of changed variables. */
7877 if (cur_loc
== node
->loc
)
7880 var
->var_part
[pos
].cur_loc
= NULL
;
7881 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7882 VAR_LOC_FROM (var
) = NULL
;
7884 pool_free (loc_chain_pool
, node
);
7889 nextp
= &node
->next
;
7892 if (var
->var_part
[pos
].loc_chain
== NULL
)
7896 while (pos
< var
->n_var_parts
)
7898 var
->var_part
[pos
] = var
->var_part
[pos
+ 1];
7903 variable_was_changed (var
, set
);
7909 /* Delete the part of variable's location from dataflow set SET. The
7910 variable part is specified by variable's declaration or value DV
7911 and offset OFFSET and the part's location by LOC. */
7914 delete_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7915 HOST_WIDE_INT offset
)
7917 variable_def
**slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7921 delete_slot_part (set
, loc
, slot
, offset
);
7925 /* Structure for passing some other parameters to function
7926 vt_expand_loc_callback. */
7927 struct expand_loc_callback_data
7929 /* The variables and values active at this point. */
7930 variable_table_type vars
;
7932 /* Stack of values and debug_exprs under expansion, and their
7934 auto_vec
<rtx
, 4> expanding
;
7936 /* Stack of values and debug_exprs whose expansion hit recursion
7937 cycles. They will have VALUE_RECURSED_INTO marked when added to
7938 this list. This flag will be cleared if any of its dependencies
7939 resolves to a valid location. So, if the flag remains set at the
7940 end of the search, we know no valid location for this one can
7942 auto_vec
<rtx
, 4> pending
;
7944 /* The maximum depth among the sub-expressions under expansion.
7945 Zero indicates no expansion so far. */
7949 /* Allocate the one-part auxiliary data structure for VAR, with enough
7950 room for COUNT dependencies. */
7953 loc_exp_dep_alloc (variable var
, int count
)
7957 gcc_checking_assert (var
->onepart
);
7959 /* We can be called with COUNT == 0 to allocate the data structure
7960 without any dependencies, e.g. for the backlinks only. However,
7961 if we are specifying a COUNT, then the dependency list must have
7962 been emptied before. It would be possible to adjust pointers or
7963 force it empty here, but this is better done at an earlier point
7964 in the algorithm, so we instead leave an assertion to catch
7966 gcc_checking_assert (!count
7967 || VAR_LOC_DEP_VEC (var
) == NULL
7968 || VAR_LOC_DEP_VEC (var
)->is_empty ());
7970 if (VAR_LOC_1PAUX (var
) && VAR_LOC_DEP_VEC (var
)->space (count
))
7973 allocsize
= offsetof (struct onepart_aux
, deps
)
7974 + vec
<loc_exp_dep
, va_heap
, vl_embed
>::embedded_size (count
);
7976 if (VAR_LOC_1PAUX (var
))
7978 VAR_LOC_1PAUX (var
) = XRESIZEVAR (struct onepart_aux
,
7979 VAR_LOC_1PAUX (var
), allocsize
);
7980 /* If the reallocation moves the onepaux structure, the
7981 back-pointer to BACKLINKS in the first list member will still
7982 point to its old location. Adjust it. */
7983 if (VAR_LOC_DEP_LST (var
))
7984 VAR_LOC_DEP_LST (var
)->pprev
= VAR_LOC_DEP_LSTP (var
);
7988 VAR_LOC_1PAUX (var
) = XNEWVAR (struct onepart_aux
, allocsize
);
7989 *VAR_LOC_DEP_LSTP (var
) = NULL
;
7990 VAR_LOC_FROM (var
) = NULL
;
7991 VAR_LOC_DEPTH (var
).complexity
= 0;
7992 VAR_LOC_DEPTH (var
).entryvals
= 0;
7994 VAR_LOC_DEP_VEC (var
)->embedded_init (count
);
7997 /* Remove all entries from the vector of active dependencies of VAR,
7998 removing them from the back-links lists too. */
8001 loc_exp_dep_clear (variable var
)
8003 while (VAR_LOC_DEP_VEC (var
) && !VAR_LOC_DEP_VEC (var
)->is_empty ())
8005 loc_exp_dep
*led
= &VAR_LOC_DEP_VEC (var
)->last ();
8007 led
->next
->pprev
= led
->pprev
;
8009 *led
->pprev
= led
->next
;
8010 VAR_LOC_DEP_VEC (var
)->pop ();
8014 /* Insert an active dependency from VAR on X to the vector of
8015 dependencies, and add the corresponding back-link to X's list of
8016 back-links in VARS. */
8019 loc_exp_insert_dep (variable var
, rtx x
, variable_table_type vars
)
8025 dv
= dv_from_rtx (x
);
8027 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8028 an additional look up? */
8029 xvar
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8033 xvar
= variable_from_dropped (dv
, NO_INSERT
);
8034 gcc_checking_assert (xvar
);
8037 /* No point in adding the same backlink more than once. This may
8038 arise if say the same value appears in two complex expressions in
8039 the same loc_list, or even more than once in a single
8041 if (VAR_LOC_DEP_LST (xvar
) && VAR_LOC_DEP_LST (xvar
)->dv
== var
->dv
)
8044 if (var
->onepart
== NOT_ONEPART
)
8045 led
= (loc_exp_dep
*) pool_alloc (loc_exp_dep_pool
);
8049 memset (&empty
, 0, sizeof (empty
));
8050 VAR_LOC_DEP_VEC (var
)->quick_push (empty
);
8051 led
= &VAR_LOC_DEP_VEC (var
)->last ();
8056 loc_exp_dep_alloc (xvar
, 0);
8057 led
->pprev
= VAR_LOC_DEP_LSTP (xvar
);
8058 led
->next
= *led
->pprev
;
8060 led
->next
->pprev
= &led
->next
;
8064 /* Create active dependencies of VAR on COUNT values starting at
8065 VALUE, and corresponding back-links to the entries in VARS. Return
8066 true if we found any pending-recursion results. */
8069 loc_exp_dep_set (variable var
, rtx result
, rtx
*value
, int count
,
8070 variable_table_type vars
)
8072 bool pending_recursion
= false;
8074 gcc_checking_assert (VAR_LOC_DEP_VEC (var
) == NULL
8075 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8077 /* Set up all dependencies from last_child (as set up at the end of
8078 the loop above) to the end. */
8079 loc_exp_dep_alloc (var
, count
);
8085 if (!pending_recursion
)
8086 pending_recursion
= !result
&& VALUE_RECURSED_INTO (x
);
8088 loc_exp_insert_dep (var
, x
, vars
);
8091 return pending_recursion
;
8094 /* Notify the back-links of IVAR that are pending recursion that we
8095 have found a non-NIL value for it, so they are cleared for another
8096 attempt to compute a current location. */
8099 notify_dependents_of_resolved_value (variable ivar
, variable_table_type vars
)
8101 loc_exp_dep
*led
, *next
;
8103 for (led
= VAR_LOC_DEP_LST (ivar
); led
; led
= next
)
8105 decl_or_value dv
= led
->dv
;
8110 if (dv_is_value_p (dv
))
8112 rtx value
= dv_as_value (dv
);
8114 /* If we have already resolved it, leave it alone. */
8115 if (!VALUE_RECURSED_INTO (value
))
8118 /* Check that VALUE_RECURSED_INTO, true from the test above,
8119 implies NO_LOC_P. */
8120 gcc_checking_assert (NO_LOC_P (value
));
8122 /* We won't notify variables that are being expanded,
8123 because their dependency list is cleared before
8125 NO_LOC_P (value
) = false;
8126 VALUE_RECURSED_INTO (value
) = false;
8128 gcc_checking_assert (dv_changed_p (dv
));
8132 gcc_checking_assert (dv_onepart_p (dv
) != NOT_ONEPART
);
8133 if (!dv_changed_p (dv
))
8137 var
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8140 var
= variable_from_dropped (dv
, NO_INSERT
);
8143 notify_dependents_of_resolved_value (var
, vars
);
8146 next
->pprev
= led
->pprev
;
8154 static rtx
vt_expand_loc_callback (rtx x
, bitmap regs
,
8155 int max_depth
, void *data
);
8157 /* Return the combined depth, when one sub-expression evaluated to
8158 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8160 static inline expand_depth
8161 update_depth (expand_depth saved_depth
, expand_depth best_depth
)
8163 /* If we didn't find anything, stick with what we had. */
8164 if (!best_depth
.complexity
)
8167 /* If we found hadn't found anything, use the depth of the current
8168 expression. Do NOT add one extra level, we want to compute the
8169 maximum depth among sub-expressions. We'll increment it later,
8171 if (!saved_depth
.complexity
)
8174 /* Combine the entryval count so that regardless of which one we
8175 return, the entryval count is accurate. */
8176 best_depth
.entryvals
= saved_depth
.entryvals
8177 = best_depth
.entryvals
+ saved_depth
.entryvals
;
8179 if (saved_depth
.complexity
< best_depth
.complexity
)
8185 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8186 DATA for cselib expand callback. If PENDRECP is given, indicate in
8187 it whether any sub-expression couldn't be fully evaluated because
8188 it is pending recursion resolution. */
8191 vt_expand_var_loc_chain (variable var
, bitmap regs
, void *data
, bool *pendrecp
)
8193 struct expand_loc_callback_data
*elcd
8194 = (struct expand_loc_callback_data
*) data
;
8195 location_chain loc
, next
;
8197 int first_child
, result_first_child
, last_child
;
8198 bool pending_recursion
;
8199 rtx loc_from
= NULL
;
8200 struct elt_loc_list
*cloc
= NULL
;
8201 expand_depth depth
= { 0, 0 }, saved_depth
= elcd
->depth
;
8202 int wanted_entryvals
, found_entryvals
= 0;
8204 /* Clear all backlinks pointing at this, so that we're not notified
8205 while we're active. */
8206 loc_exp_dep_clear (var
);
8209 if (var
->onepart
== ONEPART_VALUE
)
8211 cselib_val
*val
= CSELIB_VAL_PTR (dv_as_value (var
->dv
));
8213 gcc_checking_assert (cselib_preserved_value_p (val
));
8218 first_child
= result_first_child
= last_child
8219 = elcd
->expanding
.length ();
8221 wanted_entryvals
= found_entryvals
;
8223 /* Attempt to expand each available location in turn. */
8224 for (next
= loc
= var
->n_var_parts
? var
->var_part
[0].loc_chain
: NULL
;
8225 loc
|| cloc
; loc
= next
)
8227 result_first_child
= last_child
;
8231 loc_from
= cloc
->loc
;
8234 if (unsuitable_loc (loc_from
))
8239 loc_from
= loc
->loc
;
8243 gcc_checking_assert (!unsuitable_loc (loc_from
));
8245 elcd
->depth
.complexity
= elcd
->depth
.entryvals
= 0;
8246 result
= cselib_expand_value_rtx_cb (loc_from
, regs
, EXPR_DEPTH
,
8247 vt_expand_loc_callback
, data
);
8248 last_child
= elcd
->expanding
.length ();
8252 depth
= elcd
->depth
;
8254 gcc_checking_assert (depth
.complexity
8255 || result_first_child
== last_child
);
8257 if (last_child
- result_first_child
!= 1)
8259 if (!depth
.complexity
&& GET_CODE (result
) == ENTRY_VALUE
)
8264 if (depth
.complexity
<= EXPR_USE_DEPTH
)
8266 if (depth
.entryvals
<= wanted_entryvals
)
8268 else if (!found_entryvals
|| depth
.entryvals
< found_entryvals
)
8269 found_entryvals
= depth
.entryvals
;
8275 /* Set it up in case we leave the loop. */
8276 depth
.complexity
= depth
.entryvals
= 0;
8278 result_first_child
= first_child
;
8281 if (!loc_from
&& wanted_entryvals
< found_entryvals
)
8283 /* We found entries with ENTRY_VALUEs and skipped them. Since
8284 we could not find any expansions without ENTRY_VALUEs, but we
8285 found at least one with them, go back and get an entry with
8286 the minimum number ENTRY_VALUE count that we found. We could
8287 avoid looping, but since each sub-loc is already resolved,
8288 the re-expansion should be trivial. ??? Should we record all
8289 attempted locs as dependencies, so that we retry the
8290 expansion should any of them change, in the hope it can give
8291 us a new entry without an ENTRY_VALUE? */
8292 elcd
->expanding
.truncate (first_child
);
8296 /* Register all encountered dependencies as active. */
8297 pending_recursion
= loc_exp_dep_set
8298 (var
, result
, elcd
->expanding
.address () + result_first_child
,
8299 last_child
- result_first_child
, elcd
->vars
);
8301 elcd
->expanding
.truncate (first_child
);
8303 /* Record where the expansion came from. */
8304 gcc_checking_assert (!result
|| !pending_recursion
);
8305 VAR_LOC_FROM (var
) = loc_from
;
8306 VAR_LOC_DEPTH (var
) = depth
;
8308 gcc_checking_assert (!depth
.complexity
== !result
);
8310 elcd
->depth
= update_depth (saved_depth
, depth
);
8312 /* Indicate whether any of the dependencies are pending recursion
8315 *pendrecp
= pending_recursion
;
8317 if (!pendrecp
|| !pending_recursion
)
8318 var
->var_part
[0].cur_loc
= result
;
8323 /* Callback for cselib_expand_value, that looks for expressions
8324 holding the value in the var-tracking hash tables. Return X for
8325 standard processing, anything else is to be used as-is. */
8328 vt_expand_loc_callback (rtx x
, bitmap regs
,
8329 int max_depth ATTRIBUTE_UNUSED
,
8332 struct expand_loc_callback_data
*elcd
8333 = (struct expand_loc_callback_data
*) data
;
8337 bool pending_recursion
= false;
8338 bool from_empty
= false;
8340 switch (GET_CODE (x
))
8343 subreg
= cselib_expand_value_rtx_cb (SUBREG_REG (x
), regs
,
8345 vt_expand_loc_callback
, data
);
8350 result
= simplify_gen_subreg (GET_MODE (x
), subreg
,
8351 GET_MODE (SUBREG_REG (x
)),
8354 /* Invalid SUBREGs are ok in debug info. ??? We could try
8355 alternate expansions for the VALUE as well. */
8357 result
= gen_rtx_raw_SUBREG (GET_MODE (x
), subreg
, SUBREG_BYTE (x
));
8363 dv
= dv_from_rtx (x
);
8370 elcd
->expanding
.safe_push (x
);
8372 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8373 gcc_checking_assert (!VALUE_RECURSED_INTO (x
) || NO_LOC_P (x
));
8377 gcc_checking_assert (VALUE_RECURSED_INTO (x
) || !dv_changed_p (dv
));
8381 var
= elcd
->vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8386 var
= variable_from_dropped (dv
, INSERT
);
8389 gcc_checking_assert (var
);
8391 if (!dv_changed_p (dv
))
8393 gcc_checking_assert (!NO_LOC_P (x
));
8394 gcc_checking_assert (var
->var_part
[0].cur_loc
);
8395 gcc_checking_assert (VAR_LOC_1PAUX (var
));
8396 gcc_checking_assert (VAR_LOC_1PAUX (var
)->depth
.complexity
);
8398 elcd
->depth
= update_depth (elcd
->depth
, VAR_LOC_1PAUX (var
)->depth
);
8400 return var
->var_part
[0].cur_loc
;
8403 VALUE_RECURSED_INTO (x
) = true;
8404 /* This is tentative, but it makes some tests simpler. */
8405 NO_LOC_P (x
) = true;
8407 gcc_checking_assert (var
->n_var_parts
== 1 || from_empty
);
8409 result
= vt_expand_var_loc_chain (var
, regs
, data
, &pending_recursion
);
8411 if (pending_recursion
)
8413 gcc_checking_assert (!result
);
8414 elcd
->pending
.safe_push (x
);
8418 NO_LOC_P (x
) = !result
;
8419 VALUE_RECURSED_INTO (x
) = false;
8420 set_dv_changed (dv
, false);
8423 notify_dependents_of_resolved_value (var
, elcd
->vars
);
8429 /* While expanding variables, we may encounter recursion cycles
8430 because of mutual (possibly indirect) dependencies between two
8431 particular variables (or values), say A and B. If we're trying to
8432 expand A when we get to B, which in turn attempts to expand A, if
8433 we can't find any other expansion for B, we'll add B to this
8434 pending-recursion stack, and tentatively return NULL for its
8435 location. This tentative value will be used for any other
8436 occurrences of B, unless A gets some other location, in which case
8437 it will notify B that it is worth another try at computing a
8438 location for it, and it will use the location computed for A then.
8439 At the end of the expansion, the tentative NULL locations become
8440 final for all members of PENDING that didn't get a notification.
8441 This function performs this finalization of NULL locations. */
8444 resolve_expansions_pending_recursion (vec
<rtx
, va_heap
> *pending
)
8446 while (!pending
->is_empty ())
8448 rtx x
= pending
->pop ();
8451 if (!VALUE_RECURSED_INTO (x
))
8454 gcc_checking_assert (NO_LOC_P (x
));
8455 VALUE_RECURSED_INTO (x
) = false;
8456 dv
= dv_from_rtx (x
);
8457 gcc_checking_assert (dv_changed_p (dv
));
8458 set_dv_changed (dv
, false);
8462 /* Initialize expand_loc_callback_data D with variable hash table V.
8463 It must be a macro because of alloca (vec stack). */
8464 #define INIT_ELCD(d, v) \
8468 (d).depth.complexity = (d).depth.entryvals = 0; \
8471 /* Finalize expand_loc_callback_data D, resolved to location L. */
8472 #define FINI_ELCD(d, l) \
8475 resolve_expansions_pending_recursion (&(d).pending); \
8476 (d).pending.release (); \
8477 (d).expanding.release (); \
8479 if ((l) && MEM_P (l)) \
8480 (l) = targetm.delegitimize_address (l); \
8484 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8485 equivalences in VARS, updating their CUR_LOCs in the process. */
8488 vt_expand_loc (rtx loc
, variable_table_type vars
)
8490 struct expand_loc_callback_data data
;
8493 if (!MAY_HAVE_DEBUG_INSNS
)
8496 INIT_ELCD (data
, vars
);
8498 result
= cselib_expand_value_rtx_cb (loc
, scratch_regs
, EXPR_DEPTH
,
8499 vt_expand_loc_callback
, &data
);
8501 FINI_ELCD (data
, result
);
8506 /* Expand the one-part VARiable to a location, using the equivalences
8507 in VARS, updating their CUR_LOCs in the process. */
8510 vt_expand_1pvar (variable var
, variable_table_type vars
)
8512 struct expand_loc_callback_data data
;
8515 gcc_checking_assert (var
->onepart
&& var
->n_var_parts
== 1);
8517 if (!dv_changed_p (var
->dv
))
8518 return var
->var_part
[0].cur_loc
;
8520 INIT_ELCD (data
, vars
);
8522 loc
= vt_expand_var_loc_chain (var
, scratch_regs
, &data
, NULL
);
8524 gcc_checking_assert (data
.expanding
.is_empty ());
8526 FINI_ELCD (data
, loc
);
8531 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8532 additional parameters: WHERE specifies whether the note shall be emitted
8533 before or after instruction INSN. */
8536 emit_note_insn_var_location (variable_def
**varp
, emit_note_data
*data
)
8538 variable var
= *varp
;
8539 rtx insn
= data
->insn
;
8540 enum emit_note_where where
= data
->where
;
8541 variable_table_type vars
= data
->vars
;
8543 int i
, j
, n_var_parts
;
8545 enum var_init_status initialized
= VAR_INIT_STATUS_UNINITIALIZED
;
8546 HOST_WIDE_INT last_limit
;
8547 tree type_size_unit
;
8548 HOST_WIDE_INT offsets
[MAX_VAR_PARTS
];
8549 rtx loc
[MAX_VAR_PARTS
];
8553 gcc_checking_assert (var
->onepart
== NOT_ONEPART
8554 || var
->onepart
== ONEPART_VDECL
);
8556 decl
= dv_as_decl (var
->dv
);
8562 for (i
= 0; i
< var
->n_var_parts
; i
++)
8563 if (var
->var_part
[i
].cur_loc
== NULL
&& var
->var_part
[i
].loc_chain
)
8564 var
->var_part
[i
].cur_loc
= var
->var_part
[i
].loc_chain
->loc
;
8565 for (i
= 0; i
< var
->n_var_parts
; i
++)
8567 enum machine_mode mode
, wider_mode
;
8569 HOST_WIDE_INT offset
;
8571 if (i
== 0 && var
->onepart
)
8573 gcc_checking_assert (var
->n_var_parts
== 1);
8575 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8576 loc2
= vt_expand_1pvar (var
, vars
);
8580 if (last_limit
< VAR_PART_OFFSET (var
, i
))
8585 else if (last_limit
> VAR_PART_OFFSET (var
, i
))
8587 offset
= VAR_PART_OFFSET (var
, i
);
8588 loc2
= var
->var_part
[i
].cur_loc
;
8589 if (loc2
&& GET_CODE (loc2
) == MEM
8590 && GET_CODE (XEXP (loc2
, 0)) == VALUE
)
8592 rtx depval
= XEXP (loc2
, 0);
8594 loc2
= vt_expand_loc (loc2
, vars
);
8597 loc_exp_insert_dep (var
, depval
, vars
);
8604 gcc_checking_assert (GET_CODE (loc2
) != VALUE
);
8605 for (lc
= var
->var_part
[i
].loc_chain
; lc
; lc
= lc
->next
)
8606 if (var
->var_part
[i
].cur_loc
== lc
->loc
)
8608 initialized
= lc
->init
;
8614 offsets
[n_var_parts
] = offset
;
8620 loc
[n_var_parts
] = loc2
;
8621 mode
= GET_MODE (var
->var_part
[i
].cur_loc
);
8622 if (mode
== VOIDmode
&& var
->onepart
)
8623 mode
= DECL_MODE (decl
);
8624 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8626 /* Attempt to merge adjacent registers or memory. */
8627 wider_mode
= GET_MODE_WIDER_MODE (mode
);
8628 for (j
= i
+ 1; j
< var
->n_var_parts
; j
++)
8629 if (last_limit
<= VAR_PART_OFFSET (var
, j
))
8631 if (j
< var
->n_var_parts
8632 && wider_mode
!= VOIDmode
8633 && var
->var_part
[j
].cur_loc
8634 && mode
== GET_MODE (var
->var_part
[j
].cur_loc
)
8635 && (REG_P (loc
[n_var_parts
]) || MEM_P (loc
[n_var_parts
]))
8636 && last_limit
== (var
->onepart
? 0 : VAR_PART_OFFSET (var
, j
))
8637 && (loc2
= vt_expand_loc (var
->var_part
[j
].cur_loc
, vars
))
8638 && GET_CODE (loc
[n_var_parts
]) == GET_CODE (loc2
))
8642 if (REG_P (loc
[n_var_parts
])
8643 && hard_regno_nregs
[REGNO (loc
[n_var_parts
])][mode
] * 2
8644 == hard_regno_nregs
[REGNO (loc
[n_var_parts
])][wider_mode
]
8645 && end_hard_regno (mode
, REGNO (loc
[n_var_parts
]))
8648 if (! WORDS_BIG_ENDIAN
&& ! BYTES_BIG_ENDIAN
)
8649 new_loc
= simplify_subreg (wider_mode
, loc
[n_var_parts
],
8651 else if (WORDS_BIG_ENDIAN
&& BYTES_BIG_ENDIAN
)
8652 new_loc
= simplify_subreg (wider_mode
, loc2
, mode
, 0);
8655 if (!REG_P (new_loc
)
8656 || REGNO (new_loc
) != REGNO (loc
[n_var_parts
]))
8659 REG_ATTRS (new_loc
) = REG_ATTRS (loc
[n_var_parts
]);
8662 else if (MEM_P (loc
[n_var_parts
])
8663 && GET_CODE (XEXP (loc2
, 0)) == PLUS
8664 && REG_P (XEXP (XEXP (loc2
, 0), 0))
8665 && CONST_INT_P (XEXP (XEXP (loc2
, 0), 1)))
8667 if ((REG_P (XEXP (loc
[n_var_parts
], 0))
8668 && rtx_equal_p (XEXP (loc
[n_var_parts
], 0),
8669 XEXP (XEXP (loc2
, 0), 0))
8670 && INTVAL (XEXP (XEXP (loc2
, 0), 1))
8671 == GET_MODE_SIZE (mode
))
8672 || (GET_CODE (XEXP (loc
[n_var_parts
], 0)) == PLUS
8673 && CONST_INT_P (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8674 && rtx_equal_p (XEXP (XEXP (loc
[n_var_parts
], 0), 0),
8675 XEXP (XEXP (loc2
, 0), 0))
8676 && INTVAL (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8677 + GET_MODE_SIZE (mode
)
8678 == INTVAL (XEXP (XEXP (loc2
, 0), 1))))
8679 new_loc
= adjust_address_nv (loc
[n_var_parts
],
8685 loc
[n_var_parts
] = new_loc
;
8687 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8693 type_size_unit
= TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8694 if ((unsigned HOST_WIDE_INT
) last_limit
< TREE_INT_CST_LOW (type_size_unit
))
8697 if (! flag_var_tracking_uninit
)
8698 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8702 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, NULL_RTX
,
8704 else if (n_var_parts
== 1)
8708 if (offsets
[0] || GET_CODE (loc
[0]) == PARALLEL
)
8709 expr_list
= gen_rtx_EXPR_LIST (VOIDmode
, loc
[0], GEN_INT (offsets
[0]));
8713 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, expr_list
,
8716 else if (n_var_parts
)
8720 for (i
= 0; i
< n_var_parts
; i
++)
8722 = gen_rtx_EXPR_LIST (VOIDmode
, loc
[i
], GEN_INT (offsets
[i
]));
8724 parallel
= gen_rtx_PARALLEL (VOIDmode
,
8725 gen_rtvec_v (n_var_parts
, loc
));
8726 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
,
8727 parallel
, (int) initialized
);
8730 if (where
!= EMIT_NOTE_BEFORE_INSN
)
8732 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8733 if (where
== EMIT_NOTE_AFTER_CALL_INSN
)
8734 NOTE_DURING_CALL_P (note
) = true;
8738 /* Make sure that the call related notes come first. */
8739 while (NEXT_INSN (insn
)
8741 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8742 && NOTE_DURING_CALL_P (insn
))
8743 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8744 insn
= NEXT_INSN (insn
);
8746 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8747 && NOTE_DURING_CALL_P (insn
))
8748 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8749 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8751 note
= emit_note_before (NOTE_INSN_VAR_LOCATION
, insn
);
8753 NOTE_VAR_LOCATION (note
) = note_vl
;
8755 set_dv_changed (var
->dv
, false);
8756 gcc_assert (var
->in_changed_variables
);
8757 var
->in_changed_variables
= false;
8758 changed_variables
.clear_slot (varp
);
8760 /* Continue traversing the hash table. */
8764 /* While traversing changed_variables, push onto DATA (a stack of RTX
8765 values) entries that aren't user variables. */
8768 var_track_values_to_stack (variable_def
**slot
,
8769 vec
<rtx
, va_heap
> *changed_values_stack
)
8771 variable var
= *slot
;
8773 if (var
->onepart
== ONEPART_VALUE
)
8774 changed_values_stack
->safe_push (dv_as_value (var
->dv
));
8775 else if (var
->onepart
== ONEPART_DEXPR
)
8776 changed_values_stack
->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var
->dv
)));
8781 /* Remove from changed_variables the entry whose DV corresponds to
8782 value or debug_expr VAL. */
8784 remove_value_from_changed_variables (rtx val
)
8786 decl_or_value dv
= dv_from_rtx (val
);
8787 variable_def
**slot
;
8790 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8793 var
->in_changed_variables
= false;
8794 changed_variables
.clear_slot (slot
);
8797 /* If VAL (a value or debug_expr) has backlinks to variables actively
8798 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8799 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8800 have dependencies of their own to notify. */
8803 notify_dependents_of_changed_value (rtx val
, variable_table_type htab
,
8804 vec
<rtx
, va_heap
> *changed_values_stack
)
8806 variable_def
**slot
;
8809 decl_or_value dv
= dv_from_rtx (val
);
8811 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8814 slot
= htab
.find_slot_with_hash (dv
, dv_htab_hash (dv
), NO_INSERT
);
8816 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8820 while ((led
= VAR_LOC_DEP_LST (var
)))
8822 decl_or_value ldv
= led
->dv
;
8825 /* Deactivate and remove the backlink, as it was “used up”. It
8826 makes no sense to attempt to notify the same entity again:
8827 either it will be recomputed and re-register an active
8828 dependency, or it will still have the changed mark. */
8830 led
->next
->pprev
= led
->pprev
;
8832 *led
->pprev
= led
->next
;
8836 if (dv_changed_p (ldv
))
8839 switch (dv_onepart_p (ldv
))
8843 set_dv_changed (ldv
, true);
8844 changed_values_stack
->safe_push (dv_as_rtx (ldv
));
8848 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8849 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar
));
8850 variable_was_changed (ivar
, NULL
);
8854 pool_free (loc_exp_dep_pool
, led
);
8855 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8858 int i
= ivar
->n_var_parts
;
8861 rtx loc
= ivar
->var_part
[i
].cur_loc
;
8863 if (loc
&& GET_CODE (loc
) == MEM
8864 && XEXP (loc
, 0) == val
)
8866 variable_was_changed (ivar
, NULL
);
8879 /* Take out of changed_variables any entries that don't refer to use
8880 variables. Back-propagate change notifications from values and
8881 debug_exprs to their active dependencies in HTAB or in
8882 CHANGED_VARIABLES. */
8885 process_changed_values (variable_table_type htab
)
8889 auto_vec
<rtx
, 20> changed_values_stack
;
8891 /* Move values from changed_variables to changed_values_stack. */
8893 .traverse
<vec
<rtx
, va_heap
>*, var_track_values_to_stack
>
8894 (&changed_values_stack
);
8896 /* Back-propagate change notifications in values while popping
8897 them from the stack. */
8898 for (n
= i
= changed_values_stack
.length ();
8899 i
> 0; i
= changed_values_stack
.length ())
8901 val
= changed_values_stack
.pop ();
8902 notify_dependents_of_changed_value (val
, htab
, &changed_values_stack
);
8904 /* This condition will hold when visiting each of the entries
8905 originally in changed_variables. We can't remove them
8906 earlier because this could drop the backlinks before we got a
8907 chance to use them. */
8910 remove_value_from_changed_variables (val
);
8916 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
8917 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
8918 the notes shall be emitted before of after instruction INSN. */
8921 emit_notes_for_changes (rtx insn
, enum emit_note_where where
,
8924 emit_note_data data
;
8925 variable_table_type htab
= shared_hash_htab (vars
);
8927 if (!changed_variables
.elements ())
8930 if (MAY_HAVE_DEBUG_INSNS
)
8931 process_changed_values (htab
);
8938 .traverse
<emit_note_data
*, emit_note_insn_var_location
> (&data
);
8941 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
8942 same variable in hash table DATA or is not there at all. */
8945 emit_notes_for_differences_1 (variable_def
**slot
, variable_table_type new_vars
)
8947 variable old_var
, new_var
;
8950 new_var
= new_vars
.find_with_hash (old_var
->dv
, dv_htab_hash (old_var
->dv
));
8954 /* Variable has disappeared. */
8955 variable empty_var
= NULL
;
8957 if (old_var
->onepart
== ONEPART_VALUE
8958 || old_var
->onepart
== ONEPART_DEXPR
)
8960 empty_var
= variable_from_dropped (old_var
->dv
, NO_INSERT
);
8963 gcc_checking_assert (!empty_var
->in_changed_variables
);
8964 if (!VAR_LOC_1PAUX (old_var
))
8966 VAR_LOC_1PAUX (old_var
) = VAR_LOC_1PAUX (empty_var
);
8967 VAR_LOC_1PAUX (empty_var
) = NULL
;
8970 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
8976 empty_var
= (variable
) pool_alloc (onepart_pool (old_var
->onepart
));
8977 empty_var
->dv
= old_var
->dv
;
8978 empty_var
->refcount
= 0;
8979 empty_var
->n_var_parts
= 0;
8980 empty_var
->onepart
= old_var
->onepart
;
8981 empty_var
->in_changed_variables
= false;
8984 if (empty_var
->onepart
)
8986 /* Propagate the auxiliary data to (ultimately)
8987 changed_variables. */
8988 empty_var
->var_part
[0].loc_chain
= NULL
;
8989 empty_var
->var_part
[0].cur_loc
= NULL
;
8990 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (old_var
);
8991 VAR_LOC_1PAUX (old_var
) = NULL
;
8993 variable_was_changed (empty_var
, NULL
);
8994 /* Continue traversing the hash table. */
8997 /* Update cur_loc and one-part auxiliary data, before new_var goes
8998 through variable_was_changed. */
8999 if (old_var
!= new_var
&& new_var
->onepart
)
9001 gcc_checking_assert (VAR_LOC_1PAUX (new_var
) == NULL
);
9002 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (old_var
);
9003 VAR_LOC_1PAUX (old_var
) = NULL
;
9004 new_var
->var_part
[0].cur_loc
= old_var
->var_part
[0].cur_loc
;
9006 if (variable_different_p (old_var
, new_var
))
9007 variable_was_changed (new_var
, NULL
);
9009 /* Continue traversing the hash table. */
9013 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9017 emit_notes_for_differences_2 (variable_def
**slot
, variable_table_type old_vars
)
9019 variable old_var
, new_var
;
9022 old_var
= old_vars
.find_with_hash (new_var
->dv
, dv_htab_hash (new_var
->dv
));
9026 for (i
= 0; i
< new_var
->n_var_parts
; i
++)
9027 new_var
->var_part
[i
].cur_loc
= NULL
;
9028 variable_was_changed (new_var
, NULL
);
9031 /* Continue traversing the hash table. */
9035 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9039 emit_notes_for_differences (rtx insn
, dataflow_set
*old_set
,
9040 dataflow_set
*new_set
)
9042 shared_hash_htab (old_set
->vars
)
9043 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9044 (shared_hash_htab (new_set
->vars
));
9045 shared_hash_htab (new_set
->vars
)
9046 .traverse
<variable_table_type
, emit_notes_for_differences_2
>
9047 (shared_hash_htab (old_set
->vars
));
9048 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, new_set
->vars
);
9051 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9054 next_non_note_insn_var_location (rtx insn
)
9058 insn
= NEXT_INSN (insn
);
9061 || NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
)
9068 /* Emit the notes for changes of location parts in the basic block BB. */
9071 emit_notes_in_bb (basic_block bb
, dataflow_set
*set
)
9074 micro_operation
*mo
;
9076 dataflow_set_clear (set
);
9077 dataflow_set_copy (set
, &VTI (bb
)->in
);
9079 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
9081 rtx insn
= mo
->insn
;
9082 rtx next_insn
= next_non_note_insn_var_location (insn
);
9087 dataflow_set_clear_at_call (set
);
9088 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_CALL_INSN
, set
->vars
);
9090 rtx arguments
= mo
->u
.loc
, *p
= &arguments
, note
;
9093 XEXP (XEXP (*p
, 0), 1)
9094 = vt_expand_loc (XEXP (XEXP (*p
, 0), 1),
9095 shared_hash_htab (set
->vars
));
9096 /* If expansion is successful, keep it in the list. */
9097 if (XEXP (XEXP (*p
, 0), 1))
9099 /* Otherwise, if the following item is data_value for it,
9101 else if (XEXP (*p
, 1)
9102 && REG_P (XEXP (XEXP (*p
, 0), 0))
9103 && MEM_P (XEXP (XEXP (XEXP (*p
, 1), 0), 0))
9104 && REG_P (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0), 0),
9106 && REGNO (XEXP (XEXP (*p
, 0), 0))
9107 == REGNO (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0),
9109 *p
= XEXP (XEXP (*p
, 1), 1);
9110 /* Just drop this item. */
9114 note
= emit_note_after (NOTE_INSN_CALL_ARG_LOCATION
, insn
);
9115 NOTE_VAR_LOCATION (note
) = arguments
;
9121 rtx loc
= mo
->u
.loc
;
9124 var_reg_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9126 var_mem_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9128 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9134 rtx loc
= mo
->u
.loc
;
9138 if (GET_CODE (loc
) == CONCAT
)
9140 val
= XEXP (loc
, 0);
9141 vloc
= XEXP (loc
, 1);
9149 var
= PAT_VAR_LOCATION_DECL (vloc
);
9151 clobber_variable_part (set
, NULL_RTX
,
9152 dv_from_decl (var
), 0, NULL_RTX
);
9155 if (VAL_NEEDS_RESOLUTION (loc
))
9156 val_resolve (set
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
9157 set_variable_part (set
, val
, dv_from_decl (var
), 0,
9158 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9161 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
9162 set_variable_part (set
, PAT_VAR_LOCATION_LOC (vloc
),
9163 dv_from_decl (var
), 0,
9164 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9167 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9173 rtx loc
= mo
->u
.loc
;
9174 rtx val
, vloc
, uloc
;
9176 vloc
= uloc
= XEXP (loc
, 1);
9177 val
= XEXP (loc
, 0);
9179 if (GET_CODE (val
) == CONCAT
)
9181 uloc
= XEXP (val
, 1);
9182 val
= XEXP (val
, 0);
9185 if (VAL_NEEDS_RESOLUTION (loc
))
9186 val_resolve (set
, val
, vloc
, insn
);
9188 val_store (set
, val
, uloc
, insn
, false);
9190 if (VAL_HOLDS_TRACK_EXPR (loc
))
9192 if (GET_CODE (uloc
) == REG
)
9193 var_reg_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9195 else if (GET_CODE (uloc
) == MEM
)
9196 var_mem_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9200 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9206 rtx loc
= mo
->u
.loc
;
9207 rtx val
, vloc
, uloc
;
9211 uloc
= XEXP (vloc
, 1);
9212 val
= XEXP (vloc
, 0);
9215 if (GET_CODE (uloc
) == SET
)
9217 dstv
= SET_DEST (uloc
);
9218 srcv
= SET_SRC (uloc
);
9226 if (GET_CODE (val
) == CONCAT
)
9228 dstv
= vloc
= XEXP (val
, 1);
9229 val
= XEXP (val
, 0);
9232 if (GET_CODE (vloc
) == SET
)
9234 srcv
= SET_SRC (vloc
);
9236 gcc_assert (val
!= srcv
);
9237 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
9239 dstv
= vloc
= SET_DEST (vloc
);
9241 if (VAL_NEEDS_RESOLUTION (loc
))
9242 val_resolve (set
, val
, srcv
, insn
);
9244 else if (VAL_NEEDS_RESOLUTION (loc
))
9246 gcc_assert (GET_CODE (uloc
) == SET
9247 && GET_CODE (SET_SRC (uloc
)) == REG
);
9248 val_resolve (set
, val
, SET_SRC (uloc
), insn
);
9251 if (VAL_HOLDS_TRACK_EXPR (loc
))
9253 if (VAL_EXPR_IS_CLOBBERED (loc
))
9256 var_reg_delete (set
, uloc
, true);
9257 else if (MEM_P (uloc
))
9259 gcc_assert (MEM_P (dstv
));
9260 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
9261 var_mem_delete (set
, dstv
, true);
9266 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
9267 rtx src
= NULL
, dst
= uloc
;
9268 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
9270 if (GET_CODE (uloc
) == SET
)
9272 src
= SET_SRC (uloc
);
9273 dst
= SET_DEST (uloc
);
9278 status
= find_src_status (set
, src
);
9280 src
= find_src_set_src (set
, src
);
9284 var_reg_delete_and_set (set
, dst
, !copied_p
,
9286 else if (MEM_P (dst
))
9288 gcc_assert (MEM_P (dstv
));
9289 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
9290 var_mem_delete_and_set (set
, dstv
, !copied_p
,
9295 else if (REG_P (uloc
))
9296 var_regno_delete (set
, REGNO (uloc
));
9297 else if (MEM_P (uloc
))
9299 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
9300 gcc_checking_assert (vloc
== dstv
);
9302 clobber_overlapping_mems (set
, vloc
);
9305 val_store (set
, val
, dstv
, insn
, true);
9307 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9314 rtx loc
= mo
->u
.loc
;
9317 if (GET_CODE (loc
) == SET
)
9319 set_src
= SET_SRC (loc
);
9320 loc
= SET_DEST (loc
);
9324 var_reg_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9327 var_mem_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9330 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9337 rtx loc
= mo
->u
.loc
;
9338 enum var_init_status src_status
;
9341 if (GET_CODE (loc
) == SET
)
9343 set_src
= SET_SRC (loc
);
9344 loc
= SET_DEST (loc
);
9347 src_status
= find_src_status (set
, set_src
);
9348 set_src
= find_src_set_src (set
, set_src
);
9351 var_reg_delete_and_set (set
, loc
, false, src_status
, set_src
);
9353 var_mem_delete_and_set (set
, loc
, false, src_status
, set_src
);
9355 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9362 rtx loc
= mo
->u
.loc
;
9365 var_reg_delete (set
, loc
, false);
9367 var_mem_delete (set
, loc
, false);
9369 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9375 rtx loc
= mo
->u
.loc
;
9378 var_reg_delete (set
, loc
, true);
9380 var_mem_delete (set
, loc
, true);
9382 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9388 set
->stack_adjust
+= mo
->u
.adjust
;
9394 /* Emit notes for the whole function. */
9397 vt_emit_notes (void)
9402 gcc_assert (!changed_variables
.elements ());
9404 /* Free memory occupied by the out hash tables, as they aren't used
9406 FOR_EACH_BB_FN (bb
, cfun
)
9407 dataflow_set_clear (&VTI (bb
)->out
);
9409 /* Enable emitting notes by functions (mainly by set_variable_part and
9410 delete_variable_part). */
9413 if (MAY_HAVE_DEBUG_INSNS
)
9415 dropped_values
.create (cselib_get_next_uid () * 2);
9416 loc_exp_dep_pool
= create_alloc_pool ("loc_exp_dep pool",
9417 sizeof (loc_exp_dep
), 64);
9420 dataflow_set_init (&cur
);
9422 FOR_EACH_BB_FN (bb
, cfun
)
9424 /* Emit the notes for changes of variable locations between two
9425 subsequent basic blocks. */
9426 emit_notes_for_differences (BB_HEAD (bb
), &cur
, &VTI (bb
)->in
);
9428 if (MAY_HAVE_DEBUG_INSNS
)
9429 local_get_addr_cache
= pointer_map_create ();
9431 /* Emit the notes for the changes in the basic block itself. */
9432 emit_notes_in_bb (bb
, &cur
);
9434 if (MAY_HAVE_DEBUG_INSNS
)
9435 pointer_map_destroy (local_get_addr_cache
);
9436 local_get_addr_cache
= NULL
;
9438 /* Free memory occupied by the in hash table, we won't need it
9440 dataflow_set_clear (&VTI (bb
)->in
);
9442 #ifdef ENABLE_CHECKING
9443 shared_hash_htab (cur
.vars
)
9444 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9445 (shared_hash_htab (empty_shared_hash
));
9447 dataflow_set_destroy (&cur
);
9449 if (MAY_HAVE_DEBUG_INSNS
)
9450 dropped_values
.dispose ();
9455 /* If there is a declaration and offset associated with register/memory RTL
9456 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9459 vt_get_decl_and_offset (rtx rtl
, tree
*declp
, HOST_WIDE_INT
*offsetp
)
9463 if (REG_ATTRS (rtl
))
9465 *declp
= REG_EXPR (rtl
);
9466 *offsetp
= REG_OFFSET (rtl
);
9470 else if (GET_CODE (rtl
) == PARALLEL
)
9472 tree decl
= NULL_TREE
;
9473 HOST_WIDE_INT offset
= MAX_VAR_PARTS
;
9474 int len
= XVECLEN (rtl
, 0), i
;
9476 for (i
= 0; i
< len
; i
++)
9478 rtx reg
= XEXP (XVECEXP (rtl
, 0, i
), 0);
9479 if (!REG_P (reg
) || !REG_ATTRS (reg
))
9482 decl
= REG_EXPR (reg
);
9483 if (REG_EXPR (reg
) != decl
)
9485 if (REG_OFFSET (reg
) < offset
)
9486 offset
= REG_OFFSET (reg
);
9496 else if (MEM_P (rtl
))
9498 if (MEM_ATTRS (rtl
))
9500 *declp
= MEM_EXPR (rtl
);
9501 *offsetp
= INT_MEM_OFFSET (rtl
);
9508 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9512 record_entry_value (cselib_val
*val
, rtx rtl
)
9514 rtx ev
= gen_rtx_ENTRY_VALUE (GET_MODE (rtl
));
9516 ENTRY_VALUE_EXP (ev
) = rtl
;
9518 cselib_add_permanent_equiv (val
, ev
, get_insns ());
9521 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9524 vt_add_function_parameter (tree parm
)
9526 rtx decl_rtl
= DECL_RTL_IF_SET (parm
);
9527 rtx incoming
= DECL_INCOMING_RTL (parm
);
9529 enum machine_mode mode
;
9530 HOST_WIDE_INT offset
;
9534 if (TREE_CODE (parm
) != PARM_DECL
)
9537 if (!decl_rtl
|| !incoming
)
9540 if (GET_MODE (decl_rtl
) == BLKmode
|| GET_MODE (incoming
) == BLKmode
)
9543 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9544 rewrite the incoming location of parameters passed on the stack
9545 into MEMs based on the argument pointer, so that incoming doesn't
9546 depend on a pseudo. */
9547 if (MEM_P (incoming
)
9548 && (XEXP (incoming
, 0) == crtl
->args
.internal_arg_pointer
9549 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
9550 && XEXP (XEXP (incoming
, 0), 0)
9551 == crtl
->args
.internal_arg_pointer
9552 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
9554 HOST_WIDE_INT off
= -FIRST_PARM_OFFSET (current_function_decl
);
9555 if (GET_CODE (XEXP (incoming
, 0)) == PLUS
)
9556 off
+= INTVAL (XEXP (XEXP (incoming
, 0), 1));
9558 = replace_equiv_address_nv (incoming
,
9559 plus_constant (Pmode
,
9560 arg_pointer_rtx
, off
));
9563 #ifdef HAVE_window_save
9564 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9565 If the target machine has an explicit window save instruction, the
9566 actual entry value is the corresponding OUTGOING_REGNO instead. */
9567 if (HAVE_window_save
&& !crtl
->uses_only_leaf_regs
)
9569 if (REG_P (incoming
)
9570 && HARD_REGISTER_P (incoming
)
9571 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
9574 p
.incoming
= incoming
;
9576 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
9577 OUTGOING_REGNO (REGNO (incoming
)), 0);
9578 p
.outgoing
= incoming
;
9579 vec_safe_push (windowed_parm_regs
, p
);
9581 else if (GET_CODE (incoming
) == PARALLEL
)
9584 = gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (XVECLEN (incoming
, 0)));
9587 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9589 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9592 reg
= gen_rtx_REG_offset (reg
, GET_MODE (reg
),
9593 OUTGOING_REGNO (REGNO (reg
)), 0);
9595 XVECEXP (outgoing
, 0, i
)
9596 = gen_rtx_EXPR_LIST (VOIDmode
, reg
,
9597 XEXP (XVECEXP (incoming
, 0, i
), 1));
9598 vec_safe_push (windowed_parm_regs
, p
);
9601 incoming
= outgoing
;
9603 else if (MEM_P (incoming
)
9604 && REG_P (XEXP (incoming
, 0))
9605 && HARD_REGISTER_P (XEXP (incoming
, 0)))
9607 rtx reg
= XEXP (incoming
, 0);
9608 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
9612 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
9614 vec_safe_push (windowed_parm_regs
, p
);
9615 incoming
= replace_equiv_address_nv (incoming
, reg
);
9621 if (!vt_get_decl_and_offset (incoming
, &decl
, &offset
))
9623 if (MEM_P (incoming
))
9625 /* This means argument is passed by invisible reference. */
9631 if (!vt_get_decl_and_offset (decl_rtl
, &decl
, &offset
))
9633 offset
+= byte_lowpart_offset (GET_MODE (incoming
),
9634 GET_MODE (decl_rtl
));
9643 /* If that DECL_RTL wasn't a pseudo that got spilled to
9644 memory, bail out. Otherwise, the spill slot sharing code
9645 will force the memory to reference spill_slot_decl (%sfp),
9646 so we don't match above. That's ok, the pseudo must have
9647 referenced the entire parameter, so just reset OFFSET. */
9648 if (decl
!= get_spill_slot_decl (false))
9653 if (!track_loc_p (incoming
, parm
, offset
, false, &mode
, &offset
))
9656 out
= &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
;
9658 dv
= dv_from_decl (parm
);
9660 if (target_for_debug_bind (parm
)
9661 /* We can't deal with these right now, because this kind of
9662 variable is single-part. ??? We could handle parallels
9663 that describe multiple locations for the same single
9664 value, but ATM we don't. */
9665 && GET_CODE (incoming
) != PARALLEL
)
9670 /* ??? We shouldn't ever hit this, but it may happen because
9671 arguments passed by invisible reference aren't dealt with
9672 above: incoming-rtl will have Pmode rather than the
9673 expected mode for the type. */
9677 lowpart
= var_lowpart (mode
, incoming
);
9681 val
= cselib_lookup_from_insn (lowpart
, mode
, true,
9682 VOIDmode
, get_insns ());
9684 /* ??? Float-typed values in memory are not handled by
9688 preserve_value (val
);
9689 set_variable_part (out
, val
->val_rtx
, dv
, offset
,
9690 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9691 dv
= dv_from_value (val
->val_rtx
);
9694 if (MEM_P (incoming
))
9696 val
= cselib_lookup_from_insn (XEXP (incoming
, 0), mode
, true,
9697 VOIDmode
, get_insns ());
9700 preserve_value (val
);
9701 incoming
= replace_equiv_address_nv (incoming
, val
->val_rtx
);
9706 if (REG_P (incoming
))
9708 incoming
= var_lowpart (mode
, incoming
);
9709 gcc_assert (REGNO (incoming
) < FIRST_PSEUDO_REGISTER
);
9710 attrs_list_insert (&out
->regs
[REGNO (incoming
)], dv
, offset
,
9712 set_variable_part (out
, incoming
, dv
, offset
,
9713 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9714 if (dv_is_value_p (dv
))
9716 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv
)), incoming
);
9717 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
9718 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm
))))
9720 enum machine_mode indmode
9721 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm
)));
9722 rtx mem
= gen_rtx_MEM (indmode
, incoming
);
9723 cselib_val
*val
= cselib_lookup_from_insn (mem
, indmode
, true,
9728 preserve_value (val
);
9729 record_entry_value (val
, mem
);
9730 set_variable_part (out
, mem
, dv_from_value (val
->val_rtx
), 0,
9731 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9736 else if (GET_CODE (incoming
) == PARALLEL
&& !dv_onepart_p (dv
))
9740 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9742 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9743 offset
= REG_OFFSET (reg
);
9744 gcc_assert (REGNO (reg
) < FIRST_PSEUDO_REGISTER
);
9745 attrs_list_insert (&out
->regs
[REGNO (reg
)], dv
, offset
, reg
);
9746 set_variable_part (out
, reg
, dv
, offset
,
9747 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9750 else if (MEM_P (incoming
))
9752 incoming
= var_lowpart (mode
, incoming
);
9753 set_variable_part (out
, incoming
, dv
, offset
,
9754 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9758 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9761 vt_add_function_parameters (void)
9765 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9766 parm
; parm
= DECL_CHAIN (parm
))
9767 vt_add_function_parameter (parm
);
9769 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl
)))
9771 tree vexpr
= DECL_VALUE_EXPR (DECL_RESULT (current_function_decl
));
9773 if (TREE_CODE (vexpr
) == INDIRECT_REF
)
9774 vexpr
= TREE_OPERAND (vexpr
, 0);
9776 if (TREE_CODE (vexpr
) == PARM_DECL
9777 && DECL_ARTIFICIAL (vexpr
)
9778 && !DECL_IGNORED_P (vexpr
)
9779 && DECL_NAMELESS (vexpr
))
9780 vt_add_function_parameter (vexpr
);
9784 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9785 ensure it isn't flushed during cselib_reset_table.
9786 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9787 has been eliminated. */
9790 vt_init_cfa_base (void)
9794 #ifdef FRAME_POINTER_CFA_OFFSET
9795 cfa_base_rtx
= frame_pointer_rtx
;
9796 cfa_base_offset
= -FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9798 cfa_base_rtx
= arg_pointer_rtx
;
9799 cfa_base_offset
= -ARG_POINTER_CFA_OFFSET (current_function_decl
);
9801 if (cfa_base_rtx
== hard_frame_pointer_rtx
9802 || !fixed_regs
[REGNO (cfa_base_rtx
)])
9804 cfa_base_rtx
= NULL_RTX
;
9807 if (!MAY_HAVE_DEBUG_INSNS
)
9810 /* Tell alias analysis that cfa_base_rtx should share
9811 find_base_term value with stack pointer or hard frame pointer. */
9812 if (!frame_pointer_needed
)
9813 vt_equate_reg_base_value (cfa_base_rtx
, stack_pointer_rtx
);
9814 else if (!crtl
->stack_realign_tried
)
9815 vt_equate_reg_base_value (cfa_base_rtx
, hard_frame_pointer_rtx
);
9817 val
= cselib_lookup_from_insn (cfa_base_rtx
, GET_MODE (cfa_base_rtx
), 1,
9818 VOIDmode
, get_insns ());
9819 preserve_value (val
);
9820 cselib_preserve_cfa_base_value (val
, REGNO (cfa_base_rtx
));
9823 /* Allocate and initialize the data structures for variable tracking
9824 and parse the RTL to get the micro operations. */
9827 vt_initialize (void)
9830 HOST_WIDE_INT fp_cfa_offset
= -1;
9832 alloc_aux_for_blocks (sizeof (struct variable_tracking_info_def
));
9834 attrs_pool
= create_alloc_pool ("attrs_def pool",
9835 sizeof (struct attrs_def
), 1024);
9836 var_pool
= create_alloc_pool ("variable_def pool",
9837 sizeof (struct variable_def
)
9838 + (MAX_VAR_PARTS
- 1)
9839 * sizeof (((variable
)NULL
)->var_part
[0]), 64);
9840 loc_chain_pool
= create_alloc_pool ("location_chain_def pool",
9841 sizeof (struct location_chain_def
),
9843 shared_hash_pool
= create_alloc_pool ("shared_hash_def pool",
9844 sizeof (struct shared_hash_def
), 256);
9845 empty_shared_hash
= (shared_hash
) pool_alloc (shared_hash_pool
);
9846 empty_shared_hash
->refcount
= 1;
9847 empty_shared_hash
->htab
.create (1);
9848 changed_variables
.create (10);
9850 /* Init the IN and OUT sets. */
9851 FOR_ALL_BB_FN (bb
, cfun
)
9853 VTI (bb
)->visited
= false;
9854 VTI (bb
)->flooded
= false;
9855 dataflow_set_init (&VTI (bb
)->in
);
9856 dataflow_set_init (&VTI (bb
)->out
);
9857 VTI (bb
)->permp
= NULL
;
9860 if (MAY_HAVE_DEBUG_INSNS
)
9862 cselib_init (CSELIB_RECORD_MEMORY
| CSELIB_PRESERVE_CONSTANTS
);
9863 scratch_regs
= BITMAP_ALLOC (NULL
);
9864 valvar_pool
= create_alloc_pool ("small variable_def pool",
9865 sizeof (struct variable_def
), 256);
9866 preserved_values
.create (256);
9867 global_get_addr_cache
= pointer_map_create ();
9871 scratch_regs
= NULL
;
9873 global_get_addr_cache
= NULL
;
9876 if (MAY_HAVE_DEBUG_INSNS
)
9882 #ifdef FRAME_POINTER_CFA_OFFSET
9883 reg
= frame_pointer_rtx
;
9884 ofst
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9886 reg
= arg_pointer_rtx
;
9887 ofst
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9890 ofst
-= INCOMING_FRAME_SP_OFFSET
;
9892 val
= cselib_lookup_from_insn (reg
, GET_MODE (reg
), 1,
9893 VOIDmode
, get_insns ());
9894 preserve_value (val
);
9895 cselib_preserve_cfa_base_value (val
, REGNO (reg
));
9896 expr
= plus_constant (GET_MODE (stack_pointer_rtx
),
9897 stack_pointer_rtx
, -ofst
);
9898 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9902 val
= cselib_lookup_from_insn (stack_pointer_rtx
,
9903 GET_MODE (stack_pointer_rtx
), 1,
9904 VOIDmode
, get_insns ());
9905 preserve_value (val
);
9906 expr
= plus_constant (GET_MODE (reg
), reg
, ofst
);
9907 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9911 /* In order to factor out the adjustments made to the stack pointer or to
9912 the hard frame pointer and thus be able to use DW_OP_fbreg operations
9913 instead of individual location lists, we're going to rewrite MEMs based
9914 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
9915 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
9916 resp. arg_pointer_rtx. We can do this either when there is no frame
9917 pointer in the function and stack adjustments are consistent for all
9918 basic blocks or when there is a frame pointer and no stack realignment.
9919 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
9920 has been eliminated. */
9921 if (!frame_pointer_needed
)
9925 if (!vt_stack_adjustments ())
9928 #ifdef FRAME_POINTER_CFA_OFFSET
9929 reg
= frame_pointer_rtx
;
9931 reg
= arg_pointer_rtx
;
9933 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9936 if (GET_CODE (elim
) == PLUS
)
9937 elim
= XEXP (elim
, 0);
9938 if (elim
== stack_pointer_rtx
)
9939 vt_init_cfa_base ();
9942 else if (!crtl
->stack_realign_tried
)
9946 #ifdef FRAME_POINTER_CFA_OFFSET
9947 reg
= frame_pointer_rtx
;
9948 fp_cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9950 reg
= arg_pointer_rtx
;
9951 fp_cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9953 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9956 if (GET_CODE (elim
) == PLUS
)
9958 fp_cfa_offset
-= INTVAL (XEXP (elim
, 1));
9959 elim
= XEXP (elim
, 0);
9961 if (elim
!= hard_frame_pointer_rtx
)
9968 /* If the stack is realigned and a DRAP register is used, we're going to
9969 rewrite MEMs based on it representing incoming locations of parameters
9970 passed on the stack into MEMs based on the argument pointer. Although
9971 we aren't going to rewrite other MEMs, we still need to initialize the
9972 virtual CFA pointer in order to ensure that the argument pointer will
9973 be seen as a constant throughout the function.
9975 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
9976 else if (stack_realign_drap
)
9980 #ifdef FRAME_POINTER_CFA_OFFSET
9981 reg
= frame_pointer_rtx
;
9983 reg
= arg_pointer_rtx
;
9985 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9988 if (GET_CODE (elim
) == PLUS
)
9989 elim
= XEXP (elim
, 0);
9990 if (elim
== hard_frame_pointer_rtx
)
9991 vt_init_cfa_base ();
9995 hard_frame_pointer_adjustment
= -1;
9997 vt_add_function_parameters ();
9999 FOR_EACH_BB_FN (bb
, cfun
)
10002 HOST_WIDE_INT pre
, post
= 0;
10003 basic_block first_bb
, last_bb
;
10005 if (MAY_HAVE_DEBUG_INSNS
)
10007 cselib_record_sets_hook
= add_with_sets
;
10008 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10009 fprintf (dump_file
, "first value: %i\n",
10010 cselib_get_next_uid ());
10017 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
10018 || ! single_pred_p (bb
->next_bb
))
10020 e
= find_edge (bb
, bb
->next_bb
);
10021 if (! e
|| (e
->flags
& EDGE_FALLTHRU
) == 0)
10027 /* Add the micro-operations to the vector. */
10028 FOR_BB_BETWEEN (bb
, first_bb
, last_bb
->next_bb
, next_bb
)
10030 HOST_WIDE_INT offset
= VTI (bb
)->out
.stack_adjust
;
10031 VTI (bb
)->out
.stack_adjust
= VTI (bb
)->in
.stack_adjust
;
10032 for (insn
= BB_HEAD (bb
); insn
!= NEXT_INSN (BB_END (bb
));
10033 insn
= NEXT_INSN (insn
))
10037 if (!frame_pointer_needed
)
10039 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
10042 micro_operation mo
;
10043 mo
.type
= MO_ADJUST
;
10046 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10047 log_op_type (PATTERN (insn
), bb
, insn
,
10048 MO_ADJUST
, dump_file
);
10049 VTI (bb
)->mos
.safe_push (mo
);
10050 VTI (bb
)->out
.stack_adjust
+= pre
;
10054 cselib_hook_called
= false;
10055 adjust_insn (bb
, insn
);
10056 if (MAY_HAVE_DEBUG_INSNS
)
10059 prepare_call_arguments (bb
, insn
);
10060 cselib_process_insn (insn
);
10061 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10063 print_rtl_single (dump_file
, insn
);
10064 dump_cselib_table (dump_file
);
10067 if (!cselib_hook_called
)
10068 add_with_sets (insn
, 0, 0);
10069 cancel_changes (0);
10071 if (!frame_pointer_needed
&& post
)
10073 micro_operation mo
;
10074 mo
.type
= MO_ADJUST
;
10075 mo
.u
.adjust
= post
;
10077 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10078 log_op_type (PATTERN (insn
), bb
, insn
,
10079 MO_ADJUST
, dump_file
);
10080 VTI (bb
)->mos
.safe_push (mo
);
10081 VTI (bb
)->out
.stack_adjust
+= post
;
10084 if (fp_cfa_offset
!= -1
10085 && hard_frame_pointer_adjustment
== -1
10086 && fp_setter_insn (insn
))
10088 vt_init_cfa_base ();
10089 hard_frame_pointer_adjustment
= fp_cfa_offset
;
10090 /* Disassociate sp from fp now. */
10091 if (MAY_HAVE_DEBUG_INSNS
)
10094 cselib_invalidate_rtx (stack_pointer_rtx
);
10095 v
= cselib_lookup (stack_pointer_rtx
, Pmode
, 1,
10097 if (v
&& !cselib_preserved_value_p (v
))
10099 cselib_set_value_sp_based (v
);
10100 preserve_value (v
);
10106 gcc_assert (offset
== VTI (bb
)->out
.stack_adjust
);
10111 if (MAY_HAVE_DEBUG_INSNS
)
10113 cselib_preserve_only_values ();
10114 cselib_reset_table (cselib_get_next_uid ());
10115 cselib_record_sets_hook
= NULL
;
10119 hard_frame_pointer_adjustment
= -1;
10120 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flooded
= true;
10121 cfa_base_rtx
= NULL_RTX
;
10125 /* This is *not* reset after each function. It gives each
10126 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10127 a unique label number. */
10129 static int debug_label_num
= 1;
10131 /* Get rid of all debug insns from the insn stream. */
10134 delete_debug_insns (void)
10139 if (!MAY_HAVE_DEBUG_INSNS
)
10142 FOR_EACH_BB_FN (bb
, cfun
)
10144 FOR_BB_INSNS_SAFE (bb
, insn
, next
)
10145 if (DEBUG_INSN_P (insn
))
10147 tree decl
= INSN_VAR_LOCATION_DECL (insn
);
10148 if (TREE_CODE (decl
) == LABEL_DECL
10149 && DECL_NAME (decl
)
10150 && !DECL_RTL_SET_P (decl
))
10152 PUT_CODE (insn
, NOTE
);
10153 NOTE_KIND (insn
) = NOTE_INSN_DELETED_DEBUG_LABEL
;
10154 NOTE_DELETED_LABEL_NAME (insn
)
10155 = IDENTIFIER_POINTER (DECL_NAME (decl
));
10156 SET_DECL_RTL (decl
, insn
);
10157 CODE_LABEL_NUMBER (insn
) = debug_label_num
++;
10160 delete_insn (insn
);
10165 /* Run a fast, BB-local only version of var tracking, to take care of
10166 information that we don't do global analysis on, such that not all
10167 information is lost. If SKIPPED holds, we're skipping the global
10168 pass entirely, so we should try to use information it would have
10169 handled as well.. */
10172 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED
)
10174 /* ??? Just skip it all for now. */
10175 delete_debug_insns ();
10178 /* Free the data structures needed for variable tracking. */
10185 FOR_EACH_BB_FN (bb
, cfun
)
10187 VTI (bb
)->mos
.release ();
10190 FOR_ALL_BB_FN (bb
, cfun
)
10192 dataflow_set_destroy (&VTI (bb
)->in
);
10193 dataflow_set_destroy (&VTI (bb
)->out
);
10194 if (VTI (bb
)->permp
)
10196 dataflow_set_destroy (VTI (bb
)->permp
);
10197 XDELETE (VTI (bb
)->permp
);
10200 free_aux_for_blocks ();
10201 empty_shared_hash
->htab
.dispose ();
10202 changed_variables
.dispose ();
10203 free_alloc_pool (attrs_pool
);
10204 free_alloc_pool (var_pool
);
10205 free_alloc_pool (loc_chain_pool
);
10206 free_alloc_pool (shared_hash_pool
);
10208 if (MAY_HAVE_DEBUG_INSNS
)
10210 if (global_get_addr_cache
)
10211 pointer_map_destroy (global_get_addr_cache
);
10212 global_get_addr_cache
= NULL
;
10213 if (loc_exp_dep_pool
)
10214 free_alloc_pool (loc_exp_dep_pool
);
10215 loc_exp_dep_pool
= NULL
;
10216 free_alloc_pool (valvar_pool
);
10217 preserved_values
.release ();
10219 BITMAP_FREE (scratch_regs
);
10220 scratch_regs
= NULL
;
10223 #ifdef HAVE_window_save
10224 vec_free (windowed_parm_regs
);
10228 XDELETEVEC (vui_vec
);
10233 /* The entry point to variable tracking pass. */
10235 static inline unsigned int
10236 variable_tracking_main_1 (void)
10240 if (flag_var_tracking_assignments
< 0)
10242 delete_debug_insns ();
10246 if (n_basic_blocks_for_fn (cfun
) > 500 &&
10247 n_edges_for_fn (cfun
) / n_basic_blocks_for_fn (cfun
) >= 20)
10249 vt_debug_insns_local (true);
10253 mark_dfs_back_edges ();
10254 if (!vt_initialize ())
10257 vt_debug_insns_local (true);
10261 success
= vt_find_locations ();
10263 if (!success
&& flag_var_tracking_assignments
> 0)
10267 delete_debug_insns ();
10269 /* This is later restored by our caller. */
10270 flag_var_tracking_assignments
= 0;
10272 success
= vt_initialize ();
10273 gcc_assert (success
);
10275 success
= vt_find_locations ();
10281 vt_debug_insns_local (false);
10285 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10287 dump_dataflow_sets ();
10288 dump_reg_info (dump_file
);
10289 dump_flow_info (dump_file
, dump_flags
);
10292 timevar_push (TV_VAR_TRACKING_EMIT
);
10294 timevar_pop (TV_VAR_TRACKING_EMIT
);
10297 vt_debug_insns_local (false);
10302 variable_tracking_main (void)
10305 int save
= flag_var_tracking_assignments
;
10307 ret
= variable_tracking_main_1 ();
10309 flag_var_tracking_assignments
= save
;
10315 gate_handle_var_tracking (void)
10317 return (flag_var_tracking
&& !targetm
.delay_vartrack
);
10324 const pass_data pass_data_variable_tracking
=
10326 RTL_PASS
, /* type */
10327 "vartrack", /* name */
10328 OPTGROUP_NONE
, /* optinfo_flags */
10329 true, /* has_gate */
10330 true, /* has_execute */
10331 TV_VAR_TRACKING
, /* tv_id */
10332 0, /* properties_required */
10333 0, /* properties_provided */
10334 0, /* properties_destroyed */
10335 0, /* todo_flags_start */
10336 ( TODO_verify_rtl_sharing
| TODO_verify_flow
), /* todo_flags_finish */
10339 class pass_variable_tracking
: public rtl_opt_pass
10342 pass_variable_tracking (gcc::context
*ctxt
)
10343 : rtl_opt_pass (pass_data_variable_tracking
, ctxt
)
10346 /* opt_pass methods: */
10347 bool gate () { return gate_handle_var_tracking (); }
10348 unsigned int execute () { return variable_tracking_main (); }
10350 }; // class pass_variable_tracking
10352 } // anon namespace
10355 make_pass_variable_tracking (gcc::context
*ctxt
)
10357 return new pass_variable_tracking (ctxt
);