1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains the variable tracking pass. It computes where
21 variables are located (which registers or where in memory) at each position
22 in instruction stream and emits notes describing the locations.
23 Debug information (DWARF2 location lists) is finally generated from
25 With this debug information, it is possible to show variables
26 even when debugging optimized code.
28 How does the variable tracking pass work?
30 First, it scans RTL code for uses, stores and clobbers (register/memory
31 references in instructions), for call insns and for stack adjustments
32 separately for each basic block and saves them to an array of micro
34 The micro operations of one instruction are ordered so that
35 pre-modifying stack adjustment < use < use with no var < call insn <
36 < clobber < set < post-modifying stack adjustment
38 Then, a forward dataflow analysis is performed to find out how locations
39 of variables change through code and to propagate the variable locations
40 along control flow graph.
41 The IN set for basic block BB is computed as a union of OUT sets of BB's
42 predecessors, the OUT set for BB is copied from the IN set for BB and
43 is changed according to micro operations in BB.
45 The IN and OUT sets for basic blocks consist of a current stack adjustment
46 (used for adjusting offset of variables addressed using stack pointer),
47 the table of structures describing the locations of parts of a variable
48 and for each physical register a linked list for each physical register.
49 The linked list is a list of variable parts stored in the register,
50 i.e. it is a list of triplets (reg, decl, offset) where decl is
51 REG_EXPR (reg) and offset is REG_OFFSET (reg). The linked list is used for
52 effective deleting appropriate variable parts when we set or clobber the
55 There may be more than one variable part in a register. The linked lists
56 should be pretty short so it is a good data structure here.
57 For example in the following code, register allocator may assign same
58 register to variables A and B, and both of them are stored in the same
71 Finally, the NOTE_INSN_VAR_LOCATION notes describing the variable locations
72 are emitted to appropriate positions in RTL code. Each such a note describes
73 the location of one variable at the point in instruction stream where the
74 note is. There is no need to emit a note for each variable before each
75 instruction, we only emit these notes where the location of variable changes
76 (this means that we also emit notes for changes between the OUT set of the
77 previous block and the IN set of the current block).
79 The notes consist of two parts:
80 1. the declaration (from REG_EXPR or MEM_EXPR)
81 2. the location of a variable - it is either a simple register/memory
82 reference (for simple variables, for example int),
83 or a parallel of register/memory references (for a large variables
84 which consist of several parts, for example long long).
90 #include "coretypes.h"
95 #include "stor-layout.h"
96 #include "pointer-set.h"
97 #include "hash-table.h"
98 #include "basic-block.h"
100 #include "hard-reg-set.h"
102 #include "insn-config.h"
105 #include "alloc-pool.h"
109 #include "tree-pass.h"
111 #include "tree-dfa.h"
112 #include "tree-ssa.h"
116 #include "diagnostic.h"
117 #include "tree-pretty-print.h"
122 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
123 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
124 Currently the value is the same as IDENTIFIER_NODE, which has such
125 a property. If this compile time assertion ever fails, make sure that
126 the new tree code that equals (int) VALUE has the same property. */
127 extern char check_value_val
[(int) VALUE
== (int) IDENTIFIER_NODE
? 1 : -1];
129 /* Type of micro operation. */
130 enum micro_operation_type
132 MO_USE
, /* Use location (REG or MEM). */
133 MO_USE_NO_VAR
,/* Use location which is not associated with a variable
134 or the variable is not trackable. */
135 MO_VAL_USE
, /* Use location which is associated with a value. */
136 MO_VAL_LOC
, /* Use location which appears in a debug insn. */
137 MO_VAL_SET
, /* Set location associated with a value. */
138 MO_SET
, /* Set location. */
139 MO_COPY
, /* Copy the same portion of a variable from one
140 location to another. */
141 MO_CLOBBER
, /* Clobber location. */
142 MO_CALL
, /* Call insn. */
143 MO_ADJUST
/* Adjust stack pointer. */
147 static const char * const ATTRIBUTE_UNUSED
148 micro_operation_type_name
[] = {
161 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
162 Notes emitted as AFTER_CALL are to take effect during the call,
163 rather than after the call. */
166 EMIT_NOTE_BEFORE_INSN
,
167 EMIT_NOTE_AFTER_INSN
,
168 EMIT_NOTE_AFTER_CALL_INSN
171 /* Structure holding information about micro operation. */
172 typedef struct micro_operation_def
174 /* Type of micro operation. */
175 enum micro_operation_type type
;
177 /* The instruction which the micro operation is in, for MO_USE,
178 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
179 instruction or note in the original flow (before any var-tracking
180 notes are inserted, to simplify emission of notes), for MO_SET
185 /* Location. For MO_SET and MO_COPY, this is the SET that
186 performs the assignment, if known, otherwise it is the target
187 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
188 CONCAT of the VALUE and the LOC associated with it. For
189 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
190 associated with it. */
193 /* Stack adjustment. */
194 HOST_WIDE_INT adjust
;
199 /* A declaration of a variable, or an RTL value being handled like a
201 typedef void *decl_or_value
;
203 /* Return true if a decl_or_value DV is a DECL or NULL. */
205 dv_is_decl_p (decl_or_value dv
)
207 return !dv
|| (int) TREE_CODE ((tree
) dv
) != (int) VALUE
;
210 /* Return true if a decl_or_value is a VALUE rtl. */
212 dv_is_value_p (decl_or_value dv
)
214 return dv
&& !dv_is_decl_p (dv
);
217 /* Return the decl in the decl_or_value. */
219 dv_as_decl (decl_or_value dv
)
221 gcc_checking_assert (dv_is_decl_p (dv
));
225 /* Return the value in the decl_or_value. */
227 dv_as_value (decl_or_value dv
)
229 gcc_checking_assert (dv_is_value_p (dv
));
233 /* Return the opaque pointer in the decl_or_value. */
235 dv_as_opaque (decl_or_value dv
)
241 /* Description of location of a part of a variable. The content of a physical
242 register is described by a chain of these structures.
243 The chains are pretty short (usually 1 or 2 elements) and thus
244 chain is the best data structure. */
245 typedef struct attrs_def
247 /* Pointer to next member of the list. */
248 struct attrs_def
*next
;
250 /* The rtx of register. */
253 /* The declaration corresponding to LOC. */
256 /* Offset from start of DECL. */
257 HOST_WIDE_INT offset
;
260 /* Structure for chaining the locations. */
261 typedef struct location_chain_def
263 /* Next element in the chain. */
264 struct location_chain_def
*next
;
266 /* The location (REG, MEM or VALUE). */
269 /* The "value" stored in this location. */
273 enum var_init_status init
;
276 /* A vector of loc_exp_dep holds the active dependencies of a one-part
277 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
278 location of DV. Each entry is also part of VALUE' s linked-list of
279 backlinks back to DV. */
280 typedef struct loc_exp_dep_s
282 /* The dependent DV. */
284 /* The dependency VALUE or DECL_DEBUG. */
286 /* The next entry in VALUE's backlinks list. */
287 struct loc_exp_dep_s
*next
;
288 /* A pointer to the pointer to this entry (head or prev's next) in
289 the doubly-linked list. */
290 struct loc_exp_dep_s
**pprev
;
294 /* This data structure holds information about the depth of a variable
296 typedef struct expand_depth_struct
298 /* This measures the complexity of the expanded expression. It
299 grows by one for each level of expansion that adds more than one
302 /* This counts the number of ENTRY_VALUE expressions in an
303 expansion. We want to minimize their use. */
307 /* This data structure is allocated for one-part variables at the time
308 of emitting notes. */
311 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
312 computation used the expansion of this variable, and that ought
313 to be notified should this variable change. If the DV's cur_loc
314 expanded to NULL, all components of the loc list are regarded as
315 active, so that any changes in them give us a chance to get a
316 location. Otherwise, only components of the loc that expanded to
317 non-NULL are regarded as active dependencies. */
318 loc_exp_dep
*backlinks
;
319 /* This holds the LOC that was expanded into cur_loc. We need only
320 mark a one-part variable as changed if the FROM loc is removed,
321 or if it has no known location and a loc is added, or if it gets
322 a change notification from any of its active dependencies. */
324 /* The depth of the cur_loc expression. */
326 /* Dependencies actively used when expand FROM into cur_loc. */
327 vec
<loc_exp_dep
, va_heap
, vl_embed
> deps
;
330 /* Structure describing one part of variable. */
331 typedef struct variable_part_def
333 /* Chain of locations of the part. */
334 location_chain loc_chain
;
336 /* Location which was last emitted to location list. */
341 /* The offset in the variable, if !var->onepart. */
342 HOST_WIDE_INT offset
;
344 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
345 struct onepart_aux
*onepaux
;
349 /* Maximum number of location parts. */
350 #define MAX_VAR_PARTS 16
352 /* Enumeration type used to discriminate various types of one-part
354 typedef enum onepart_enum
356 /* Not a one-part variable. */
358 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
360 /* A DEBUG_EXPR_DECL. */
366 /* Structure describing where the variable is located. */
367 typedef struct variable_def
369 /* The declaration of the variable, or an RTL value being handled
370 like a declaration. */
373 /* Reference count. */
376 /* Number of variable parts. */
379 /* What type of DV this is, according to enum onepart_enum. */
380 ENUM_BITFIELD (onepart_enum
) onepart
: CHAR_BIT
;
382 /* True if this variable_def struct is currently in the
383 changed_variables hash table. */
384 bool in_changed_variables
;
386 /* The variable parts. */
387 variable_part var_part
[1];
389 typedef const struct variable_def
*const_variable
;
391 /* Pointer to the BB's information specific to variable tracking pass. */
392 #define VTI(BB) ((variable_tracking_info) (BB)->aux)
394 /* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
395 #define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
397 #if ENABLE_CHECKING && (GCC_VERSION >= 2007)
399 /* Access VAR's Ith part's offset, checking that it's not a one-part
401 #define VAR_PART_OFFSET(var, i) __extension__ \
402 (*({ variable const __v = (var); \
403 gcc_checking_assert (!__v->onepart); \
404 &__v->var_part[(i)].aux.offset; }))
406 /* Access VAR's one-part auxiliary data, checking that it is a
407 one-part variable. */
408 #define VAR_LOC_1PAUX(var) __extension__ \
409 (*({ variable const __v = (var); \
410 gcc_checking_assert (__v->onepart); \
411 &__v->var_part[0].aux.onepaux; }))
414 #define VAR_PART_OFFSET(var, i) ((var)->var_part[(i)].aux.offset)
415 #define VAR_LOC_1PAUX(var) ((var)->var_part[0].aux.onepaux)
418 /* These are accessor macros for the one-part auxiliary data. When
419 convenient for users, they're guarded by tests that the data was
421 #define VAR_LOC_DEP_LST(var) (VAR_LOC_1PAUX (var) \
422 ? VAR_LOC_1PAUX (var)->backlinks \
424 #define VAR_LOC_DEP_LSTP(var) (VAR_LOC_1PAUX (var) \
425 ? &VAR_LOC_1PAUX (var)->backlinks \
427 #define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
428 #define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
429 #define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
430 ? &VAR_LOC_1PAUX (var)->deps \
435 typedef unsigned int dvuid
;
437 /* Return the uid of DV. */
440 dv_uid (decl_or_value dv
)
442 if (dv_is_value_p (dv
))
443 return CSELIB_VAL_PTR (dv_as_value (dv
))->uid
;
445 return DECL_UID (dv_as_decl (dv
));
448 /* Compute the hash from the uid. */
450 static inline hashval_t
451 dv_uid2hash (dvuid uid
)
456 /* The hash function for a mask table in a shared_htab chain. */
458 static inline hashval_t
459 dv_htab_hash (decl_or_value dv
)
461 return dv_uid2hash (dv_uid (dv
));
464 static void variable_htab_free (void *);
466 /* Variable hashtable helpers. */
468 struct variable_hasher
470 typedef variable_def value_type
;
471 typedef void compare_type
;
472 static inline hashval_t
hash (const value_type
*);
473 static inline bool equal (const value_type
*, const compare_type
*);
474 static inline void remove (value_type
*);
477 /* The hash function for variable_htab, computes the hash value
478 from the declaration of variable X. */
481 variable_hasher::hash (const value_type
*v
)
483 return dv_htab_hash (v
->dv
);
486 /* Compare the declaration of variable X with declaration Y. */
489 variable_hasher::equal (const value_type
*v
, const compare_type
*y
)
491 decl_or_value dv
= CONST_CAST2 (decl_or_value
, const void *, y
);
493 return (dv_as_opaque (v
->dv
) == dv_as_opaque (dv
));
496 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
499 variable_hasher::remove (value_type
*var
)
501 variable_htab_free (var
);
504 typedef hash_table
<variable_hasher
> variable_table_type
;
505 typedef variable_table_type::iterator variable_iterator_type
;
507 /* Structure for passing some other parameters to function
508 emit_note_insn_var_location. */
509 typedef struct emit_note_data_def
511 /* The instruction which the note will be emitted before/after. */
514 /* Where the note will be emitted (before/after insn)? */
515 enum emit_note_where where
;
517 /* The variables and values active at this point. */
518 variable_table_type vars
;
521 /* Structure holding a refcounted hash table. If refcount > 1,
522 it must be first unshared before modified. */
523 typedef struct shared_hash_def
525 /* Reference count. */
528 /* Actual hash table. */
529 variable_table_type htab
;
532 /* Structure holding the IN or OUT set for a basic block. */
533 typedef struct dataflow_set_def
535 /* Adjustment of stack offset. */
536 HOST_WIDE_INT stack_adjust
;
538 /* Attributes for registers (lists of attrs). */
539 attrs regs
[FIRST_PSEUDO_REGISTER
];
541 /* Variable locations. */
544 /* Vars that is being traversed. */
545 shared_hash traversed_vars
;
548 /* The structure (one for each basic block) containing the information
549 needed for variable tracking. */
550 typedef struct variable_tracking_info_def
552 /* The vector of micro operations. */
553 vec
<micro_operation
> mos
;
555 /* The IN and OUT set for dataflow analysis. */
559 /* The permanent-in dataflow set for this block. This is used to
560 hold values for which we had to compute entry values. ??? This
561 should probably be dynamically allocated, to avoid using more
562 memory in non-debug builds. */
565 /* Has the block been visited in DFS? */
568 /* Has the block been flooded in VTA? */
571 } *variable_tracking_info
;
573 /* Alloc pool for struct attrs_def. */
574 static alloc_pool attrs_pool
;
576 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
577 static alloc_pool var_pool
;
579 /* Alloc pool for struct variable_def with a single var_part entry. */
580 static alloc_pool valvar_pool
;
582 /* Alloc pool for struct location_chain_def. */
583 static alloc_pool loc_chain_pool
;
585 /* Alloc pool for struct shared_hash_def. */
586 static alloc_pool shared_hash_pool
;
588 /* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
589 static alloc_pool loc_exp_dep_pool
;
591 /* Changed variables, notes will be emitted for them. */
592 static variable_table_type changed_variables
;
594 /* Shall notes be emitted? */
595 static bool emit_notes
;
597 /* Values whose dynamic location lists have gone empty, but whose
598 cselib location lists are still usable. Use this to hold the
599 current location, the backlinks, etc, during emit_notes. */
600 static variable_table_type dropped_values
;
602 /* Empty shared hashtable. */
603 static shared_hash empty_shared_hash
;
605 /* Scratch register bitmap used by cselib_expand_value_rtx. */
606 static bitmap scratch_regs
= NULL
;
608 #ifdef HAVE_window_save
609 typedef struct GTY(()) parm_reg
{
615 /* Vector of windowed parameter registers, if any. */
616 static vec
<parm_reg_t
, va_gc
> *windowed_parm_regs
= NULL
;
619 /* Variable used to tell whether cselib_process_insn called our hook. */
620 static bool cselib_hook_called
;
622 /* Local function prototypes. */
623 static void stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
625 static void insn_stack_adjust_offset_pre_post (rtx
, HOST_WIDE_INT
*,
627 static bool vt_stack_adjustments (void);
629 static void init_attrs_list_set (attrs
*);
630 static void attrs_list_clear (attrs
*);
631 static attrs
attrs_list_member (attrs
, decl_or_value
, HOST_WIDE_INT
);
632 static void attrs_list_insert (attrs
*, decl_or_value
, HOST_WIDE_INT
, rtx
);
633 static void attrs_list_copy (attrs
*, attrs
);
634 static void attrs_list_union (attrs
*, attrs
);
636 static variable_def
**unshare_variable (dataflow_set
*set
, variable_def
**slot
,
637 variable var
, enum var_init_status
);
638 static void vars_copy (variable_table_type
, variable_table_type
);
639 static tree
var_debug_decl (tree
);
640 static void var_reg_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
641 static void var_reg_delete_and_set (dataflow_set
*, rtx
, bool,
642 enum var_init_status
, rtx
);
643 static void var_reg_delete (dataflow_set
*, rtx
, bool);
644 static void var_regno_delete (dataflow_set
*, int);
645 static void var_mem_set (dataflow_set
*, rtx
, enum var_init_status
, rtx
);
646 static void var_mem_delete_and_set (dataflow_set
*, rtx
, bool,
647 enum var_init_status
, rtx
);
648 static void var_mem_delete (dataflow_set
*, rtx
, bool);
650 static void dataflow_set_init (dataflow_set
*);
651 static void dataflow_set_clear (dataflow_set
*);
652 static void dataflow_set_copy (dataflow_set
*, dataflow_set
*);
653 static int variable_union_info_cmp_pos (const void *, const void *);
654 static void dataflow_set_union (dataflow_set
*, dataflow_set
*);
655 static location_chain
find_loc_in_1pdv (rtx
, variable
, variable_table_type
);
656 static bool canon_value_cmp (rtx
, rtx
);
657 static int loc_cmp (rtx
, rtx
);
658 static bool variable_part_different_p (variable_part
*, variable_part
*);
659 static bool onepart_variable_different_p (variable
, variable
);
660 static bool variable_different_p (variable
, variable
);
661 static bool dataflow_set_different (dataflow_set
*, dataflow_set
*);
662 static void dataflow_set_destroy (dataflow_set
*);
664 static bool contains_symbol_ref (rtx
);
665 static bool track_expr_p (tree
, bool);
666 static bool same_variable_part_p (rtx
, tree
, HOST_WIDE_INT
);
667 static int add_uses (rtx
*, void *);
668 static void add_uses_1 (rtx
*, void *);
669 static void add_stores (rtx
, const_rtx
, void *);
670 static bool compute_bb_dataflow (basic_block
);
671 static bool vt_find_locations (void);
673 static void dump_attrs_list (attrs
);
674 static void dump_var (variable
);
675 static void dump_vars (variable_table_type
);
676 static void dump_dataflow_set (dataflow_set
*);
677 static void dump_dataflow_sets (void);
679 static void set_dv_changed (decl_or_value
, bool);
680 static void variable_was_changed (variable
, dataflow_set
*);
681 static variable_def
**set_slot_part (dataflow_set
*, rtx
, variable_def
**,
682 decl_or_value
, HOST_WIDE_INT
,
683 enum var_init_status
, rtx
);
684 static void set_variable_part (dataflow_set
*, rtx
,
685 decl_or_value
, HOST_WIDE_INT
,
686 enum var_init_status
, rtx
, enum insert_option
);
687 static variable_def
**clobber_slot_part (dataflow_set
*, rtx
,
688 variable_def
**, HOST_WIDE_INT
, rtx
);
689 static void clobber_variable_part (dataflow_set
*, rtx
,
690 decl_or_value
, HOST_WIDE_INT
, rtx
);
691 static variable_def
**delete_slot_part (dataflow_set
*, rtx
, variable_def
**,
693 static void delete_variable_part (dataflow_set
*, rtx
,
694 decl_or_value
, HOST_WIDE_INT
);
695 static void emit_notes_in_bb (basic_block
, dataflow_set
*);
696 static void vt_emit_notes (void);
698 static bool vt_get_decl_and_offset (rtx
, tree
*, HOST_WIDE_INT
*);
699 static void vt_add_function_parameters (void);
700 static bool vt_initialize (void);
701 static void vt_finalize (void);
703 /* Given a SET, calculate the amount of stack adjustment it contains
704 PRE- and POST-modifying stack pointer.
705 This function is similar to stack_adjust_offset. */
708 stack_adjust_offset_pre_post (rtx pattern
, HOST_WIDE_INT
*pre
,
711 rtx src
= SET_SRC (pattern
);
712 rtx dest
= SET_DEST (pattern
);
715 if (dest
== stack_pointer_rtx
)
717 /* (set (reg sp) (plus (reg sp) (const_int))) */
718 code
= GET_CODE (src
);
719 if (! (code
== PLUS
|| code
== MINUS
)
720 || XEXP (src
, 0) != stack_pointer_rtx
721 || !CONST_INT_P (XEXP (src
, 1)))
725 *post
+= INTVAL (XEXP (src
, 1));
727 *post
-= INTVAL (XEXP (src
, 1));
729 else if (MEM_P (dest
))
731 /* (set (mem (pre_dec (reg sp))) (foo)) */
732 src
= XEXP (dest
, 0);
733 code
= GET_CODE (src
);
739 if (XEXP (src
, 0) == stack_pointer_rtx
)
741 rtx val
= XEXP (XEXP (src
, 1), 1);
742 /* We handle only adjustments by constant amount. */
743 gcc_assert (GET_CODE (XEXP (src
, 1)) == PLUS
&&
746 if (code
== PRE_MODIFY
)
747 *pre
-= INTVAL (val
);
749 *post
-= INTVAL (val
);
755 if (XEXP (src
, 0) == stack_pointer_rtx
)
757 *pre
+= GET_MODE_SIZE (GET_MODE (dest
));
763 if (XEXP (src
, 0) == stack_pointer_rtx
)
765 *post
+= GET_MODE_SIZE (GET_MODE (dest
));
771 if (XEXP (src
, 0) == stack_pointer_rtx
)
773 *pre
-= GET_MODE_SIZE (GET_MODE (dest
));
779 if (XEXP (src
, 0) == stack_pointer_rtx
)
781 *post
-= GET_MODE_SIZE (GET_MODE (dest
));
792 /* Given an INSN, calculate the amount of stack adjustment it contains
793 PRE- and POST-modifying stack pointer. */
796 insn_stack_adjust_offset_pre_post (rtx insn
, HOST_WIDE_INT
*pre
,
804 pattern
= PATTERN (insn
);
805 if (RTX_FRAME_RELATED_P (insn
))
807 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
809 pattern
= XEXP (expr
, 0);
812 if (GET_CODE (pattern
) == SET
)
813 stack_adjust_offset_pre_post (pattern
, pre
, post
);
814 else if (GET_CODE (pattern
) == PARALLEL
815 || GET_CODE (pattern
) == SEQUENCE
)
819 /* There may be stack adjustments inside compound insns. Search
821 for ( i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
822 if (GET_CODE (XVECEXP (pattern
, 0, i
)) == SET
)
823 stack_adjust_offset_pre_post (XVECEXP (pattern
, 0, i
), pre
, post
);
827 /* Compute stack adjustments for all blocks by traversing DFS tree.
828 Return true when the adjustments on all incoming edges are consistent.
829 Heavily borrowed from pre_and_rev_post_order_compute. */
832 vt_stack_adjustments (void)
834 edge_iterator
*stack
;
837 /* Initialize entry block. */
838 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->visited
= true;
839 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->in
.stack_adjust
=
840 INCOMING_FRAME_SP_OFFSET
;
841 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
.stack_adjust
=
842 INCOMING_FRAME_SP_OFFSET
;
844 /* Allocate stack for back-tracking up CFG. */
845 stack
= XNEWVEC (edge_iterator
, n_basic_blocks_for_fn (cfun
) + 1);
848 /* Push the first edge on to the stack. */
849 stack
[sp
++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
857 /* Look at the edge on the top of the stack. */
859 src
= ei_edge (ei
)->src
;
860 dest
= ei_edge (ei
)->dest
;
862 /* Check if the edge destination has been visited yet. */
863 if (!VTI (dest
)->visited
)
866 HOST_WIDE_INT pre
, post
, offset
;
867 VTI (dest
)->visited
= true;
868 VTI (dest
)->in
.stack_adjust
= offset
= VTI (src
)->out
.stack_adjust
;
870 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
871 for (insn
= BB_HEAD (dest
);
872 insn
!= NEXT_INSN (BB_END (dest
));
873 insn
= NEXT_INSN (insn
))
876 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
877 offset
+= pre
+ post
;
880 VTI (dest
)->out
.stack_adjust
= offset
;
882 if (EDGE_COUNT (dest
->succs
) > 0)
883 /* Since the DEST node has been visited for the first
884 time, check its successors. */
885 stack
[sp
++] = ei_start (dest
->succs
);
889 /* Check whether the adjustments on the edges are the same. */
890 if (VTI (dest
)->in
.stack_adjust
!= VTI (src
)->out
.stack_adjust
)
896 if (! ei_one_before_end_p (ei
))
897 /* Go to the next edge. */
898 ei_next (&stack
[sp
- 1]);
900 /* Return to previous level if there are no more edges. */
909 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
910 hard_frame_pointer_rtx is being mapped to it and offset for it. */
911 static rtx cfa_base_rtx
;
912 static HOST_WIDE_INT cfa_base_offset
;
914 /* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
915 or hard_frame_pointer_rtx. */
918 compute_cfa_pointer (HOST_WIDE_INT adjustment
)
920 return plus_constant (Pmode
, cfa_base_rtx
, adjustment
+ cfa_base_offset
);
923 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
924 or -1 if the replacement shouldn't be done. */
925 static HOST_WIDE_INT hard_frame_pointer_adjustment
= -1;
927 /* Data for adjust_mems callback. */
929 struct adjust_mem_data
932 enum machine_mode mem_mode
;
933 HOST_WIDE_INT stack_adjust
;
937 /* Helper for adjust_mems. Return 1 if *loc is unsuitable for
938 transformation of wider mode arithmetics to narrower mode,
939 -1 if it is suitable and subexpressions shouldn't be
940 traversed and 0 if it is suitable and subexpressions should
941 be traversed. Called through for_each_rtx. */
944 use_narrower_mode_test (rtx
*loc
, void *data
)
946 rtx subreg
= (rtx
) data
;
948 if (CONSTANT_P (*loc
))
950 switch (GET_CODE (*loc
))
953 if (cselib_lookup (*loc
, GET_MODE (SUBREG_REG (subreg
)), 0, VOIDmode
))
955 if (!validate_subreg (GET_MODE (subreg
), GET_MODE (*loc
),
956 *loc
, subreg_lowpart_offset (GET_MODE (subreg
),
965 if (for_each_rtx (&XEXP (*loc
, 0), use_narrower_mode_test
, data
))
974 /* Transform X into narrower mode MODE from wider mode WMODE. */
977 use_narrower_mode (rtx x
, enum machine_mode mode
, enum machine_mode wmode
)
981 return lowpart_subreg (mode
, x
, wmode
);
982 switch (GET_CODE (x
))
985 return lowpart_subreg (mode
, x
, wmode
);
989 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
990 op1
= use_narrower_mode (XEXP (x
, 1), mode
, wmode
);
991 return simplify_gen_binary (GET_CODE (x
), mode
, op0
, op1
);
993 op0
= use_narrower_mode (XEXP (x
, 0), mode
, wmode
);
994 return simplify_gen_binary (ASHIFT
, mode
, op0
, XEXP (x
, 1));
1000 /* Helper function for adjusting used MEMs. */
1003 adjust_mems (rtx loc
, const_rtx old_rtx
, void *data
)
1005 struct adjust_mem_data
*amd
= (struct adjust_mem_data
*) data
;
1006 rtx mem
, addr
= loc
, tem
;
1007 enum machine_mode mem_mode_save
;
1009 switch (GET_CODE (loc
))
1012 /* Don't do any sp or fp replacements outside of MEM addresses
1014 if (amd
->mem_mode
== VOIDmode
&& amd
->store
)
1016 if (loc
== stack_pointer_rtx
1017 && !frame_pointer_needed
1019 return compute_cfa_pointer (amd
->stack_adjust
);
1020 else if (loc
== hard_frame_pointer_rtx
1021 && frame_pointer_needed
1022 && hard_frame_pointer_adjustment
!= -1
1024 return compute_cfa_pointer (hard_frame_pointer_adjustment
);
1025 gcc_checking_assert (loc
!= virtual_incoming_args_rtx
);
1031 mem
= targetm
.delegitimize_address (mem
);
1032 if (mem
!= loc
&& !MEM_P (mem
))
1033 return simplify_replace_fn_rtx (mem
, old_rtx
, adjust_mems
, data
);
1036 addr
= XEXP (mem
, 0);
1037 mem_mode_save
= amd
->mem_mode
;
1038 amd
->mem_mode
= GET_MODE (mem
);
1039 store_save
= amd
->store
;
1041 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1042 amd
->store
= store_save
;
1043 amd
->mem_mode
= mem_mode_save
;
1045 addr
= targetm
.delegitimize_address (addr
);
1046 if (addr
!= XEXP (mem
, 0))
1047 mem
= replace_equiv_address_nv (mem
, addr
);
1049 mem
= avoid_constant_pool_reference (mem
);
1053 addr
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1054 gen_int_mode (GET_CODE (loc
) == PRE_INC
1055 ? GET_MODE_SIZE (amd
->mem_mode
)
1056 : -GET_MODE_SIZE (amd
->mem_mode
),
1061 addr
= XEXP (loc
, 0);
1062 gcc_assert (amd
->mem_mode
!= VOIDmode
&& amd
->mem_mode
!= BLKmode
);
1063 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1064 tem
= gen_rtx_PLUS (GET_MODE (loc
), XEXP (loc
, 0),
1065 gen_int_mode ((GET_CODE (loc
) == PRE_INC
1066 || GET_CODE (loc
) == POST_INC
)
1067 ? GET_MODE_SIZE (amd
->mem_mode
)
1068 : -GET_MODE_SIZE (amd
->mem_mode
),
1070 amd
->side_effects
= alloc_EXPR_LIST (0,
1071 gen_rtx_SET (VOIDmode
,
1077 addr
= XEXP (loc
, 1);
1080 addr
= XEXP (loc
, 0);
1081 gcc_assert (amd
->mem_mode
!= VOIDmode
);
1082 addr
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1083 amd
->side_effects
= alloc_EXPR_LIST (0,
1084 gen_rtx_SET (VOIDmode
,
1090 /* First try without delegitimization of whole MEMs and
1091 avoid_constant_pool_reference, which is more likely to succeed. */
1092 store_save
= amd
->store
;
1094 addr
= simplify_replace_fn_rtx (SUBREG_REG (loc
), old_rtx
, adjust_mems
,
1096 amd
->store
= store_save
;
1097 mem
= simplify_replace_fn_rtx (addr
, old_rtx
, adjust_mems
, data
);
1098 if (mem
== SUBREG_REG (loc
))
1103 tem
= simplify_gen_subreg (GET_MODE (loc
), mem
,
1104 GET_MODE (SUBREG_REG (loc
)),
1108 tem
= simplify_gen_subreg (GET_MODE (loc
), addr
,
1109 GET_MODE (SUBREG_REG (loc
)),
1111 if (tem
== NULL_RTX
)
1112 tem
= gen_rtx_raw_SUBREG (GET_MODE (loc
), addr
, SUBREG_BYTE (loc
));
1114 if (MAY_HAVE_DEBUG_INSNS
1115 && GET_CODE (tem
) == SUBREG
1116 && (GET_CODE (SUBREG_REG (tem
)) == PLUS
1117 || GET_CODE (SUBREG_REG (tem
)) == MINUS
1118 || GET_CODE (SUBREG_REG (tem
)) == MULT
1119 || GET_CODE (SUBREG_REG (tem
)) == ASHIFT
)
1120 && GET_MODE_CLASS (GET_MODE (tem
)) == MODE_INT
1121 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (tem
))) == MODE_INT
1122 && GET_MODE_SIZE (GET_MODE (tem
))
1123 < GET_MODE_SIZE (GET_MODE (SUBREG_REG (tem
)))
1124 && subreg_lowpart_p (tem
)
1125 && !for_each_rtx (&SUBREG_REG (tem
), use_narrower_mode_test
, tem
))
1126 return use_narrower_mode (SUBREG_REG (tem
), GET_MODE (tem
),
1127 GET_MODE (SUBREG_REG (tem
)));
1130 /* Don't do any replacements in second and following
1131 ASM_OPERANDS of inline-asm with multiple sets.
1132 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1133 and ASM_OPERANDS_LABEL_VEC need to be equal between
1134 all the ASM_OPERANDs in the insn and adjust_insn will
1136 if (ASM_OPERANDS_OUTPUT_IDX (loc
) != 0)
1145 /* Helper function for replacement of uses. */
1148 adjust_mem_uses (rtx
*x
, void *data
)
1150 rtx new_x
= simplify_replace_fn_rtx (*x
, NULL_RTX
, adjust_mems
, data
);
1152 validate_change (NULL_RTX
, x
, new_x
, true);
1155 /* Helper function for replacement of stores. */
1158 adjust_mem_stores (rtx loc
, const_rtx expr
, void *data
)
1162 rtx new_dest
= simplify_replace_fn_rtx (SET_DEST (expr
), NULL_RTX
,
1164 if (new_dest
!= SET_DEST (expr
))
1166 rtx xexpr
= CONST_CAST_RTX (expr
);
1167 validate_change (NULL_RTX
, &SET_DEST (xexpr
), new_dest
, true);
1172 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1173 replace them with their value in the insn and add the side-effects
1174 as other sets to the insn. */
1177 adjust_insn (basic_block bb
, rtx insn
)
1179 struct adjust_mem_data amd
;
1182 #ifdef HAVE_window_save
1183 /* If the target machine has an explicit window save instruction, the
1184 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1185 if (RTX_FRAME_RELATED_P (insn
)
1186 && find_reg_note (insn
, REG_CFA_WINDOW_SAVE
, NULL_RTX
))
1188 unsigned int i
, nregs
= vec_safe_length (windowed_parm_regs
);
1189 rtx rtl
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (nregs
* 2));
1192 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs
, i
, p
)
1194 XVECEXP (rtl
, 0, i
* 2)
1195 = gen_rtx_SET (VOIDmode
, p
->incoming
, p
->outgoing
);
1196 /* Do not clobber the attached DECL, but only the REG. */
1197 XVECEXP (rtl
, 0, i
* 2 + 1)
1198 = gen_rtx_CLOBBER (GET_MODE (p
->outgoing
),
1199 gen_raw_REG (GET_MODE (p
->outgoing
),
1200 REGNO (p
->outgoing
)));
1203 validate_change (NULL_RTX
, &PATTERN (insn
), rtl
, true);
1208 amd
.mem_mode
= VOIDmode
;
1209 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
1210 amd
.side_effects
= NULL_RTX
;
1213 note_stores (PATTERN (insn
), adjust_mem_stores
, &amd
);
1216 if (GET_CODE (PATTERN (insn
)) == PARALLEL
1217 && asm_noperands (PATTERN (insn
)) > 0
1218 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == SET
)
1223 /* inline-asm with multiple sets is tiny bit more complicated,
1224 because the 3 vectors in ASM_OPERANDS need to be shared between
1225 all ASM_OPERANDS in the instruction. adjust_mems will
1226 not touch ASM_OPERANDS other than the first one, asm_noperands
1227 test above needs to be called before that (otherwise it would fail)
1228 and afterwards this code fixes it up. */
1229 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1230 body
= PATTERN (insn
);
1231 set0
= XVECEXP (body
, 0, 0);
1232 gcc_checking_assert (GET_CODE (set0
) == SET
1233 && GET_CODE (SET_SRC (set0
)) == ASM_OPERANDS
1234 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0
)) == 0);
1235 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1236 if (GET_CODE (XVECEXP (body
, 0, i
)) != SET
)
1240 set
= XVECEXP (body
, 0, i
);
1241 gcc_checking_assert (GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
1242 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set
))
1244 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set
))
1245 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
))
1246 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set
))
1247 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
))
1248 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set
))
1249 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
)))
1251 rtx newsrc
= shallow_copy_rtx (SET_SRC (set
));
1252 ASM_OPERANDS_INPUT_VEC (newsrc
)
1253 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0
));
1254 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc
)
1255 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0
));
1256 ASM_OPERANDS_LABEL_VEC (newsrc
)
1257 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0
));
1258 validate_change (NULL_RTX
, &SET_SRC (set
), newsrc
, true);
1263 note_uses (&PATTERN (insn
), adjust_mem_uses
, &amd
);
1265 /* For read-only MEMs containing some constant, prefer those
1267 set
= single_set (insn
);
1268 if (set
&& MEM_P (SET_SRC (set
)) && MEM_READONLY_P (SET_SRC (set
)))
1270 rtx note
= find_reg_equal_equiv_note (insn
);
1272 if (note
&& CONSTANT_P (XEXP (note
, 0)))
1273 validate_change (NULL_RTX
, &SET_SRC (set
), XEXP (note
, 0), true);
1276 if (amd
.side_effects
)
1278 rtx
*pat
, new_pat
, s
;
1281 pat
= &PATTERN (insn
);
1282 if (GET_CODE (*pat
) == COND_EXEC
)
1283 pat
= &COND_EXEC_CODE (*pat
);
1284 if (GET_CODE (*pat
) == PARALLEL
)
1285 oldn
= XVECLEN (*pat
, 0);
1288 for (s
= amd
.side_effects
, newn
= 0; s
; newn
++)
1290 new_pat
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (oldn
+ newn
));
1291 if (GET_CODE (*pat
) == PARALLEL
)
1292 for (i
= 0; i
< oldn
; i
++)
1293 XVECEXP (new_pat
, 0, i
) = XVECEXP (*pat
, 0, i
);
1295 XVECEXP (new_pat
, 0, 0) = *pat
;
1296 for (s
= amd
.side_effects
, i
= oldn
; i
< oldn
+ newn
; i
++, s
= XEXP (s
, 1))
1297 XVECEXP (new_pat
, 0, i
) = XEXP (s
, 0);
1298 free_EXPR_LIST_list (&amd
.side_effects
);
1299 validate_change (NULL_RTX
, pat
, new_pat
, true);
1303 /* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1305 dv_as_rtx (decl_or_value dv
)
1309 if (dv_is_value_p (dv
))
1310 return dv_as_value (dv
);
1312 decl
= dv_as_decl (dv
);
1314 gcc_checking_assert (TREE_CODE (decl
) == DEBUG_EXPR_DECL
);
1315 return DECL_RTL_KNOWN_SET (decl
);
1318 /* Return nonzero if a decl_or_value must not have more than one
1319 variable part. The returned value discriminates among various
1320 kinds of one-part DVs ccording to enum onepart_enum. */
1321 static inline onepart_enum_t
1322 dv_onepart_p (decl_or_value dv
)
1326 if (!MAY_HAVE_DEBUG_INSNS
)
1329 if (dv_is_value_p (dv
))
1330 return ONEPART_VALUE
;
1332 decl
= dv_as_decl (dv
);
1334 if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
1335 return ONEPART_DEXPR
;
1337 if (target_for_debug_bind (decl
) != NULL_TREE
)
1338 return ONEPART_VDECL
;
1343 /* Return the variable pool to be used for a dv of type ONEPART. */
1344 static inline alloc_pool
1345 onepart_pool (onepart_enum_t onepart
)
1347 return onepart
? valvar_pool
: var_pool
;
1350 /* Build a decl_or_value out of a decl. */
1351 static inline decl_or_value
1352 dv_from_decl (tree decl
)
1356 gcc_checking_assert (dv_is_decl_p (dv
));
1360 /* Build a decl_or_value out of a value. */
1361 static inline decl_or_value
1362 dv_from_value (rtx value
)
1366 gcc_checking_assert (dv_is_value_p (dv
));
1370 /* Return a value or the decl of a debug_expr as a decl_or_value. */
1371 static inline decl_or_value
1376 switch (GET_CODE (x
))
1379 dv
= dv_from_decl (DEBUG_EXPR_TREE_DECL (x
));
1380 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x
)) == x
);
1384 dv
= dv_from_value (x
);
1394 extern void debug_dv (decl_or_value dv
);
1397 debug_dv (decl_or_value dv
)
1399 if (dv_is_value_p (dv
))
1400 debug_rtx (dv_as_value (dv
));
1402 debug_generic_stmt (dv_as_decl (dv
));
1405 static void loc_exp_dep_clear (variable var
);
1407 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1410 variable_htab_free (void *elem
)
1413 variable var
= (variable
) elem
;
1414 location_chain node
, next
;
1416 gcc_checking_assert (var
->refcount
> 0);
1419 if (var
->refcount
> 0)
1422 for (i
= 0; i
< var
->n_var_parts
; i
++)
1424 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= next
)
1427 pool_free (loc_chain_pool
, node
);
1429 var
->var_part
[i
].loc_chain
= NULL
;
1431 if (var
->onepart
&& VAR_LOC_1PAUX (var
))
1433 loc_exp_dep_clear (var
);
1434 if (VAR_LOC_DEP_LST (var
))
1435 VAR_LOC_DEP_LST (var
)->pprev
= NULL
;
1436 XDELETE (VAR_LOC_1PAUX (var
));
1437 /* These may be reused across functions, so reset
1439 if (var
->onepart
== ONEPART_DEXPR
)
1440 set_dv_changed (var
->dv
, true);
1442 pool_free (onepart_pool (var
->onepart
), var
);
1445 /* Initialize the set (array) SET of attrs to empty lists. */
1448 init_attrs_list_set (attrs
*set
)
1452 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1456 /* Make the list *LISTP empty. */
1459 attrs_list_clear (attrs
*listp
)
1463 for (list
= *listp
; list
; list
= next
)
1466 pool_free (attrs_pool
, list
);
1471 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1474 attrs_list_member (attrs list
, decl_or_value dv
, HOST_WIDE_INT offset
)
1476 for (; list
; list
= list
->next
)
1477 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
) && list
->offset
== offset
)
1482 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1485 attrs_list_insert (attrs
*listp
, decl_or_value dv
,
1486 HOST_WIDE_INT offset
, rtx loc
)
1490 list
= (attrs
) pool_alloc (attrs_pool
);
1493 list
->offset
= offset
;
1494 list
->next
= *listp
;
1498 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1501 attrs_list_copy (attrs
*dstp
, attrs src
)
1505 attrs_list_clear (dstp
);
1506 for (; src
; src
= src
->next
)
1508 n
= (attrs
) pool_alloc (attrs_pool
);
1511 n
->offset
= src
->offset
;
1517 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1520 attrs_list_union (attrs
*dstp
, attrs src
)
1522 for (; src
; src
= src
->next
)
1524 if (!attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1525 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1529 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1533 attrs_list_mpdv_union (attrs
*dstp
, attrs src
, attrs src2
)
1535 gcc_assert (!*dstp
);
1536 for (; src
; src
= src
->next
)
1538 if (!dv_onepart_p (src
->dv
))
1539 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1541 for (src
= src2
; src
; src
= src
->next
)
1543 if (!dv_onepart_p (src
->dv
)
1544 && !attrs_list_member (*dstp
, src
->dv
, src
->offset
))
1545 attrs_list_insert (dstp
, src
->dv
, src
->offset
, src
->loc
);
1549 /* Shared hashtable support. */
1551 /* Return true if VARS is shared. */
1554 shared_hash_shared (shared_hash vars
)
1556 return vars
->refcount
> 1;
1559 /* Return the hash table for VARS. */
1561 static inline variable_table_type
1562 shared_hash_htab (shared_hash vars
)
1567 /* Return true if VAR is shared, or maybe because VARS is shared. */
1570 shared_var_p (variable var
, shared_hash vars
)
1572 /* Don't count an entry in the changed_variables table as a duplicate. */
1573 return ((var
->refcount
> 1 + (int) var
->in_changed_variables
)
1574 || shared_hash_shared (vars
));
1577 /* Copy variables into a new hash table. */
1580 shared_hash_unshare (shared_hash vars
)
1582 shared_hash new_vars
= (shared_hash
) pool_alloc (shared_hash_pool
);
1583 gcc_assert (vars
->refcount
> 1);
1584 new_vars
->refcount
= 1;
1585 new_vars
->htab
.create (vars
->htab
.elements () + 3);
1586 vars_copy (new_vars
->htab
, vars
->htab
);
1591 /* Increment reference counter on VARS and return it. */
1593 static inline shared_hash
1594 shared_hash_copy (shared_hash vars
)
1600 /* Decrement reference counter and destroy hash table if not shared
1604 shared_hash_destroy (shared_hash vars
)
1606 gcc_checking_assert (vars
->refcount
> 0);
1607 if (--vars
->refcount
== 0)
1609 vars
->htab
.dispose ();
1610 pool_free (shared_hash_pool
, vars
);
1614 /* Unshare *PVARS if shared and return slot for DV. If INS is
1615 INSERT, insert it if not already present. */
1617 static inline variable_def
**
1618 shared_hash_find_slot_unshare_1 (shared_hash
*pvars
, decl_or_value dv
,
1619 hashval_t dvhash
, enum insert_option ins
)
1621 if (shared_hash_shared (*pvars
))
1622 *pvars
= shared_hash_unshare (*pvars
);
1623 return shared_hash_htab (*pvars
).find_slot_with_hash (dv
, dvhash
, ins
);
1626 static inline variable_def
**
1627 shared_hash_find_slot_unshare (shared_hash
*pvars
, decl_or_value dv
,
1628 enum insert_option ins
)
1630 return shared_hash_find_slot_unshare_1 (pvars
, dv
, dv_htab_hash (dv
), ins
);
1633 /* Return slot for DV, if it is already present in the hash table.
1634 If it is not present, insert it only VARS is not shared, otherwise
1637 static inline variable_def
**
1638 shared_hash_find_slot_1 (shared_hash vars
, decl_or_value dv
, hashval_t dvhash
)
1640 return shared_hash_htab (vars
).find_slot_with_hash (dv
, dvhash
,
1641 shared_hash_shared (vars
)
1642 ? NO_INSERT
: INSERT
);
1645 static inline variable_def
**
1646 shared_hash_find_slot (shared_hash vars
, decl_or_value dv
)
1648 return shared_hash_find_slot_1 (vars
, dv
, dv_htab_hash (dv
));
1651 /* Return slot for DV only if it is already present in the hash table. */
1653 static inline variable_def
**
1654 shared_hash_find_slot_noinsert_1 (shared_hash vars
, decl_or_value dv
,
1657 return shared_hash_htab (vars
).find_slot_with_hash (dv
, dvhash
, NO_INSERT
);
1660 static inline variable_def
**
1661 shared_hash_find_slot_noinsert (shared_hash vars
, decl_or_value dv
)
1663 return shared_hash_find_slot_noinsert_1 (vars
, dv
, dv_htab_hash (dv
));
1666 /* Return variable for DV or NULL if not already present in the hash
1669 static inline variable
1670 shared_hash_find_1 (shared_hash vars
, decl_or_value dv
, hashval_t dvhash
)
1672 return shared_hash_htab (vars
).find_with_hash (dv
, dvhash
);
1675 static inline variable
1676 shared_hash_find (shared_hash vars
, decl_or_value dv
)
1678 return shared_hash_find_1 (vars
, dv
, dv_htab_hash (dv
));
1681 /* Return true if TVAL is better than CVAL as a canonival value. We
1682 choose lowest-numbered VALUEs, using the RTX address as a
1683 tie-breaker. The idea is to arrange them into a star topology,
1684 such that all of them are at most one step away from the canonical
1685 value, and the canonical value has backlinks to all of them, in
1686 addition to all the actual locations. We don't enforce this
1687 topology throughout the entire dataflow analysis, though.
1691 canon_value_cmp (rtx tval
, rtx cval
)
1694 || CSELIB_VAL_PTR (tval
)->uid
< CSELIB_VAL_PTR (cval
)->uid
;
1697 static bool dst_can_be_shared
;
1699 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1701 static variable_def
**
1702 unshare_variable (dataflow_set
*set
, variable_def
**slot
, variable var
,
1703 enum var_init_status initialized
)
1708 new_var
= (variable
) pool_alloc (onepart_pool (var
->onepart
));
1709 new_var
->dv
= var
->dv
;
1710 new_var
->refcount
= 1;
1712 new_var
->n_var_parts
= var
->n_var_parts
;
1713 new_var
->onepart
= var
->onepart
;
1714 new_var
->in_changed_variables
= false;
1716 if (! flag_var_tracking_uninit
)
1717 initialized
= VAR_INIT_STATUS_INITIALIZED
;
1719 for (i
= 0; i
< var
->n_var_parts
; i
++)
1721 location_chain node
;
1722 location_chain
*nextp
;
1724 if (i
== 0 && var
->onepart
)
1726 /* One-part auxiliary data is only used while emitting
1727 notes, so propagate it to the new variable in the active
1728 dataflow set. If we're not emitting notes, this will be
1730 gcc_checking_assert (!VAR_LOC_1PAUX (var
) || emit_notes
);
1731 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (var
);
1732 VAR_LOC_1PAUX (var
) = NULL
;
1735 VAR_PART_OFFSET (new_var
, i
) = VAR_PART_OFFSET (var
, i
);
1736 nextp
= &new_var
->var_part
[i
].loc_chain
;
1737 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
1739 location_chain new_lc
;
1741 new_lc
= (location_chain
) pool_alloc (loc_chain_pool
);
1742 new_lc
->next
= NULL
;
1743 if (node
->init
> initialized
)
1744 new_lc
->init
= node
->init
;
1746 new_lc
->init
= initialized
;
1747 if (node
->set_src
&& !(MEM_P (node
->set_src
)))
1748 new_lc
->set_src
= node
->set_src
;
1750 new_lc
->set_src
= NULL
;
1751 new_lc
->loc
= node
->loc
;
1754 nextp
= &new_lc
->next
;
1757 new_var
->var_part
[i
].cur_loc
= var
->var_part
[i
].cur_loc
;
1760 dst_can_be_shared
= false;
1761 if (shared_hash_shared (set
->vars
))
1762 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
, NO_INSERT
);
1763 else if (set
->traversed_vars
&& set
->vars
!= set
->traversed_vars
)
1764 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
1766 if (var
->in_changed_variables
)
1768 variable_def
**cslot
1769 = changed_variables
.find_slot_with_hash (var
->dv
,
1770 dv_htab_hash (var
->dv
), NO_INSERT
);
1771 gcc_assert (*cslot
== (void *) var
);
1772 var
->in_changed_variables
= false;
1773 variable_htab_free (var
);
1775 new_var
->in_changed_variables
= true;
1780 /* Copy all variables from hash table SRC to hash table DST. */
1783 vars_copy (variable_table_type dst
, variable_table_type src
)
1785 variable_iterator_type hi
;
1788 FOR_EACH_HASH_TABLE_ELEMENT (src
, var
, variable
, hi
)
1790 variable_def
**dstp
;
1792 dstp
= dst
.find_slot_with_hash (var
->dv
, dv_htab_hash (var
->dv
), INSERT
);
1797 /* Map a decl to its main debug decl. */
1800 var_debug_decl (tree decl
)
1802 if (decl
&& TREE_CODE (decl
) == VAR_DECL
1803 && DECL_HAS_DEBUG_EXPR_P (decl
))
1805 tree debugdecl
= DECL_DEBUG_EXPR (decl
);
1806 if (DECL_P (debugdecl
))
1813 /* Set the register LOC to contain DV, OFFSET. */
1816 var_reg_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1817 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
1818 enum insert_option iopt
)
1821 bool decl_p
= dv_is_decl_p (dv
);
1824 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
1826 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
1827 if (dv_as_opaque (node
->dv
) == dv_as_opaque (dv
)
1828 && node
->offset
== offset
)
1831 attrs_list_insert (&set
->regs
[REGNO (loc
)], dv
, offset
, loc
);
1832 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
1835 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1838 var_reg_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
1841 tree decl
= REG_EXPR (loc
);
1842 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1844 var_reg_decl_set (set
, loc
, initialized
,
1845 dv_from_decl (decl
), offset
, set_src
, INSERT
);
1848 static enum var_init_status
1849 get_init_value (dataflow_set
*set
, rtx loc
, decl_or_value dv
)
1853 enum var_init_status ret_val
= VAR_INIT_STATUS_UNKNOWN
;
1855 if (! flag_var_tracking_uninit
)
1856 return VAR_INIT_STATUS_INITIALIZED
;
1858 var
= shared_hash_find (set
->vars
, dv
);
1861 for (i
= 0; i
< var
->n_var_parts
&& ret_val
== VAR_INIT_STATUS_UNKNOWN
; i
++)
1863 location_chain nextp
;
1864 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
; nextp
= nextp
->next
)
1865 if (rtx_equal_p (nextp
->loc
, loc
))
1867 ret_val
= nextp
->init
;
1876 /* Delete current content of register LOC in dataflow set SET and set
1877 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1878 MODIFY is true, any other live copies of the same variable part are
1879 also deleted from the dataflow set, otherwise the variable part is
1880 assumed to be copied from another location holding the same
1884 var_reg_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
1885 enum var_init_status initialized
, rtx set_src
)
1887 tree decl
= REG_EXPR (loc
);
1888 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1892 decl
= var_debug_decl (decl
);
1894 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
1895 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
1897 nextp
= &set
->regs
[REGNO (loc
)];
1898 for (node
= *nextp
; node
; node
= next
)
1901 if (dv_as_opaque (node
->dv
) != decl
|| node
->offset
!= offset
)
1903 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1904 pool_free (attrs_pool
, node
);
1910 nextp
= &node
->next
;
1914 clobber_variable_part (set
, loc
, dv_from_decl (decl
), offset
, set_src
);
1915 var_reg_set (set
, loc
, initialized
, set_src
);
1918 /* Delete the association of register LOC in dataflow set SET with any
1919 variables that aren't onepart. If CLOBBER is true, also delete any
1920 other live copies of the same variable part, and delete the
1921 association with onepart dvs too. */
1924 var_reg_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
1926 attrs
*nextp
= &set
->regs
[REGNO (loc
)];
1931 tree decl
= REG_EXPR (loc
);
1932 HOST_WIDE_INT offset
= REG_OFFSET (loc
);
1934 decl
= var_debug_decl (decl
);
1936 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
1939 for (node
= *nextp
; node
; node
= next
)
1942 if (clobber
|| !dv_onepart_p (node
->dv
))
1944 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1945 pool_free (attrs_pool
, node
);
1949 nextp
= &node
->next
;
1953 /* Delete content of register with number REGNO in dataflow set SET. */
1956 var_regno_delete (dataflow_set
*set
, int regno
)
1958 attrs
*reg
= &set
->regs
[regno
];
1961 for (node
= *reg
; node
; node
= next
)
1964 delete_variable_part (set
, node
->loc
, node
->dv
, node
->offset
);
1965 pool_free (attrs_pool
, node
);
1970 /* Return true if I is the negated value of a power of two. */
1972 negative_power_of_two_p (HOST_WIDE_INT i
)
1974 unsigned HOST_WIDE_INT x
= -(unsigned HOST_WIDE_INT
)i
;
1975 return x
== (x
& -x
);
1978 /* Strip constant offsets and alignments off of LOC. Return the base
1982 vt_get_canonicalize_base (rtx loc
)
1984 while ((GET_CODE (loc
) == PLUS
1985 || GET_CODE (loc
) == AND
)
1986 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
1987 && (GET_CODE (loc
) != AND
1988 || negative_power_of_two_p (INTVAL (XEXP (loc
, 1)))))
1989 loc
= XEXP (loc
, 0);
1994 /* This caches canonicalized addresses for VALUEs, computed using
1995 information in the global cselib table. */
1996 static struct pointer_map_t
*global_get_addr_cache
;
1998 /* This caches canonicalized addresses for VALUEs, computed using
1999 information from the global cache and information pertaining to a
2000 basic block being analyzed. */
2001 static struct pointer_map_t
*local_get_addr_cache
;
2003 static rtx
vt_canonicalize_addr (dataflow_set
*, rtx
);
2005 /* Return the canonical address for LOC, that must be a VALUE, using a
2006 cached global equivalence or computing it and storing it in the
2010 get_addr_from_global_cache (rtx
const loc
)
2015 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2017 slot
= pointer_map_insert (global_get_addr_cache
, loc
);
2021 x
= canon_rtx (get_addr (loc
));
2023 /* Tentative, avoiding infinite recursion. */
2028 rtx nx
= vt_canonicalize_addr (NULL
, x
);
2031 /* The table may have moved during recursion, recompute
2033 slot
= pointer_map_contains (global_get_addr_cache
, loc
);
2041 /* Return the canonical address for LOC, that must be a VALUE, using a
2042 cached local equivalence or computing it and storing it in the
2046 get_addr_from_local_cache (dataflow_set
*set
, rtx
const loc
)
2054 gcc_checking_assert (GET_CODE (loc
) == VALUE
);
2056 slot
= pointer_map_insert (local_get_addr_cache
, loc
);
2060 x
= get_addr_from_global_cache (loc
);
2062 /* Tentative, avoiding infinite recursion. */
2065 /* Recurse to cache local expansion of X, or if we need to search
2066 for a VALUE in the expansion. */
2069 rtx nx
= vt_canonicalize_addr (set
, x
);
2072 slot
= pointer_map_contains (local_get_addr_cache
, loc
);
2078 dv
= dv_from_rtx (x
);
2079 var
= shared_hash_find (set
->vars
, dv
);
2083 /* Look for an improved equivalent expression. */
2084 for (l
= var
->var_part
[0].loc_chain
; l
; l
= l
->next
)
2086 rtx base
= vt_get_canonicalize_base (l
->loc
);
2087 if (GET_CODE (base
) == VALUE
2088 && canon_value_cmp (base
, loc
))
2090 rtx nx
= vt_canonicalize_addr (set
, l
->loc
);
2093 slot
= pointer_map_contains (local_get_addr_cache
, loc
);
2103 /* Canonicalize LOC using equivalences from SET in addition to those
2104 in the cselib static table. It expects a VALUE-based expression,
2105 and it will only substitute VALUEs with other VALUEs or
2106 function-global equivalences, so that, if two addresses have base
2107 VALUEs that are locally or globally related in ways that
2108 memrefs_conflict_p cares about, they will both canonicalize to
2109 expressions that have the same base VALUE.
2111 The use of VALUEs as canonical base addresses enables the canonical
2112 RTXs to remain unchanged globally, if they resolve to a constant,
2113 or throughout a basic block otherwise, so that they can be cached
2114 and the cache needs not be invalidated when REGs, MEMs or such
2118 vt_canonicalize_addr (dataflow_set
*set
, rtx oloc
)
2120 HOST_WIDE_INT ofst
= 0;
2121 enum machine_mode mode
= GET_MODE (oloc
);
2128 while (GET_CODE (loc
) == PLUS
2129 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2131 ofst
+= INTVAL (XEXP (loc
, 1));
2132 loc
= XEXP (loc
, 0);
2135 /* Alignment operations can't normally be combined, so just
2136 canonicalize the base and we're done. We'll normally have
2137 only one stack alignment anyway. */
2138 if (GET_CODE (loc
) == AND
2139 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
2140 && negative_power_of_two_p (INTVAL (XEXP (loc
, 1))))
2142 x
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2143 if (x
!= XEXP (loc
, 0))
2144 loc
= gen_rtx_AND (mode
, x
, XEXP (loc
, 1));
2148 if (GET_CODE (loc
) == VALUE
)
2151 loc
= get_addr_from_local_cache (set
, loc
);
2153 loc
= get_addr_from_global_cache (loc
);
2155 /* Consolidate plus_constants. */
2156 while (ofst
&& GET_CODE (loc
) == PLUS
2157 && GET_CODE (XEXP (loc
, 1)) == CONST_INT
)
2159 ofst
+= INTVAL (XEXP (loc
, 1));
2160 loc
= XEXP (loc
, 0);
2167 x
= canon_rtx (loc
);
2174 /* Add OFST back in. */
2177 /* Don't build new RTL if we can help it. */
2178 if (GET_CODE (oloc
) == PLUS
2179 && XEXP (oloc
, 0) == loc
2180 && INTVAL (XEXP (oloc
, 1)) == ofst
)
2183 loc
= plus_constant (mode
, loc
, ofst
);
2189 /* Return true iff there's a true dependence between MLOC and LOC.
2190 MADDR must be a canonicalized version of MLOC's address. */
2193 vt_canon_true_dep (dataflow_set
*set
, rtx mloc
, rtx maddr
, rtx loc
)
2195 if (GET_CODE (loc
) != MEM
)
2198 rtx addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2199 if (!canon_true_dependence (mloc
, GET_MODE (mloc
), maddr
, loc
, addr
))
2205 /* Hold parameters for the hashtab traversal function
2206 drop_overlapping_mem_locs, see below. */
2208 struct overlapping_mems
2214 /* Remove all MEMs that overlap with COMS->LOC from the location list
2215 of a hash table entry for a value. COMS->ADDR must be a
2216 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2217 canonicalized itself. */
2220 drop_overlapping_mem_locs (variable_def
**slot
, overlapping_mems
*coms
)
2222 dataflow_set
*set
= coms
->set
;
2223 rtx mloc
= coms
->loc
, addr
= coms
->addr
;
2224 variable var
= *slot
;
2226 if (var
->onepart
== ONEPART_VALUE
)
2228 location_chain loc
, *locp
;
2229 bool changed
= false;
2232 gcc_assert (var
->n_var_parts
== 1);
2234 if (shared_var_p (var
, set
->vars
))
2236 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
2237 if (vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2243 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
2245 gcc_assert (var
->n_var_parts
== 1);
2248 if (VAR_LOC_1PAUX (var
))
2249 cur_loc
= VAR_LOC_FROM (var
);
2251 cur_loc
= var
->var_part
[0].cur_loc
;
2253 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
2256 if (!vt_canon_true_dep (set
, mloc
, addr
, loc
->loc
))
2263 /* If we have deleted the location which was last emitted
2264 we have to emit new location so add the variable to set
2265 of changed variables. */
2266 if (cur_loc
== loc
->loc
)
2269 var
->var_part
[0].cur_loc
= NULL
;
2270 if (VAR_LOC_1PAUX (var
))
2271 VAR_LOC_FROM (var
) = NULL
;
2273 pool_free (loc_chain_pool
, loc
);
2276 if (!var
->var_part
[0].loc_chain
)
2282 variable_was_changed (var
, set
);
2288 /* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2291 clobber_overlapping_mems (dataflow_set
*set
, rtx loc
)
2293 struct overlapping_mems coms
;
2295 gcc_checking_assert (GET_CODE (loc
) == MEM
);
2298 coms
.loc
= canon_rtx (loc
);
2299 coms
.addr
= vt_canonicalize_addr (set
, XEXP (loc
, 0));
2301 set
->traversed_vars
= set
->vars
;
2302 shared_hash_htab (set
->vars
)
2303 .traverse
<overlapping_mems
*, drop_overlapping_mem_locs
> (&coms
);
2304 set
->traversed_vars
= NULL
;
2307 /* Set the location of DV, OFFSET as the MEM LOC. */
2310 var_mem_decl_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2311 decl_or_value dv
, HOST_WIDE_INT offset
, rtx set_src
,
2312 enum insert_option iopt
)
2314 if (dv_is_decl_p (dv
))
2315 dv
= dv_from_decl (var_debug_decl (dv_as_decl (dv
)));
2317 set_variable_part (set
, loc
, dv
, offset
, initialized
, set_src
, iopt
);
2320 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2322 Adjust the address first if it is stack pointer based. */
2325 var_mem_set (dataflow_set
*set
, rtx loc
, enum var_init_status initialized
,
2328 tree decl
= MEM_EXPR (loc
);
2329 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2331 var_mem_decl_set (set
, loc
, initialized
,
2332 dv_from_decl (decl
), offset
, set_src
, INSERT
);
2335 /* Delete and set the location part of variable MEM_EXPR (LOC) in
2336 dataflow set SET to LOC. If MODIFY is true, any other live copies
2337 of the same variable part are also deleted from the dataflow set,
2338 otherwise the variable part is assumed to be copied from another
2339 location holding the same part.
2340 Adjust the address first if it is stack pointer based. */
2343 var_mem_delete_and_set (dataflow_set
*set
, rtx loc
, bool modify
,
2344 enum var_init_status initialized
, rtx set_src
)
2346 tree decl
= MEM_EXPR (loc
);
2347 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2349 clobber_overlapping_mems (set
, loc
);
2350 decl
= var_debug_decl (decl
);
2352 if (initialized
== VAR_INIT_STATUS_UNKNOWN
)
2353 initialized
= get_init_value (set
, loc
, dv_from_decl (decl
));
2356 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, set_src
);
2357 var_mem_set (set
, loc
, initialized
, set_src
);
2360 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
2361 true, also delete any other live copies of the same variable part.
2362 Adjust the address first if it is stack pointer based. */
2365 var_mem_delete (dataflow_set
*set
, rtx loc
, bool clobber
)
2367 tree decl
= MEM_EXPR (loc
);
2368 HOST_WIDE_INT offset
= INT_MEM_OFFSET (loc
);
2370 clobber_overlapping_mems (set
, loc
);
2371 decl
= var_debug_decl (decl
);
2373 clobber_variable_part (set
, NULL
, dv_from_decl (decl
), offset
, NULL
);
2374 delete_variable_part (set
, loc
, dv_from_decl (decl
), offset
);
2377 /* Return true if LOC should not be expanded for location expressions,
2381 unsuitable_loc (rtx loc
)
2383 switch (GET_CODE (loc
))
2397 /* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2401 val_bind (dataflow_set
*set
, rtx val
, rtx loc
, bool modified
)
2406 var_regno_delete (set
, REGNO (loc
));
2407 var_reg_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2408 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2410 else if (MEM_P (loc
))
2412 struct elt_loc_list
*l
= CSELIB_VAL_PTR (val
)->locs
;
2415 clobber_overlapping_mems (set
, loc
);
2417 if (l
&& GET_CODE (l
->loc
) == VALUE
)
2418 l
= canonical_cselib_val (CSELIB_VAL_PTR (l
->loc
))->locs
;
2420 /* If this MEM is a global constant, we don't need it in the
2421 dynamic tables. ??? We should test this before emitting the
2422 micro-op in the first place. */
2424 if (GET_CODE (l
->loc
) == MEM
&& XEXP (l
->loc
, 0) == XEXP (loc
, 0))
2430 var_mem_decl_set (set
, loc
, VAR_INIT_STATUS_INITIALIZED
,
2431 dv_from_value (val
), 0, NULL_RTX
, INSERT
);
2435 /* Other kinds of equivalences are necessarily static, at least
2436 so long as we do not perform substitutions while merging
2439 set_variable_part (set
, loc
, dv_from_value (val
), 0,
2440 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2444 /* Bind a value to a location it was just stored in. If MODIFIED
2445 holds, assume the location was modified, detaching it from any
2446 values bound to it. */
2449 val_store (dataflow_set
*set
, rtx val
, rtx loc
, rtx insn
, bool modified
)
2451 cselib_val
*v
= CSELIB_VAL_PTR (val
);
2453 gcc_assert (cselib_preserved_value_p (v
));
2457 fprintf (dump_file
, "%i: ", insn
? INSN_UID (insn
) : 0);
2458 print_inline_rtx (dump_file
, loc
, 0);
2459 fprintf (dump_file
, " evaluates to ");
2460 print_inline_rtx (dump_file
, val
, 0);
2463 struct elt_loc_list
*l
;
2464 for (l
= v
->locs
; l
; l
= l
->next
)
2466 fprintf (dump_file
, "\n%i: ", INSN_UID (l
->setting_insn
));
2467 print_inline_rtx (dump_file
, l
->loc
, 0);
2470 fprintf (dump_file
, "\n");
2473 gcc_checking_assert (!unsuitable_loc (loc
));
2475 val_bind (set
, val
, loc
, modified
);
2478 /* Clear (canonical address) slots that reference X. */
2481 local_get_addr_clear_given_value (const void *v ATTRIBUTE_UNUSED
,
2482 void **slot
, void *x
)
2485 && vt_get_canonicalize_base ((rtx
)*slot
) == x
)
2490 /* Reset this node, detaching all its equivalences. Return the slot
2491 in the variable hash table that holds dv, if there is one. */
2494 val_reset (dataflow_set
*set
, decl_or_value dv
)
2496 variable var
= shared_hash_find (set
->vars
, dv
) ;
2497 location_chain node
;
2500 if (!var
|| !var
->n_var_parts
)
2503 gcc_assert (var
->n_var_parts
== 1);
2505 if (var
->onepart
== ONEPART_VALUE
2506 && local_get_addr_cache
!= NULL
)
2508 rtx x
= dv_as_value (dv
);
2511 /* Relationships in the global cache don't change, so reset the
2512 local cache entry only. */
2513 slot
= pointer_map_contains (local_get_addr_cache
, x
);
2516 /* If the value resolved back to itself, odds are that other
2517 values may have cached it too. These entries now refer
2518 to the old X, so detach them too. Entries that used the
2519 old X but resolved to something else remain ok as long as
2520 that something else isn't also reset. */
2522 pointer_map_traverse (local_get_addr_cache
,
2523 local_get_addr_clear_given_value
, x
);
2529 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2530 if (GET_CODE (node
->loc
) == VALUE
2531 && canon_value_cmp (node
->loc
, cval
))
2534 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2535 if (GET_CODE (node
->loc
) == VALUE
&& cval
!= node
->loc
)
2537 /* Redirect the equivalence link to the new canonical
2538 value, or simply remove it if it would point at
2541 set_variable_part (set
, cval
, dv_from_value (node
->loc
),
2542 0, node
->init
, node
->set_src
, NO_INSERT
);
2543 delete_variable_part (set
, dv_as_value (dv
),
2544 dv_from_value (node
->loc
), 0);
2549 decl_or_value cdv
= dv_from_value (cval
);
2551 /* Keep the remaining values connected, accummulating links
2552 in the canonical value. */
2553 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
2555 if (node
->loc
== cval
)
2557 else if (GET_CODE (node
->loc
) == REG
)
2558 var_reg_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2559 node
->set_src
, NO_INSERT
);
2560 else if (GET_CODE (node
->loc
) == MEM
)
2561 var_mem_decl_set (set
, node
->loc
, node
->init
, cdv
, 0,
2562 node
->set_src
, NO_INSERT
);
2564 set_variable_part (set
, node
->loc
, cdv
, 0,
2565 node
->init
, node
->set_src
, NO_INSERT
);
2569 /* We remove this last, to make sure that the canonical value is not
2570 removed to the point of requiring reinsertion. */
2572 delete_variable_part (set
, dv_as_value (dv
), dv_from_value (cval
), 0);
2574 clobber_variable_part (set
, NULL
, dv
, 0, NULL
);
2577 /* Find the values in a given location and map the val to another
2578 value, if it is unique, or add the location as one holding the
2582 val_resolve (dataflow_set
*set
, rtx val
, rtx loc
, rtx insn
)
2584 decl_or_value dv
= dv_from_value (val
);
2586 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2589 fprintf (dump_file
, "%i: ", INSN_UID (insn
));
2591 fprintf (dump_file
, "head: ");
2592 print_inline_rtx (dump_file
, val
, 0);
2593 fputs (" is at ", dump_file
);
2594 print_inline_rtx (dump_file
, loc
, 0);
2595 fputc ('\n', dump_file
);
2598 val_reset (set
, dv
);
2600 gcc_checking_assert (!unsuitable_loc (loc
));
2604 attrs node
, found
= NULL
;
2606 for (node
= set
->regs
[REGNO (loc
)]; node
; node
= node
->next
)
2607 if (dv_is_value_p (node
->dv
)
2608 && GET_MODE (dv_as_value (node
->dv
)) == GET_MODE (loc
))
2612 /* Map incoming equivalences. ??? Wouldn't it be nice if
2613 we just started sharing the location lists? Maybe a
2614 circular list ending at the value itself or some
2616 set_variable_part (set
, dv_as_value (node
->dv
),
2617 dv_from_value (val
), node
->offset
,
2618 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2619 set_variable_part (set
, val
, node
->dv
, node
->offset
,
2620 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
, INSERT
);
2623 /* If we didn't find any equivalence, we need to remember that
2624 this value is held in the named register. */
2628 /* ??? Attempt to find and merge equivalent MEMs or other
2631 val_bind (set
, val
, loc
, false);
2634 /* Initialize dataflow set SET to be empty.
2635 VARS_SIZE is the initial size of hash table VARS. */
2638 dataflow_set_init (dataflow_set
*set
)
2640 init_attrs_list_set (set
->regs
);
2641 set
->vars
= shared_hash_copy (empty_shared_hash
);
2642 set
->stack_adjust
= 0;
2643 set
->traversed_vars
= NULL
;
2646 /* Delete the contents of dataflow set SET. */
2649 dataflow_set_clear (dataflow_set
*set
)
2653 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2654 attrs_list_clear (&set
->regs
[i
]);
2656 shared_hash_destroy (set
->vars
);
2657 set
->vars
= shared_hash_copy (empty_shared_hash
);
2660 /* Copy the contents of dataflow set SRC to DST. */
2663 dataflow_set_copy (dataflow_set
*dst
, dataflow_set
*src
)
2667 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2668 attrs_list_copy (&dst
->regs
[i
], src
->regs
[i
]);
2670 shared_hash_destroy (dst
->vars
);
2671 dst
->vars
= shared_hash_copy (src
->vars
);
2672 dst
->stack_adjust
= src
->stack_adjust
;
2675 /* Information for merging lists of locations for a given offset of variable.
2677 struct variable_union_info
2679 /* Node of the location chain. */
2682 /* The sum of positions in the input chains. */
2685 /* The position in the chain of DST dataflow set. */
2689 /* Buffer for location list sorting and its allocated size. */
2690 static struct variable_union_info
*vui_vec
;
2691 static int vui_allocated
;
2693 /* Compare function for qsort, order the structures by POS element. */
2696 variable_union_info_cmp_pos (const void *n1
, const void *n2
)
2698 const struct variable_union_info
*const i1
=
2699 (const struct variable_union_info
*) n1
;
2700 const struct variable_union_info
*const i2
=
2701 ( const struct variable_union_info
*) n2
;
2703 if (i1
->pos
!= i2
->pos
)
2704 return i1
->pos
- i2
->pos
;
2706 return (i1
->pos_dst
- i2
->pos_dst
);
2709 /* Compute union of location parts of variable *SLOT and the same variable
2710 from hash table DATA. Compute "sorted" union of the location chains
2711 for common offsets, i.e. the locations of a variable part are sorted by
2712 a priority where the priority is the sum of the positions in the 2 chains
2713 (if a location is only in one list the position in the second list is
2714 defined to be larger than the length of the chains).
2715 When we are updating the location parts the newest location is in the
2716 beginning of the chain, so when we do the described "sorted" union
2717 we keep the newest locations in the beginning. */
2720 variable_union (variable src
, dataflow_set
*set
)
2723 variable_def
**dstp
;
2726 dstp
= shared_hash_find_slot (set
->vars
, src
->dv
);
2727 if (!dstp
|| !*dstp
)
2731 dst_can_be_shared
= false;
2733 dstp
= shared_hash_find_slot_unshare (&set
->vars
, src
->dv
, INSERT
);
2737 /* Continue traversing the hash table. */
2743 gcc_assert (src
->n_var_parts
);
2744 gcc_checking_assert (src
->onepart
== dst
->onepart
);
2746 /* We can combine one-part variables very efficiently, because their
2747 entries are in canonical order. */
2750 location_chain
*nodep
, dnode
, snode
;
2752 gcc_assert (src
->n_var_parts
== 1
2753 && dst
->n_var_parts
== 1);
2755 snode
= src
->var_part
[0].loc_chain
;
2758 restart_onepart_unshared
:
2759 nodep
= &dst
->var_part
[0].loc_chain
;
2765 int r
= dnode
? loc_cmp (dnode
->loc
, snode
->loc
) : 1;
2769 location_chain nnode
;
2771 if (shared_var_p (dst
, set
->vars
))
2773 dstp
= unshare_variable (set
, dstp
, dst
,
2774 VAR_INIT_STATUS_INITIALIZED
);
2776 goto restart_onepart_unshared
;
2779 *nodep
= nnode
= (location_chain
) pool_alloc (loc_chain_pool
);
2780 nnode
->loc
= snode
->loc
;
2781 nnode
->init
= snode
->init
;
2782 if (!snode
->set_src
|| MEM_P (snode
->set_src
))
2783 nnode
->set_src
= NULL
;
2785 nnode
->set_src
= snode
->set_src
;
2786 nnode
->next
= dnode
;
2790 gcc_checking_assert (rtx_equal_p (dnode
->loc
, snode
->loc
));
2793 snode
= snode
->next
;
2795 nodep
= &dnode
->next
;
2802 gcc_checking_assert (!src
->onepart
);
2804 /* Count the number of location parts, result is K. */
2805 for (i
= 0, j
= 0, k
= 0;
2806 i
< src
->n_var_parts
&& j
< dst
->n_var_parts
; k
++)
2808 if (VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2813 else if (VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
2818 k
+= src
->n_var_parts
- i
;
2819 k
+= dst
->n_var_parts
- j
;
2821 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2822 thus there are at most MAX_VAR_PARTS different offsets. */
2823 gcc_checking_assert (dst
->onepart
? k
== 1 : k
<= MAX_VAR_PARTS
);
2825 if (dst
->n_var_parts
!= k
&& shared_var_p (dst
, set
->vars
))
2827 dstp
= unshare_variable (set
, dstp
, dst
, VAR_INIT_STATUS_UNKNOWN
);
2831 i
= src
->n_var_parts
- 1;
2832 j
= dst
->n_var_parts
- 1;
2833 dst
->n_var_parts
= k
;
2835 for (k
--; k
>= 0; k
--)
2837 location_chain node
, node2
;
2839 if (i
>= 0 && j
>= 0
2840 && VAR_PART_OFFSET (src
, i
) == VAR_PART_OFFSET (dst
, j
))
2842 /* Compute the "sorted" union of the chains, i.e. the locations which
2843 are in both chains go first, they are sorted by the sum of
2844 positions in the chains. */
2847 struct variable_union_info
*vui
;
2849 /* If DST is shared compare the location chains.
2850 If they are different we will modify the chain in DST with
2851 high probability so make a copy of DST. */
2852 if (shared_var_p (dst
, set
->vars
))
2854 for (node
= src
->var_part
[i
].loc_chain
,
2855 node2
= dst
->var_part
[j
].loc_chain
; node
&& node2
;
2856 node
= node
->next
, node2
= node2
->next
)
2858 if (!((REG_P (node2
->loc
)
2859 && REG_P (node
->loc
)
2860 && REGNO (node2
->loc
) == REGNO (node
->loc
))
2861 || rtx_equal_p (node2
->loc
, node
->loc
)))
2863 if (node2
->init
< node
->init
)
2864 node2
->init
= node
->init
;
2870 dstp
= unshare_variable (set
, dstp
, dst
,
2871 VAR_INIT_STATUS_UNKNOWN
);
2872 dst
= (variable
)*dstp
;
2877 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2880 for (node
= dst
->var_part
[j
].loc_chain
; node
; node
= node
->next
)
2885 /* The most common case, much simpler, no qsort is needed. */
2886 location_chain dstnode
= dst
->var_part
[j
].loc_chain
;
2887 dst
->var_part
[k
].loc_chain
= dstnode
;
2888 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
2890 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
2891 if (!((REG_P (dstnode
->loc
)
2892 && REG_P (node
->loc
)
2893 && REGNO (dstnode
->loc
) == REGNO (node
->loc
))
2894 || rtx_equal_p (dstnode
->loc
, node
->loc
)))
2896 location_chain new_node
;
2898 /* Copy the location from SRC. */
2899 new_node
= (location_chain
) pool_alloc (loc_chain_pool
);
2900 new_node
->loc
= node
->loc
;
2901 new_node
->init
= node
->init
;
2902 if (!node
->set_src
|| MEM_P (node
->set_src
))
2903 new_node
->set_src
= NULL
;
2905 new_node
->set_src
= node
->set_src
;
2906 node2
->next
= new_node
;
2913 if (src_l
+ dst_l
> vui_allocated
)
2915 vui_allocated
= MAX (vui_allocated
* 2, src_l
+ dst_l
);
2916 vui_vec
= XRESIZEVEC (struct variable_union_info
, vui_vec
,
2921 /* Fill in the locations from DST. */
2922 for (node
= dst
->var_part
[j
].loc_chain
, jj
= 0; node
;
2923 node
= node
->next
, jj
++)
2926 vui
[jj
].pos_dst
= jj
;
2928 /* Pos plus value larger than a sum of 2 valid positions. */
2929 vui
[jj
].pos
= jj
+ src_l
+ dst_l
;
2932 /* Fill in the locations from SRC. */
2934 for (node
= src
->var_part
[i
].loc_chain
, ii
= 0; node
;
2935 node
= node
->next
, ii
++)
2937 /* Find location from NODE. */
2938 for (jj
= 0; jj
< dst_l
; jj
++)
2940 if ((REG_P (vui
[jj
].lc
->loc
)
2941 && REG_P (node
->loc
)
2942 && REGNO (vui
[jj
].lc
->loc
) == REGNO (node
->loc
))
2943 || rtx_equal_p (vui
[jj
].lc
->loc
, node
->loc
))
2945 vui
[jj
].pos
= jj
+ ii
;
2949 if (jj
>= dst_l
) /* The location has not been found. */
2951 location_chain new_node
;
2953 /* Copy the location from SRC. */
2954 new_node
= (location_chain
) pool_alloc (loc_chain_pool
);
2955 new_node
->loc
= node
->loc
;
2956 new_node
->init
= node
->init
;
2957 if (!node
->set_src
|| MEM_P (node
->set_src
))
2958 new_node
->set_src
= NULL
;
2960 new_node
->set_src
= node
->set_src
;
2961 vui
[n
].lc
= new_node
;
2962 vui
[n
].pos_dst
= src_l
+ dst_l
;
2963 vui
[n
].pos
= ii
+ src_l
+ dst_l
;
2970 /* Special case still very common case. For dst_l == 2
2971 all entries dst_l ... n-1 are sorted, with for i >= dst_l
2972 vui[i].pos == i + src_l + dst_l. */
2973 if (vui
[0].pos
> vui
[1].pos
)
2975 /* Order should be 1, 0, 2... */
2976 dst
->var_part
[k
].loc_chain
= vui
[1].lc
;
2977 vui
[1].lc
->next
= vui
[0].lc
;
2980 vui
[0].lc
->next
= vui
[2].lc
;
2981 vui
[n
- 1].lc
->next
= NULL
;
2984 vui
[0].lc
->next
= NULL
;
2989 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
2990 if (n
>= 3 && vui
[2].pos
< vui
[1].pos
)
2992 /* Order should be 0, 2, 1, 3... */
2993 vui
[0].lc
->next
= vui
[2].lc
;
2994 vui
[2].lc
->next
= vui
[1].lc
;
2997 vui
[1].lc
->next
= vui
[3].lc
;
2998 vui
[n
- 1].lc
->next
= NULL
;
3001 vui
[1].lc
->next
= NULL
;
3006 /* Order should be 0, 1, 2... */
3008 vui
[n
- 1].lc
->next
= NULL
;
3011 for (; ii
< n
; ii
++)
3012 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3016 qsort (vui
, n
, sizeof (struct variable_union_info
),
3017 variable_union_info_cmp_pos
);
3019 /* Reconnect the nodes in sorted order. */
3020 for (ii
= 1; ii
< n
; ii
++)
3021 vui
[ii
- 1].lc
->next
= vui
[ii
].lc
;
3022 vui
[n
- 1].lc
->next
= NULL
;
3023 dst
->var_part
[k
].loc_chain
= vui
[0].lc
;
3026 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (dst
, j
);
3031 else if ((i
>= 0 && j
>= 0
3032 && VAR_PART_OFFSET (src
, i
) < VAR_PART_OFFSET (dst
, j
))
3035 dst
->var_part
[k
] = dst
->var_part
[j
];
3038 else if ((i
>= 0 && j
>= 0
3039 && VAR_PART_OFFSET (src
, i
) > VAR_PART_OFFSET (dst
, j
))
3042 location_chain
*nextp
;
3044 /* Copy the chain from SRC. */
3045 nextp
= &dst
->var_part
[k
].loc_chain
;
3046 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3048 location_chain new_lc
;
3050 new_lc
= (location_chain
) pool_alloc (loc_chain_pool
);
3051 new_lc
->next
= NULL
;
3052 new_lc
->init
= node
->init
;
3053 if (!node
->set_src
|| MEM_P (node
->set_src
))
3054 new_lc
->set_src
= NULL
;
3056 new_lc
->set_src
= node
->set_src
;
3057 new_lc
->loc
= node
->loc
;
3060 nextp
= &new_lc
->next
;
3063 VAR_PART_OFFSET (dst
, k
) = VAR_PART_OFFSET (src
, i
);
3066 dst
->var_part
[k
].cur_loc
= NULL
;
3069 if (flag_var_tracking_uninit
)
3070 for (i
= 0; i
< src
->n_var_parts
&& i
< dst
->n_var_parts
; i
++)
3072 location_chain node
, node2
;
3073 for (node
= src
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
3074 for (node2
= dst
->var_part
[i
].loc_chain
; node2
; node2
= node2
->next
)
3075 if (rtx_equal_p (node
->loc
, node2
->loc
))
3077 if (node
->init
> node2
->init
)
3078 node2
->init
= node
->init
;
3082 /* Continue traversing the hash table. */
3086 /* Compute union of dataflow sets SRC and DST and store it to DST. */
3089 dataflow_set_union (dataflow_set
*dst
, dataflow_set
*src
)
3093 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3094 attrs_list_union (&dst
->regs
[i
], src
->regs
[i
]);
3096 if (dst
->vars
== empty_shared_hash
)
3098 shared_hash_destroy (dst
->vars
);
3099 dst
->vars
= shared_hash_copy (src
->vars
);
3103 variable_iterator_type hi
;
3106 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (src
->vars
),
3108 variable_union (var
, dst
);
3112 /* Whether the value is currently being expanded. */
3113 #define VALUE_RECURSED_INTO(x) \
3114 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
3116 /* Whether no expansion was found, saving useless lookups.
3117 It must only be set when VALUE_CHANGED is clear. */
3118 #define NO_LOC_P(x) \
3119 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)->return_val)
3121 /* Whether cur_loc in the value needs to be (re)computed. */
3122 #define VALUE_CHANGED(x) \
3123 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
3124 /* Whether cur_loc in the decl needs to be (re)computed. */
3125 #define DECL_CHANGED(x) TREE_VISITED (x)
3127 /* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3128 user DECLs, this means they're in changed_variables. Values and
3129 debug exprs may be left with this flag set if no user variable
3130 requires them to be evaluated. */
3133 set_dv_changed (decl_or_value dv
, bool newv
)
3135 switch (dv_onepart_p (dv
))
3139 NO_LOC_P (dv_as_value (dv
)) = false;
3140 VALUE_CHANGED (dv_as_value (dv
)) = newv
;
3145 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv
))) = false;
3146 /* Fall through... */
3149 DECL_CHANGED (dv_as_decl (dv
)) = newv
;
3154 /* Return true if DV needs to have its cur_loc recomputed. */
3157 dv_changed_p (decl_or_value dv
)
3159 return (dv_is_value_p (dv
)
3160 ? VALUE_CHANGED (dv_as_value (dv
))
3161 : DECL_CHANGED (dv_as_decl (dv
)));
3164 /* Return a location list node whose loc is rtx_equal to LOC, in the
3165 location list of a one-part variable or value VAR, or in that of
3166 any values recursively mentioned in the location lists. VARS must
3167 be in star-canonical form. */
3169 static location_chain
3170 find_loc_in_1pdv (rtx loc
, variable var
, variable_table_type vars
)
3172 location_chain node
;
3173 enum rtx_code loc_code
;
3178 gcc_checking_assert (var
->onepart
);
3180 if (!var
->n_var_parts
)
3183 gcc_checking_assert (loc
!= dv_as_opaque (var
->dv
));
3185 loc_code
= GET_CODE (loc
);
3186 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3191 if (GET_CODE (node
->loc
) != loc_code
)
3193 if (GET_CODE (node
->loc
) != VALUE
)
3196 else if (loc
== node
->loc
)
3198 else if (loc_code
!= VALUE
)
3200 if (rtx_equal_p (loc
, node
->loc
))
3205 /* Since we're in star-canonical form, we don't need to visit
3206 non-canonical nodes: one-part variables and non-canonical
3207 values would only point back to the canonical node. */
3208 if (dv_is_value_p (var
->dv
)
3209 && !canon_value_cmp (node
->loc
, dv_as_value (var
->dv
)))
3211 /* Skip all subsequent VALUEs. */
3212 while (node
->next
&& GET_CODE (node
->next
->loc
) == VALUE
)
3215 gcc_checking_assert (!canon_value_cmp (node
->loc
,
3216 dv_as_value (var
->dv
)));
3217 if (loc
== node
->loc
)
3223 gcc_checking_assert (node
== var
->var_part
[0].loc_chain
);
3224 gcc_checking_assert (!node
->next
);
3226 dv
= dv_from_value (node
->loc
);
3227 rvar
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
3228 return find_loc_in_1pdv (loc
, rvar
, vars
);
3231 /* ??? Gotta look in cselib_val locations too. */
3236 /* Hash table iteration argument passed to variable_merge. */
3239 /* The set in which the merge is to be inserted. */
3241 /* The set that we're iterating in. */
3243 /* The set that may contain the other dv we are to merge with. */
3245 /* Number of onepart dvs in src. */
3246 int src_onepart_cnt
;
3249 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
3250 loc_cmp order, and it is maintained as such. */
3253 insert_into_intersection (location_chain
*nodep
, rtx loc
,
3254 enum var_init_status status
)
3256 location_chain node
;
3259 for (node
= *nodep
; node
; nodep
= &node
->next
, node
= *nodep
)
3260 if ((r
= loc_cmp (node
->loc
, loc
)) == 0)
3262 node
->init
= MIN (node
->init
, status
);
3268 node
= (location_chain
) pool_alloc (loc_chain_pool
);
3271 node
->set_src
= NULL
;
3272 node
->init
= status
;
3273 node
->next
= *nodep
;
3277 /* Insert in DEST the intersection of the locations present in both
3278 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3279 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3283 intersect_loc_chains (rtx val
, location_chain
*dest
, struct dfset_merge
*dsm
,
3284 location_chain s1node
, variable s2var
)
3286 dataflow_set
*s1set
= dsm
->cur
;
3287 dataflow_set
*s2set
= dsm
->src
;
3288 location_chain found
;
3292 location_chain s2node
;
3294 gcc_checking_assert (s2var
->onepart
);
3296 if (s2var
->n_var_parts
)
3298 s2node
= s2var
->var_part
[0].loc_chain
;
3300 for (; s1node
&& s2node
;
3301 s1node
= s1node
->next
, s2node
= s2node
->next
)
3302 if (s1node
->loc
!= s2node
->loc
)
3304 else if (s1node
->loc
== val
)
3307 insert_into_intersection (dest
, s1node
->loc
,
3308 MIN (s1node
->init
, s2node
->init
));
3312 for (; s1node
; s1node
= s1node
->next
)
3314 if (s1node
->loc
== val
)
3317 if ((found
= find_loc_in_1pdv (s1node
->loc
, s2var
,
3318 shared_hash_htab (s2set
->vars
))))
3320 insert_into_intersection (dest
, s1node
->loc
,
3321 MIN (s1node
->init
, found
->init
));
3325 if (GET_CODE (s1node
->loc
) == VALUE
3326 && !VALUE_RECURSED_INTO (s1node
->loc
))
3328 decl_or_value dv
= dv_from_value (s1node
->loc
);
3329 variable svar
= shared_hash_find (s1set
->vars
, dv
);
3332 if (svar
->n_var_parts
== 1)
3334 VALUE_RECURSED_INTO (s1node
->loc
) = true;
3335 intersect_loc_chains (val
, dest
, dsm
,
3336 svar
->var_part
[0].loc_chain
,
3338 VALUE_RECURSED_INTO (s1node
->loc
) = false;
3343 /* ??? gotta look in cselib_val locations too. */
3345 /* ??? if the location is equivalent to any location in src,
3346 searched recursively
3348 add to dst the values needed to represent the equivalence
3350 telling whether locations S is equivalent to another dv's
3353 for each location D in the list
3355 if S and D satisfy rtx_equal_p, then it is present
3357 else if D is a value, recurse without cycles
3359 else if S and D have the same CODE and MODE
3361 for each operand oS and the corresponding oD
3363 if oS and oD are not equivalent, then S an D are not equivalent
3365 else if they are RTX vectors
3367 if any vector oS element is not equivalent to its respective oD,
3368 then S and D are not equivalent
3376 /* Return -1 if X should be before Y in a location list for a 1-part
3377 variable, 1 if Y should be before X, and 0 if they're equivalent
3378 and should not appear in the list. */
3381 loc_cmp (rtx x
, rtx y
)
3384 RTX_CODE code
= GET_CODE (x
);
3394 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3395 if (REGNO (x
) == REGNO (y
))
3397 else if (REGNO (x
) < REGNO (y
))
3410 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3411 return loc_cmp (XEXP (x
, 0), XEXP (y
, 0));
3417 if (GET_CODE (x
) == VALUE
)
3419 if (GET_CODE (y
) != VALUE
)
3421 /* Don't assert the modes are the same, that is true only
3422 when not recursing. (subreg:QI (value:SI 1:1) 0)
3423 and (subreg:QI (value:DI 2:2) 0) can be compared,
3424 even when the modes are different. */
3425 if (canon_value_cmp (x
, y
))
3431 if (GET_CODE (y
) == VALUE
)
3434 /* Entry value is the least preferable kind of expression. */
3435 if (GET_CODE (x
) == ENTRY_VALUE
)
3437 if (GET_CODE (y
) != ENTRY_VALUE
)
3439 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3440 return loc_cmp (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
3443 if (GET_CODE (y
) == ENTRY_VALUE
)
3446 if (GET_CODE (x
) == GET_CODE (y
))
3447 /* Compare operands below. */;
3448 else if (GET_CODE (x
) < GET_CODE (y
))
3453 gcc_assert (GET_MODE (x
) == GET_MODE (y
));
3455 if (GET_CODE (x
) == DEBUG_EXPR
)
3457 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3458 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)))
3460 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
))
3461 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y
)));
3465 fmt
= GET_RTX_FORMAT (code
);
3466 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
3470 if (XWINT (x
, i
) == XWINT (y
, i
))
3472 else if (XWINT (x
, i
) < XWINT (y
, i
))
3479 if (XINT (x
, i
) == XINT (y
, i
))
3481 else if (XINT (x
, i
) < XINT (y
, i
))
3488 /* Compare the vector length first. */
3489 if (XVECLEN (x
, i
) == XVECLEN (y
, i
))
3490 /* Compare the vectors elements. */;
3491 else if (XVECLEN (x
, i
) < XVECLEN (y
, i
))
3496 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3497 if ((r
= loc_cmp (XVECEXP (x
, i
, j
),
3498 XVECEXP (y
, i
, j
))))
3503 if ((r
= loc_cmp (XEXP (x
, i
), XEXP (y
, i
))))
3509 if (XSTR (x
, i
) == XSTR (y
, i
))
3515 if ((r
= strcmp (XSTR (x
, i
), XSTR (y
, i
))) == 0)
3523 /* These are just backpointers, so they don't matter. */
3530 /* It is believed that rtx's at this level will never
3531 contain anything but integers and other rtx's,
3532 except for within LABEL_REFs and SYMBOL_REFs. */
3541 /* Check the order of entries in one-part variables. */
3544 canonicalize_loc_order_check (variable_def
**slot
,
3545 dataflow_set
*data ATTRIBUTE_UNUSED
)
3547 variable var
= *slot
;
3548 location_chain node
, next
;
3550 #ifdef ENABLE_RTL_CHECKING
3552 for (i
= 0; i
< var
->n_var_parts
; i
++)
3553 gcc_assert (var
->var_part
[0].cur_loc
== NULL
);
3554 gcc_assert (!var
->in_changed_variables
);
3560 gcc_assert (var
->n_var_parts
== 1);
3561 node
= var
->var_part
[0].loc_chain
;
3564 while ((next
= node
->next
))
3566 gcc_assert (loc_cmp (node
->loc
, next
->loc
) < 0);
3574 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3575 more likely to be chosen as canonical for an equivalence set.
3576 Ensure less likely values can reach more likely neighbors, making
3577 the connections bidirectional. */
3580 canonicalize_values_mark (variable_def
**slot
, dataflow_set
*set
)
3582 variable var
= *slot
;
3583 decl_or_value dv
= var
->dv
;
3585 location_chain node
;
3587 if (!dv_is_value_p (dv
))
3590 gcc_checking_assert (var
->n_var_parts
== 1);
3592 val
= dv_as_value (dv
);
3594 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3595 if (GET_CODE (node
->loc
) == VALUE
)
3597 if (canon_value_cmp (node
->loc
, val
))
3598 VALUE_RECURSED_INTO (val
) = true;
3601 decl_or_value odv
= dv_from_value (node
->loc
);
3602 variable_def
**oslot
;
3603 oslot
= shared_hash_find_slot_noinsert (set
->vars
, odv
);
3605 set_slot_part (set
, val
, oslot
, odv
, 0,
3606 node
->init
, NULL_RTX
);
3608 VALUE_RECURSED_INTO (node
->loc
) = true;
3615 /* Remove redundant entries from equivalence lists in onepart
3616 variables, canonicalizing equivalence sets into star shapes. */
3619 canonicalize_values_star (variable_def
**slot
, dataflow_set
*set
)
3621 variable var
= *slot
;
3622 decl_or_value dv
= var
->dv
;
3623 location_chain node
;
3626 variable_def
**cslot
;
3633 gcc_checking_assert (var
->n_var_parts
== 1);
3635 if (dv_is_value_p (dv
))
3637 cval
= dv_as_value (dv
);
3638 if (!VALUE_RECURSED_INTO (cval
))
3640 VALUE_RECURSED_INTO (cval
) = false;
3650 gcc_assert (var
->n_var_parts
== 1);
3652 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3653 if (GET_CODE (node
->loc
) == VALUE
)
3656 if (VALUE_RECURSED_INTO (node
->loc
))
3658 if (canon_value_cmp (node
->loc
, cval
))
3667 if (!has_marks
|| dv_is_decl_p (dv
))
3670 /* Keep it marked so that we revisit it, either after visiting a
3671 child node, or after visiting a new parent that might be
3673 VALUE_RECURSED_INTO (val
) = true;
3675 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3676 if (GET_CODE (node
->loc
) == VALUE
3677 && VALUE_RECURSED_INTO (node
->loc
))
3681 VALUE_RECURSED_INTO (cval
) = false;
3682 dv
= dv_from_value (cval
);
3683 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
3686 gcc_assert (dv_is_decl_p (var
->dv
));
3687 /* The canonical value was reset and dropped.
3689 clobber_variable_part (set
, NULL
, var
->dv
, 0, NULL
);
3693 gcc_assert (dv_is_value_p (var
->dv
));
3694 if (var
->n_var_parts
== 0)
3696 gcc_assert (var
->n_var_parts
== 1);
3700 VALUE_RECURSED_INTO (val
) = false;
3705 /* Push values to the canonical one. */
3706 cdv
= dv_from_value (cval
);
3707 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3709 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
3710 if (node
->loc
!= cval
)
3712 cslot
= set_slot_part (set
, node
->loc
, cslot
, cdv
, 0,
3713 node
->init
, NULL_RTX
);
3714 if (GET_CODE (node
->loc
) == VALUE
)
3716 decl_or_value ndv
= dv_from_value (node
->loc
);
3718 set_variable_part (set
, cval
, ndv
, 0, node
->init
, NULL_RTX
,
3721 if (canon_value_cmp (node
->loc
, val
))
3723 /* If it could have been a local minimum, it's not any more,
3724 since it's now neighbor to cval, so it may have to push
3725 to it. Conversely, if it wouldn't have prevailed over
3726 val, then whatever mark it has is fine: if it was to
3727 push, it will now push to a more canonical node, but if
3728 it wasn't, then it has already pushed any values it might
3730 VALUE_RECURSED_INTO (node
->loc
) = true;
3731 /* Make sure we visit node->loc by ensuring we cval is
3733 VALUE_RECURSED_INTO (cval
) = true;
3735 else if (!VALUE_RECURSED_INTO (node
->loc
))
3736 /* If we have no need to "recurse" into this node, it's
3737 already "canonicalized", so drop the link to the old
3739 clobber_variable_part (set
, cval
, ndv
, 0, NULL
);
3741 else if (GET_CODE (node
->loc
) == REG
)
3743 attrs list
= set
->regs
[REGNO (node
->loc
)], *listp
;
3745 /* Change an existing attribute referring to dv so that it
3746 refers to cdv, removing any duplicate this might
3747 introduce, and checking that no previous duplicates
3748 existed, all in a single pass. */
3752 if (list
->offset
== 0
3753 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3754 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3761 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3764 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3769 if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3771 *listp
= list
->next
;
3772 pool_free (attrs_pool
, list
);
3777 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (dv
));
3780 else if (dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
))
3782 for (listp
= &list
->next
; (list
= *listp
); listp
= &list
->next
)
3787 if (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
))
3789 *listp
= list
->next
;
3790 pool_free (attrs_pool
, list
);
3795 gcc_assert (dv_as_opaque (list
->dv
) != dv_as_opaque (cdv
));
3804 if (list
->offset
== 0
3805 && (dv_as_opaque (list
->dv
) == dv_as_opaque (dv
)
3806 || dv_as_opaque (list
->dv
) == dv_as_opaque (cdv
)))
3816 set_slot_part (set
, val
, cslot
, cdv
, 0,
3817 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
);
3819 slot
= clobber_slot_part (set
, cval
, slot
, 0, NULL
);
3821 /* Variable may have been unshared. */
3823 gcc_checking_assert (var
->n_var_parts
&& var
->var_part
[0].loc_chain
->loc
== cval
3824 && var
->var_part
[0].loc_chain
->next
== NULL
);
3826 if (VALUE_RECURSED_INTO (cval
))
3827 goto restart_with_cval
;
3832 /* Bind one-part variables to the canonical value in an equivalence
3833 set. Not doing this causes dataflow convergence failure in rare
3834 circumstances, see PR42873. Unfortunately we can't do this
3835 efficiently as part of canonicalize_values_star, since we may not
3836 have determined or even seen the canonical value of a set when we
3837 get to a variable that references another member of the set. */
3840 canonicalize_vars_star (variable_def
**slot
, dataflow_set
*set
)
3842 variable var
= *slot
;
3843 decl_or_value dv
= var
->dv
;
3844 location_chain node
;
3847 variable_def
**cslot
;
3849 location_chain cnode
;
3851 if (!var
->onepart
|| var
->onepart
== ONEPART_VALUE
)
3854 gcc_assert (var
->n_var_parts
== 1);
3856 node
= var
->var_part
[0].loc_chain
;
3858 if (GET_CODE (node
->loc
) != VALUE
)
3861 gcc_assert (!node
->next
);
3864 /* Push values to the canonical one. */
3865 cdv
= dv_from_value (cval
);
3866 cslot
= shared_hash_find_slot_noinsert (set
->vars
, cdv
);
3870 gcc_assert (cvar
->n_var_parts
== 1);
3872 cnode
= cvar
->var_part
[0].loc_chain
;
3874 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3875 that are not “more canonical” than it. */
3876 if (GET_CODE (cnode
->loc
) != VALUE
3877 || !canon_value_cmp (cnode
->loc
, cval
))
3880 /* CVAL was found to be non-canonical. Change the variable to point
3881 to the canonical VALUE. */
3882 gcc_assert (!cnode
->next
);
3885 slot
= set_slot_part (set
, cval
, slot
, dv
, 0,
3886 node
->init
, node
->set_src
);
3887 clobber_slot_part (set
, cval
, slot
, 0, node
->set_src
);
3892 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3893 corresponding entry in DSM->src. Multi-part variables are combined
3894 with variable_union, whereas onepart dvs are combined with
3898 variable_merge_over_cur (variable s1var
, struct dfset_merge
*dsm
)
3900 dataflow_set
*dst
= dsm
->dst
;
3901 variable_def
**dstslot
;
3902 variable s2var
, dvar
= NULL
;
3903 decl_or_value dv
= s1var
->dv
;
3904 onepart_enum_t onepart
= s1var
->onepart
;
3907 location_chain node
, *nodep
;
3909 /* If the incoming onepart variable has an empty location list, then
3910 the intersection will be just as empty. For other variables,
3911 it's always union. */
3912 gcc_checking_assert (s1var
->n_var_parts
3913 && s1var
->var_part
[0].loc_chain
);
3916 return variable_union (s1var
, dst
);
3918 gcc_checking_assert (s1var
->n_var_parts
== 1);
3920 dvhash
= dv_htab_hash (dv
);
3921 if (dv_is_value_p (dv
))
3922 val
= dv_as_value (dv
);
3926 s2var
= shared_hash_find_1 (dsm
->src
->vars
, dv
, dvhash
);
3929 dst_can_be_shared
= false;
3933 dsm
->src_onepart_cnt
--;
3934 gcc_assert (s2var
->var_part
[0].loc_chain
3935 && s2var
->onepart
== onepart
3936 && s2var
->n_var_parts
== 1);
3938 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
3942 gcc_assert (dvar
->refcount
== 1
3943 && dvar
->onepart
== onepart
3944 && dvar
->n_var_parts
== 1);
3945 nodep
= &dvar
->var_part
[0].loc_chain
;
3953 if (!dstslot
&& !onepart_variable_different_p (s1var
, s2var
))
3955 dstslot
= shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
,
3957 *dstslot
= dvar
= s2var
;
3962 dst_can_be_shared
= false;
3964 intersect_loc_chains (val
, nodep
, dsm
,
3965 s1var
->var_part
[0].loc_chain
, s2var
);
3971 dvar
= (variable
) pool_alloc (onepart_pool (onepart
));
3974 dvar
->n_var_parts
= 1;
3975 dvar
->onepart
= onepart
;
3976 dvar
->in_changed_variables
= false;
3977 dvar
->var_part
[0].loc_chain
= node
;
3978 dvar
->var_part
[0].cur_loc
= NULL
;
3980 VAR_LOC_1PAUX (dvar
) = NULL
;
3982 VAR_PART_OFFSET (dvar
, 0) = 0;
3985 = shared_hash_find_slot_unshare_1 (&dst
->vars
, dv
, dvhash
,
3987 gcc_assert (!*dstslot
);
3995 nodep
= &dvar
->var_part
[0].loc_chain
;
3996 while ((node
= *nodep
))
3998 location_chain
*nextp
= &node
->next
;
4000 if (GET_CODE (node
->loc
) == REG
)
4004 for (list
= dst
->regs
[REGNO (node
->loc
)]; list
; list
= list
->next
)
4005 if (GET_MODE (node
->loc
) == GET_MODE (list
->loc
)
4006 && dv_is_value_p (list
->dv
))
4010 attrs_list_insert (&dst
->regs
[REGNO (node
->loc
)],
4012 /* If this value became canonical for another value that had
4013 this register, we want to leave it alone. */
4014 else if (dv_as_value (list
->dv
) != val
)
4016 dstslot
= set_slot_part (dst
, dv_as_value (list
->dv
),
4018 node
->init
, NULL_RTX
);
4019 dstslot
= delete_slot_part (dst
, node
->loc
, dstslot
, 0);
4021 /* Since nextp points into the removed node, we can't
4022 use it. The pointer to the next node moved to nodep.
4023 However, if the variable we're walking is unshared
4024 during our walk, we'll keep walking the location list
4025 of the previously-shared variable, in which case the
4026 node won't have been removed, and we'll want to skip
4027 it. That's why we test *nodep here. */
4033 /* Canonicalization puts registers first, so we don't have to
4039 if (dvar
!= *dstslot
)
4041 nodep
= &dvar
->var_part
[0].loc_chain
;
4045 /* Mark all referenced nodes for canonicalization, and make sure
4046 we have mutual equivalence links. */
4047 VALUE_RECURSED_INTO (val
) = true;
4048 for (node
= *nodep
; node
; node
= node
->next
)
4049 if (GET_CODE (node
->loc
) == VALUE
)
4051 VALUE_RECURSED_INTO (node
->loc
) = true;
4052 set_variable_part (dst
, val
, dv_from_value (node
->loc
), 0,
4053 node
->init
, NULL
, INSERT
);
4056 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4057 gcc_assert (*dstslot
== dvar
);
4058 canonicalize_values_star (dstslot
, dst
);
4059 gcc_checking_assert (dstslot
4060 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4066 bool has_value
= false, has_other
= false;
4068 /* If we have one value and anything else, we're going to
4069 canonicalize this, so make sure all values have an entry in
4070 the table and are marked for canonicalization. */
4071 for (node
= *nodep
; node
; node
= node
->next
)
4073 if (GET_CODE (node
->loc
) == VALUE
)
4075 /* If this was marked during register canonicalization,
4076 we know we have to canonicalize values. */
4091 if (has_value
&& has_other
)
4093 for (node
= *nodep
; node
; node
= node
->next
)
4095 if (GET_CODE (node
->loc
) == VALUE
)
4097 decl_or_value dv
= dv_from_value (node
->loc
);
4098 variable_def
**slot
= NULL
;
4100 if (shared_hash_shared (dst
->vars
))
4101 slot
= shared_hash_find_slot_noinsert (dst
->vars
, dv
);
4103 slot
= shared_hash_find_slot_unshare (&dst
->vars
, dv
,
4107 variable var
= (variable
) pool_alloc (onepart_pool
4111 var
->n_var_parts
= 1;
4112 var
->onepart
= ONEPART_VALUE
;
4113 var
->in_changed_variables
= false;
4114 var
->var_part
[0].loc_chain
= NULL
;
4115 var
->var_part
[0].cur_loc
= NULL
;
4116 VAR_LOC_1PAUX (var
) = NULL
;
4120 VALUE_RECURSED_INTO (node
->loc
) = true;
4124 dstslot
= shared_hash_find_slot_noinsert_1 (dst
->vars
, dv
, dvhash
);
4125 gcc_assert (*dstslot
== dvar
);
4126 canonicalize_values_star (dstslot
, dst
);
4127 gcc_checking_assert (dstslot
4128 == shared_hash_find_slot_noinsert_1 (dst
->vars
,
4134 if (!onepart_variable_different_p (dvar
, s2var
))
4136 variable_htab_free (dvar
);
4137 *dstslot
= dvar
= s2var
;
4140 else if (s2var
!= s1var
&& !onepart_variable_different_p (dvar
, s1var
))
4142 variable_htab_free (dvar
);
4143 *dstslot
= dvar
= s1var
;
4145 dst_can_be_shared
= false;
4148 dst_can_be_shared
= false;
4153 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4154 multi-part variable. Unions of multi-part variables and
4155 intersections of one-part ones will be handled in
4156 variable_merge_over_cur(). */
4159 variable_merge_over_src (variable s2var
, struct dfset_merge
*dsm
)
4161 dataflow_set
*dst
= dsm
->dst
;
4162 decl_or_value dv
= s2var
->dv
;
4164 if (!s2var
->onepart
)
4166 variable_def
**dstp
= shared_hash_find_slot (dst
->vars
, dv
);
4172 dsm
->src_onepart_cnt
++;
4176 /* Combine dataflow set information from SRC2 into DST, using PDST
4177 to carry over information across passes. */
4180 dataflow_set_merge (dataflow_set
*dst
, dataflow_set
*src2
)
4182 dataflow_set cur
= *dst
;
4183 dataflow_set
*src1
= &cur
;
4184 struct dfset_merge dsm
;
4186 size_t src1_elems
, src2_elems
;
4187 variable_iterator_type hi
;
4190 src1_elems
= shared_hash_htab (src1
->vars
).elements ();
4191 src2_elems
= shared_hash_htab (src2
->vars
).elements ();
4192 dataflow_set_init (dst
);
4193 dst
->stack_adjust
= cur
.stack_adjust
;
4194 shared_hash_destroy (dst
->vars
);
4195 dst
->vars
= (shared_hash
) pool_alloc (shared_hash_pool
);
4196 dst
->vars
->refcount
= 1;
4197 dst
->vars
->htab
.create (MAX (src1_elems
, src2_elems
));
4199 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4200 attrs_list_mpdv_union (&dst
->regs
[i
], src1
->regs
[i
], src2
->regs
[i
]);
4205 dsm
.src_onepart_cnt
= 0;
4207 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm
.src
->vars
),
4209 variable_merge_over_src (var
, &dsm
);
4210 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm
.cur
->vars
),
4212 variable_merge_over_cur (var
, &dsm
);
4214 if (dsm
.src_onepart_cnt
)
4215 dst_can_be_shared
= false;
4217 dataflow_set_destroy (src1
);
4220 /* Mark register equivalences. */
4223 dataflow_set_equiv_regs (dataflow_set
*set
)
4228 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4230 rtx canon
[NUM_MACHINE_MODES
];
4232 /* If the list is empty or one entry, no need to canonicalize
4234 if (set
->regs
[i
] == NULL
|| set
->regs
[i
]->next
== NULL
)
4237 memset (canon
, 0, sizeof (canon
));
4239 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4240 if (list
->offset
== 0 && dv_is_value_p (list
->dv
))
4242 rtx val
= dv_as_value (list
->dv
);
4243 rtx
*cvalp
= &canon
[(int)GET_MODE (val
)];
4246 if (canon_value_cmp (val
, cval
))
4250 for (list
= set
->regs
[i
]; list
; list
= list
->next
)
4251 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4253 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4258 if (dv_is_value_p (list
->dv
))
4260 rtx val
= dv_as_value (list
->dv
);
4265 VALUE_RECURSED_INTO (val
) = true;
4266 set_variable_part (set
, val
, dv_from_value (cval
), 0,
4267 VAR_INIT_STATUS_INITIALIZED
,
4271 VALUE_RECURSED_INTO (cval
) = true;
4272 set_variable_part (set
, cval
, list
->dv
, 0,
4273 VAR_INIT_STATUS_INITIALIZED
, NULL
, NO_INSERT
);
4276 for (listp
= &set
->regs
[i
]; (list
= *listp
);
4277 listp
= list
? &list
->next
: listp
)
4278 if (list
->offset
== 0 && dv_onepart_p (list
->dv
))
4280 rtx cval
= canon
[(int)GET_MODE (list
->loc
)];
4281 variable_def
**slot
;
4286 if (dv_is_value_p (list
->dv
))
4288 rtx val
= dv_as_value (list
->dv
);
4289 if (!VALUE_RECURSED_INTO (val
))
4293 slot
= shared_hash_find_slot_noinsert (set
->vars
, list
->dv
);
4294 canonicalize_values_star (slot
, set
);
4301 /* Remove any redundant values in the location list of VAR, which must
4302 be unshared and 1-part. */
4305 remove_duplicate_values (variable var
)
4307 location_chain node
, *nodep
;
4309 gcc_assert (var
->onepart
);
4310 gcc_assert (var
->n_var_parts
== 1);
4311 gcc_assert (var
->refcount
== 1);
4313 for (nodep
= &var
->var_part
[0].loc_chain
; (node
= *nodep
); )
4315 if (GET_CODE (node
->loc
) == VALUE
)
4317 if (VALUE_RECURSED_INTO (node
->loc
))
4319 /* Remove duplicate value node. */
4320 *nodep
= node
->next
;
4321 pool_free (loc_chain_pool
, node
);
4325 VALUE_RECURSED_INTO (node
->loc
) = true;
4327 nodep
= &node
->next
;
4330 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4331 if (GET_CODE (node
->loc
) == VALUE
)
4333 gcc_assert (VALUE_RECURSED_INTO (node
->loc
));
4334 VALUE_RECURSED_INTO (node
->loc
) = false;
4339 /* Hash table iteration argument passed to variable_post_merge. */
4340 struct dfset_post_merge
4342 /* The new input set for the current block. */
4344 /* Pointer to the permanent input set for the current block, or
4346 dataflow_set
**permp
;
4349 /* Create values for incoming expressions associated with one-part
4350 variables that don't have value numbers for them. */
4353 variable_post_merge_new_vals (variable_def
**slot
, dfset_post_merge
*dfpm
)
4355 dataflow_set
*set
= dfpm
->set
;
4356 variable var
= *slot
;
4357 location_chain node
;
4359 if (!var
->onepart
|| !var
->n_var_parts
)
4362 gcc_assert (var
->n_var_parts
== 1);
4364 if (dv_is_decl_p (var
->dv
))
4366 bool check_dupes
= false;
4369 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4371 if (GET_CODE (node
->loc
) == VALUE
)
4372 gcc_assert (!VALUE_RECURSED_INTO (node
->loc
));
4373 else if (GET_CODE (node
->loc
) == REG
)
4375 attrs att
, *attp
, *curp
= NULL
;
4377 if (var
->refcount
!= 1)
4379 slot
= unshare_variable (set
, slot
, var
,
4380 VAR_INIT_STATUS_INITIALIZED
);
4385 for (attp
= &set
->regs
[REGNO (node
->loc
)]; (att
= *attp
);
4387 if (att
->offset
== 0
4388 && GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4390 if (dv_is_value_p (att
->dv
))
4392 rtx cval
= dv_as_value (att
->dv
);
4397 else if (dv_as_opaque (att
->dv
) == dv_as_opaque (var
->dv
))
4405 if ((*curp
)->offset
== 0
4406 && GET_MODE ((*curp
)->loc
) == GET_MODE (node
->loc
)
4407 && dv_as_opaque ((*curp
)->dv
) == dv_as_opaque (var
->dv
))
4410 curp
= &(*curp
)->next
;
4421 *dfpm
->permp
= XNEW (dataflow_set
);
4422 dataflow_set_init (*dfpm
->permp
);
4425 for (att
= (*dfpm
->permp
)->regs
[REGNO (node
->loc
)];
4426 att
; att
= att
->next
)
4427 if (GET_MODE (att
->loc
) == GET_MODE (node
->loc
))
4429 gcc_assert (att
->offset
== 0
4430 && dv_is_value_p (att
->dv
));
4431 val_reset (set
, att
->dv
);
4438 cval
= dv_as_value (cdv
);
4442 /* Create a unique value to hold this register,
4443 that ought to be found and reused in
4444 subsequent rounds. */
4446 gcc_assert (!cselib_lookup (node
->loc
,
4447 GET_MODE (node
->loc
), 0,
4449 v
= cselib_lookup (node
->loc
, GET_MODE (node
->loc
), 1,
4451 cselib_preserve_value (v
);
4452 cselib_invalidate_rtx (node
->loc
);
4454 cdv
= dv_from_value (cval
);
4457 "Created new value %u:%u for reg %i\n",
4458 v
->uid
, v
->hash
, REGNO (node
->loc
));
4461 var_reg_decl_set (*dfpm
->permp
, node
->loc
,
4462 VAR_INIT_STATUS_INITIALIZED
,
4463 cdv
, 0, NULL
, INSERT
);
4469 /* Remove attribute referring to the decl, which now
4470 uses the value for the register, already existing or
4471 to be added when we bring perm in. */
4474 pool_free (attrs_pool
, att
);
4479 remove_duplicate_values (var
);
4485 /* Reset values in the permanent set that are not associated with the
4486 chosen expression. */
4489 variable_post_merge_perm_vals (variable_def
**pslot
, dfset_post_merge
*dfpm
)
4491 dataflow_set
*set
= dfpm
->set
;
4492 variable pvar
= *pslot
, var
;
4493 location_chain pnode
;
4497 gcc_assert (dv_is_value_p (pvar
->dv
)
4498 && pvar
->n_var_parts
== 1);
4499 pnode
= pvar
->var_part
[0].loc_chain
;
4502 && REG_P (pnode
->loc
));
4506 var
= shared_hash_find (set
->vars
, dv
);
4509 /* Although variable_post_merge_new_vals may have made decls
4510 non-star-canonical, values that pre-existed in canonical form
4511 remain canonical, and newly-created values reference a single
4512 REG, so they are canonical as well. Since VAR has the
4513 location list for a VALUE, using find_loc_in_1pdv for it is
4514 fine, since VALUEs don't map back to DECLs. */
4515 if (find_loc_in_1pdv (pnode
->loc
, var
, shared_hash_htab (set
->vars
)))
4517 val_reset (set
, dv
);
4520 for (att
= set
->regs
[REGNO (pnode
->loc
)]; att
; att
= att
->next
)
4521 if (att
->offset
== 0
4522 && GET_MODE (att
->loc
) == GET_MODE (pnode
->loc
)
4523 && dv_is_value_p (att
->dv
))
4526 /* If there is a value associated with this register already, create
4528 if (att
&& dv_as_value (att
->dv
) != dv_as_value (dv
))
4530 rtx cval
= dv_as_value (att
->dv
);
4531 set_variable_part (set
, cval
, dv
, 0, pnode
->init
, NULL
, INSERT
);
4532 set_variable_part (set
, dv_as_value (dv
), att
->dv
, 0, pnode
->init
,
4537 attrs_list_insert (&set
->regs
[REGNO (pnode
->loc
)],
4539 variable_union (pvar
, set
);
4545 /* Just checking stuff and registering register attributes for
4549 dataflow_post_merge_adjust (dataflow_set
*set
, dataflow_set
**permp
)
4551 struct dfset_post_merge dfpm
;
4556 shared_hash_htab (set
->vars
)
4557 .traverse
<dfset_post_merge
*, variable_post_merge_new_vals
> (&dfpm
);
4559 shared_hash_htab ((*permp
)->vars
)
4560 .traverse
<dfset_post_merge
*, variable_post_merge_perm_vals
> (&dfpm
);
4561 shared_hash_htab (set
->vars
)
4562 .traverse
<dataflow_set
*, canonicalize_values_star
> (set
);
4563 shared_hash_htab (set
->vars
)
4564 .traverse
<dataflow_set
*, canonicalize_vars_star
> (set
);
4567 /* Return a node whose loc is a MEM that refers to EXPR in the
4568 location list of a one-part variable or value VAR, or in that of
4569 any values recursively mentioned in the location lists. */
4571 static location_chain
4572 find_mem_expr_in_1pdv (tree expr
, rtx val
, variable_table_type vars
)
4574 location_chain node
;
4577 location_chain where
= NULL
;
4582 gcc_assert (GET_CODE (val
) == VALUE
4583 && !VALUE_RECURSED_INTO (val
));
4585 dv
= dv_from_value (val
);
4586 var
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
4591 gcc_assert (var
->onepart
);
4593 if (!var
->n_var_parts
)
4596 VALUE_RECURSED_INTO (val
) = true;
4598 for (node
= var
->var_part
[0].loc_chain
; node
; node
= node
->next
)
4599 if (MEM_P (node
->loc
)
4600 && MEM_EXPR (node
->loc
) == expr
4601 && INT_MEM_OFFSET (node
->loc
) == 0)
4606 else if (GET_CODE (node
->loc
) == VALUE
4607 && !VALUE_RECURSED_INTO (node
->loc
)
4608 && (where
= find_mem_expr_in_1pdv (expr
, node
->loc
, vars
)))
4611 VALUE_RECURSED_INTO (val
) = false;
4616 /* Return TRUE if the value of MEM may vary across a call. */
4619 mem_dies_at_call (rtx mem
)
4621 tree expr
= MEM_EXPR (mem
);
4627 decl
= get_base_address (expr
);
4635 return (may_be_aliased (decl
)
4636 || (!TREE_READONLY (decl
) && is_global_var (decl
)));
4639 /* Remove all MEMs from the location list of a hash table entry for a
4640 one-part variable, except those whose MEM attributes map back to
4641 the variable itself, directly or within a VALUE. */
4644 dataflow_set_preserve_mem_locs (variable_def
**slot
, dataflow_set
*set
)
4646 variable var
= *slot
;
4648 if (var
->onepart
== ONEPART_VDECL
|| var
->onepart
== ONEPART_DEXPR
)
4650 tree decl
= dv_as_decl (var
->dv
);
4651 location_chain loc
, *locp
;
4652 bool changed
= false;
4654 if (!var
->n_var_parts
)
4657 gcc_assert (var
->n_var_parts
== 1);
4659 if (shared_var_p (var
, set
->vars
))
4661 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4663 /* We want to remove dying MEMs that doesn't refer to DECL. */
4664 if (GET_CODE (loc
->loc
) == MEM
4665 && (MEM_EXPR (loc
->loc
) != decl
4666 || INT_MEM_OFFSET (loc
->loc
) != 0)
4667 && !mem_dies_at_call (loc
->loc
))
4669 /* We want to move here MEMs that do refer to DECL. */
4670 else if (GET_CODE (loc
->loc
) == VALUE
4671 && find_mem_expr_in_1pdv (decl
, loc
->loc
,
4672 shared_hash_htab (set
->vars
)))
4679 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4681 gcc_assert (var
->n_var_parts
== 1);
4684 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4687 rtx old_loc
= loc
->loc
;
4688 if (GET_CODE (old_loc
) == VALUE
)
4690 location_chain mem_node
4691 = find_mem_expr_in_1pdv (decl
, loc
->loc
,
4692 shared_hash_htab (set
->vars
));
4694 /* ??? This picks up only one out of multiple MEMs that
4695 refer to the same variable. Do we ever need to be
4696 concerned about dealing with more than one, or, given
4697 that they should all map to the same variable
4698 location, their addresses will have been merged and
4699 they will be regarded as equivalent? */
4702 loc
->loc
= mem_node
->loc
;
4703 loc
->set_src
= mem_node
->set_src
;
4704 loc
->init
= MIN (loc
->init
, mem_node
->init
);
4708 if (GET_CODE (loc
->loc
) != MEM
4709 || (MEM_EXPR (loc
->loc
) == decl
4710 && INT_MEM_OFFSET (loc
->loc
) == 0)
4711 || !mem_dies_at_call (loc
->loc
))
4713 if (old_loc
!= loc
->loc
&& emit_notes
)
4715 if (old_loc
== var
->var_part
[0].cur_loc
)
4718 var
->var_part
[0].cur_loc
= NULL
;
4727 if (old_loc
== var
->var_part
[0].cur_loc
)
4730 var
->var_part
[0].cur_loc
= NULL
;
4734 pool_free (loc_chain_pool
, loc
);
4737 if (!var
->var_part
[0].loc_chain
)
4743 variable_was_changed (var
, set
);
4749 /* Remove all MEMs from the location list of a hash table entry for a
4753 dataflow_set_remove_mem_locs (variable_def
**slot
, dataflow_set
*set
)
4755 variable var
= *slot
;
4757 if (var
->onepart
== ONEPART_VALUE
)
4759 location_chain loc
, *locp
;
4760 bool changed
= false;
4763 gcc_assert (var
->n_var_parts
== 1);
4765 if (shared_var_p (var
, set
->vars
))
4767 for (loc
= var
->var_part
[0].loc_chain
; loc
; loc
= loc
->next
)
4768 if (GET_CODE (loc
->loc
) == MEM
4769 && mem_dies_at_call (loc
->loc
))
4775 slot
= unshare_variable (set
, slot
, var
, VAR_INIT_STATUS_UNKNOWN
);
4777 gcc_assert (var
->n_var_parts
== 1);
4780 if (VAR_LOC_1PAUX (var
))
4781 cur_loc
= VAR_LOC_FROM (var
);
4783 cur_loc
= var
->var_part
[0].cur_loc
;
4785 for (locp
= &var
->var_part
[0].loc_chain
, loc
= *locp
;
4788 if (GET_CODE (loc
->loc
) != MEM
4789 || !mem_dies_at_call (loc
->loc
))
4796 /* If we have deleted the location which was last emitted
4797 we have to emit new location so add the variable to set
4798 of changed variables. */
4799 if (cur_loc
== loc
->loc
)
4802 var
->var_part
[0].cur_loc
= NULL
;
4803 if (VAR_LOC_1PAUX (var
))
4804 VAR_LOC_FROM (var
) = NULL
;
4806 pool_free (loc_chain_pool
, loc
);
4809 if (!var
->var_part
[0].loc_chain
)
4815 variable_was_changed (var
, set
);
4821 /* Remove all variable-location information about call-clobbered
4822 registers, as well as associations between MEMs and VALUEs. */
4825 dataflow_set_clear_at_call (dataflow_set
*set
)
4828 hard_reg_set_iterator hrsi
;
4830 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call
, 0, r
, hrsi
)
4831 var_regno_delete (set
, r
);
4833 if (MAY_HAVE_DEBUG_INSNS
)
4835 set
->traversed_vars
= set
->vars
;
4836 shared_hash_htab (set
->vars
)
4837 .traverse
<dataflow_set
*, dataflow_set_preserve_mem_locs
> (set
);
4838 set
->traversed_vars
= set
->vars
;
4839 shared_hash_htab (set
->vars
)
4840 .traverse
<dataflow_set
*, dataflow_set_remove_mem_locs
> (set
);
4841 set
->traversed_vars
= NULL
;
4846 variable_part_different_p (variable_part
*vp1
, variable_part
*vp2
)
4848 location_chain lc1
, lc2
;
4850 for (lc1
= vp1
->loc_chain
; lc1
; lc1
= lc1
->next
)
4852 for (lc2
= vp2
->loc_chain
; lc2
; lc2
= lc2
->next
)
4854 if (REG_P (lc1
->loc
) && REG_P (lc2
->loc
))
4856 if (REGNO (lc1
->loc
) == REGNO (lc2
->loc
))
4859 if (rtx_equal_p (lc1
->loc
, lc2
->loc
))
4868 /* Return true if one-part variables VAR1 and VAR2 are different.
4869 They must be in canonical order. */
4872 onepart_variable_different_p (variable var1
, variable var2
)
4874 location_chain lc1
, lc2
;
4879 gcc_assert (var1
->n_var_parts
== 1
4880 && var2
->n_var_parts
== 1);
4882 lc1
= var1
->var_part
[0].loc_chain
;
4883 lc2
= var2
->var_part
[0].loc_chain
;
4885 gcc_assert (lc1
&& lc2
);
4889 if (loc_cmp (lc1
->loc
, lc2
->loc
))
4898 /* Return true if variables VAR1 and VAR2 are different. */
4901 variable_different_p (variable var1
, variable var2
)
4908 if (var1
->onepart
!= var2
->onepart
)
4911 if (var1
->n_var_parts
!= var2
->n_var_parts
)
4914 if (var1
->onepart
&& var1
->n_var_parts
)
4916 gcc_checking_assert (dv_as_opaque (var1
->dv
) == dv_as_opaque (var2
->dv
)
4917 && var1
->n_var_parts
== 1);
4918 /* One-part values have locations in a canonical order. */
4919 return onepart_variable_different_p (var1
, var2
);
4922 for (i
= 0; i
< var1
->n_var_parts
; i
++)
4924 if (VAR_PART_OFFSET (var1
, i
) != VAR_PART_OFFSET (var2
, i
))
4926 if (variable_part_different_p (&var1
->var_part
[i
], &var2
->var_part
[i
]))
4928 if (variable_part_different_p (&var2
->var_part
[i
], &var1
->var_part
[i
]))
4934 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
4937 dataflow_set_different (dataflow_set
*old_set
, dataflow_set
*new_set
)
4939 variable_iterator_type hi
;
4942 if (old_set
->vars
== new_set
->vars
)
4945 if (shared_hash_htab (old_set
->vars
).elements ()
4946 != shared_hash_htab (new_set
->vars
).elements ())
4949 FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (old_set
->vars
),
4952 variable_table_type htab
= shared_hash_htab (new_set
->vars
);
4953 variable var2
= htab
.find_with_hash (var1
->dv
, dv_htab_hash (var1
->dv
));
4956 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4958 fprintf (dump_file
, "dataflow difference found: removal of:\n");
4964 if (variable_different_p (var1
, var2
))
4966 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4968 fprintf (dump_file
, "dataflow difference found: "
4969 "old and new follow:\n");
4977 /* No need to traverse the second hashtab, if both have the same number
4978 of elements and the second one had all entries found in the first one,
4979 then it can't have any extra entries. */
4983 /* Free the contents of dataflow set SET. */
4986 dataflow_set_destroy (dataflow_set
*set
)
4990 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4991 attrs_list_clear (&set
->regs
[i
]);
4993 shared_hash_destroy (set
->vars
);
4997 /* Return true if RTL X contains a SYMBOL_REF. */
5000 contains_symbol_ref (rtx x
)
5009 code
= GET_CODE (x
);
5010 if (code
== SYMBOL_REF
)
5013 fmt
= GET_RTX_FORMAT (code
);
5014 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
5018 if (contains_symbol_ref (XEXP (x
, i
)))
5021 else if (fmt
[i
] == 'E')
5024 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
5025 if (contains_symbol_ref (XVECEXP (x
, i
, j
)))
5033 /* Shall EXPR be tracked? */
5036 track_expr_p (tree expr
, bool need_rtl
)
5041 if (TREE_CODE (expr
) == DEBUG_EXPR_DECL
)
5042 return DECL_RTL_SET_P (expr
);
5044 /* If EXPR is not a parameter or a variable do not track it. */
5045 if (TREE_CODE (expr
) != VAR_DECL
&& TREE_CODE (expr
) != PARM_DECL
)
5048 /* It also must have a name... */
5049 if (!DECL_NAME (expr
) && need_rtl
)
5052 /* ... and a RTL assigned to it. */
5053 decl_rtl
= DECL_RTL_IF_SET (expr
);
5054 if (!decl_rtl
&& need_rtl
)
5057 /* If this expression is really a debug alias of some other declaration, we
5058 don't need to track this expression if the ultimate declaration is
5061 if (TREE_CODE (realdecl
) == VAR_DECL
&& DECL_HAS_DEBUG_EXPR_P (realdecl
))
5063 realdecl
= DECL_DEBUG_EXPR (realdecl
);
5064 if (!DECL_P (realdecl
))
5066 if (handled_component_p (realdecl
)
5067 || (TREE_CODE (realdecl
) == MEM_REF
5068 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5070 HOST_WIDE_INT bitsize
, bitpos
, maxsize
;
5072 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
,
5074 if (!DECL_P (innerdecl
)
5075 || DECL_IGNORED_P (innerdecl
)
5076 /* Do not track declarations for parts of tracked parameters
5077 since we want to track them as a whole instead. */
5078 || (TREE_CODE (innerdecl
) == PARM_DECL
5079 && DECL_MODE (innerdecl
) != BLKmode
5080 && TREE_CODE (TREE_TYPE (innerdecl
)) != UNION_TYPE
)
5081 || TREE_STATIC (innerdecl
)
5083 || bitpos
+ bitsize
> 256
5084 || bitsize
!= maxsize
)
5094 /* Do not track EXPR if REALDECL it should be ignored for debugging
5096 if (DECL_IGNORED_P (realdecl
))
5099 /* Do not track global variables until we are able to emit correct location
5101 if (TREE_STATIC (realdecl
))
5104 /* When the EXPR is a DECL for alias of some variable (see example)
5105 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5106 DECL_RTL contains SYMBOL_REF.
5109 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5112 if (decl_rtl
&& MEM_P (decl_rtl
)
5113 && contains_symbol_ref (XEXP (decl_rtl
, 0)))
5116 /* If RTX is a memory it should not be very large (because it would be
5117 an array or struct). */
5118 if (decl_rtl
&& MEM_P (decl_rtl
))
5120 /* Do not track structures and arrays. */
5121 if (GET_MODE (decl_rtl
) == BLKmode
5122 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl
)))
5124 if (MEM_SIZE_KNOWN_P (decl_rtl
)
5125 && MEM_SIZE (decl_rtl
) > MAX_VAR_PARTS
)
5129 DECL_CHANGED (expr
) = 0;
5130 DECL_CHANGED (realdecl
) = 0;
5134 /* Determine whether a given LOC refers to the same variable part as
5138 same_variable_part_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
)
5141 HOST_WIDE_INT offset2
;
5143 if (! DECL_P (expr
))
5148 expr2
= REG_EXPR (loc
);
5149 offset2
= REG_OFFSET (loc
);
5151 else if (MEM_P (loc
))
5153 expr2
= MEM_EXPR (loc
);
5154 offset2
= INT_MEM_OFFSET (loc
);
5159 if (! expr2
|| ! DECL_P (expr2
))
5162 expr
= var_debug_decl (expr
);
5163 expr2
= var_debug_decl (expr2
);
5165 return (expr
== expr2
&& offset
== offset2
);
5168 /* LOC is a REG or MEM that we would like to track if possible.
5169 If EXPR is null, we don't know what expression LOC refers to,
5170 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5171 LOC is an lvalue register.
5173 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5174 is something we can track. When returning true, store the mode of
5175 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5176 from EXPR in *OFFSET_OUT (if nonnull). */
5179 track_loc_p (rtx loc
, tree expr
, HOST_WIDE_INT offset
, bool store_reg_p
,
5180 enum machine_mode
*mode_out
, HOST_WIDE_INT
*offset_out
)
5182 enum machine_mode mode
;
5184 if (expr
== NULL
|| !track_expr_p (expr
, true))
5187 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5188 whole subreg, but only the old inner part is really relevant. */
5189 mode
= GET_MODE (loc
);
5190 if (REG_P (loc
) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc
)))
5192 enum machine_mode pseudo_mode
;
5194 pseudo_mode
= PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc
));
5195 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (pseudo_mode
))
5197 offset
+= byte_lowpart_offset (pseudo_mode
, mode
);
5202 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5203 Do the same if we are storing to a register and EXPR occupies
5204 the whole of register LOC; in that case, the whole of EXPR is
5205 being changed. We exclude complex modes from the second case
5206 because the real and imaginary parts are represented as separate
5207 pseudo registers, even if the whole complex value fits into one
5209 if ((GET_MODE_SIZE (mode
) > GET_MODE_SIZE (DECL_MODE (expr
))
5211 && !COMPLEX_MODE_P (DECL_MODE (expr
))
5212 && hard_regno_nregs
[REGNO (loc
)][DECL_MODE (expr
)] == 1))
5213 && offset
+ byte_lowpart_offset (DECL_MODE (expr
), mode
) == 0)
5215 mode
= DECL_MODE (expr
);
5219 if (offset
< 0 || offset
>= MAX_VAR_PARTS
)
5225 *offset_out
= offset
;
5229 /* Return the MODE lowpart of LOC, or null if LOC is not something we
5230 want to track. When returning nonnull, make sure that the attributes
5231 on the returned value are updated. */
5234 var_lowpart (enum machine_mode mode
, rtx loc
)
5236 unsigned int offset
, reg_offset
, regno
;
5238 if (GET_MODE (loc
) == mode
)
5241 if (!REG_P (loc
) && !MEM_P (loc
))
5244 offset
= byte_lowpart_offset (mode
, GET_MODE (loc
));
5247 return adjust_address_nv (loc
, mode
, offset
);
5249 reg_offset
= subreg_lowpart_offset (mode
, GET_MODE (loc
));
5250 regno
= REGNO (loc
) + subreg_regno_offset (REGNO (loc
), GET_MODE (loc
),
5252 return gen_rtx_REG_offset (loc
, mode
, regno
, offset
);
5255 /* Carry information about uses and stores while walking rtx. */
5257 struct count_use_info
5259 /* The insn where the RTX is. */
5262 /* The basic block where insn is. */
5265 /* The array of n_sets sets in the insn, as determined by cselib. */
5266 struct cselib_set
*sets
;
5269 /* True if we're counting stores, false otherwise. */
5273 /* Find a VALUE corresponding to X. */
5275 static inline cselib_val
*
5276 find_use_val (rtx x
, enum machine_mode mode
, struct count_use_info
*cui
)
5282 /* This is called after uses are set up and before stores are
5283 processed by cselib, so it's safe to look up srcs, but not
5284 dsts. So we look up expressions that appear in srcs or in
5285 dest expressions, but we search the sets array for dests of
5289 /* Some targets represent memset and memcpy patterns
5290 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5291 (set (mem:BLK ...) (const_int ...)) or
5292 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5293 in that case, otherwise we end up with mode mismatches. */
5294 if (mode
== BLKmode
&& MEM_P (x
))
5296 for (i
= 0; i
< cui
->n_sets
; i
++)
5297 if (cui
->sets
[i
].dest
== x
)
5298 return cui
->sets
[i
].src_elt
;
5301 return cselib_lookup (x
, mode
, 0, VOIDmode
);
5307 /* Replace all registers and addresses in an expression with VALUE
5308 expressions that map back to them, unless the expression is a
5309 register. If no mapping is or can be performed, returns NULL. */
5312 replace_expr_with_values (rtx loc
)
5314 if (REG_P (loc
) || GET_CODE (loc
) == ENTRY_VALUE
)
5316 else if (MEM_P (loc
))
5318 cselib_val
*addr
= cselib_lookup (XEXP (loc
, 0),
5319 get_address_mode (loc
), 0,
5322 return replace_equiv_address_nv (loc
, addr
->val_rtx
);
5327 return cselib_subst_to_values (loc
, VOIDmode
);
5330 /* Return true if *X is a DEBUG_EXPR. Usable as an argument to
5331 for_each_rtx to tell whether there are any DEBUG_EXPRs within
5335 rtx_debug_expr_p (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
5339 return GET_CODE (loc
) == DEBUG_EXPR
;
5342 /* Determine what kind of micro operation to choose for a USE. Return
5343 MO_CLOBBER if no micro operation is to be generated. */
5345 static enum micro_operation_type
5346 use_type (rtx loc
, struct count_use_info
*cui
, enum machine_mode
*modep
)
5350 if (cui
&& cui
->sets
)
5352 if (GET_CODE (loc
) == VAR_LOCATION
)
5354 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc
), false))
5356 rtx ploc
= PAT_VAR_LOCATION_LOC (loc
);
5357 if (! VAR_LOC_UNKNOWN_P (ploc
))
5359 cselib_val
*val
= cselib_lookup (ploc
, GET_MODE (loc
), 1,
5362 /* ??? flag_float_store and volatile mems are never
5363 given values, but we could in theory use them for
5365 gcc_assert (val
|| 1);
5373 if (REG_P (loc
) || MEM_P (loc
))
5376 *modep
= GET_MODE (loc
);
5380 || (find_use_val (loc
, GET_MODE (loc
), cui
)
5381 && cselib_lookup (XEXP (loc
, 0),
5382 get_address_mode (loc
), 0,
5388 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5390 if (val
&& !cselib_preserved_value_p (val
))
5398 gcc_assert (REGNO (loc
) < FIRST_PSEUDO_REGISTER
);
5400 if (loc
== cfa_base_rtx
)
5402 expr
= REG_EXPR (loc
);
5405 return MO_USE_NO_VAR
;
5406 else if (target_for_debug_bind (var_debug_decl (expr
)))
5408 else if (track_loc_p (loc
, expr
, REG_OFFSET (loc
),
5409 false, modep
, NULL
))
5412 return MO_USE_NO_VAR
;
5414 else if (MEM_P (loc
))
5416 expr
= MEM_EXPR (loc
);
5420 else if (target_for_debug_bind (var_debug_decl (expr
)))
5422 else if (track_loc_p (loc
, expr
, INT_MEM_OFFSET (loc
),
5424 /* Multi-part variables shouldn't refer to one-part
5425 variable names such as VALUEs (never happens) or
5426 DEBUG_EXPRs (only happens in the presence of debug
5428 && (!MAY_HAVE_DEBUG_INSNS
5429 || !for_each_rtx (&XEXP (loc
, 0), rtx_debug_expr_p
, NULL
)))
5438 /* Log to OUT information about micro-operation MOPT involving X in
5442 log_op_type (rtx x
, basic_block bb
, rtx insn
,
5443 enum micro_operation_type mopt
, FILE *out
)
5445 fprintf (out
, "bb %i op %i insn %i %s ",
5446 bb
->index
, VTI (bb
)->mos
.length (),
5447 INSN_UID (insn
), micro_operation_type_name
[mopt
]);
5448 print_inline_rtx (out
, x
, 2);
5452 /* Tell whether the CONCAT used to holds a VALUE and its location
5453 needs value resolution, i.e., an attempt of mapping the location
5454 back to other incoming values. */
5455 #define VAL_NEEDS_RESOLUTION(x) \
5456 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
5457 /* Whether the location in the CONCAT is a tracked expression, that
5458 should also be handled like a MO_USE. */
5459 #define VAL_HOLDS_TRACK_EXPR(x) \
5460 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
5461 /* Whether the location in the CONCAT should be handled like a MO_COPY
5463 #define VAL_EXPR_IS_COPIED(x) \
5464 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
5465 /* Whether the location in the CONCAT should be handled like a
5466 MO_CLOBBER as well. */
5467 #define VAL_EXPR_IS_CLOBBERED(x) \
5468 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
5470 /* All preserved VALUEs. */
5471 static vec
<rtx
> preserved_values
;
5473 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5476 preserve_value (cselib_val
*val
)
5478 cselib_preserve_value (val
);
5479 preserved_values
.safe_push (val
->val_rtx
);
5482 /* Helper function for MO_VAL_LOC handling. Return non-zero if
5483 any rtxes not suitable for CONST use not replaced by VALUEs
5487 non_suitable_const (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
5492 switch (GET_CODE (*x
))
5503 return !MEM_READONLY_P (*x
);
5509 /* Add uses (register and memory references) LOC which will be tracked
5510 to VTI (bb)->mos. INSN is instruction which the LOC is part of. */
5513 add_uses (rtx
*ploc
, void *data
)
5516 enum machine_mode mode
= VOIDmode
;
5517 struct count_use_info
*cui
= (struct count_use_info
*)data
;
5518 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5520 if (type
!= MO_CLOBBER
)
5522 basic_block bb
= cui
->bb
;
5526 mo
.u
.loc
= type
== MO_USE
? var_lowpart (mode
, loc
) : loc
;
5527 mo
.insn
= cui
->insn
;
5529 if (type
== MO_VAL_LOC
)
5532 rtx vloc
= PAT_VAR_LOCATION_LOC (oloc
);
5535 gcc_assert (cui
->sets
);
5538 && !REG_P (XEXP (vloc
, 0))
5539 && !MEM_P (XEXP (vloc
, 0)))
5542 enum machine_mode address_mode
= get_address_mode (mloc
);
5544 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5547 if (val
&& !cselib_preserved_value_p (val
))
5548 preserve_value (val
);
5551 if (CONSTANT_P (vloc
)
5552 && (GET_CODE (vloc
) != CONST
5553 || for_each_rtx (&vloc
, non_suitable_const
, NULL
)))
5554 /* For constants don't look up any value. */;
5555 else if (!VAR_LOC_UNKNOWN_P (vloc
) && !unsuitable_loc (vloc
)
5556 && (val
= find_use_val (vloc
, GET_MODE (oloc
), cui
)))
5558 enum machine_mode mode2
;
5559 enum micro_operation_type type2
;
5561 bool resolvable
= REG_P (vloc
) || MEM_P (vloc
);
5564 nloc
= replace_expr_with_values (vloc
);
5568 oloc
= shallow_copy_rtx (oloc
);
5569 PAT_VAR_LOCATION_LOC (oloc
) = nloc
;
5572 oloc
= gen_rtx_CONCAT (mode
, val
->val_rtx
, oloc
);
5574 type2
= use_type (vloc
, 0, &mode2
);
5576 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5577 || type2
== MO_CLOBBER
);
5579 if (type2
== MO_CLOBBER
5580 && !cselib_preserved_value_p (val
))
5582 VAL_NEEDS_RESOLUTION (oloc
) = resolvable
;
5583 preserve_value (val
);
5586 else if (!VAR_LOC_UNKNOWN_P (vloc
))
5588 oloc
= shallow_copy_rtx (oloc
);
5589 PAT_VAR_LOCATION_LOC (oloc
) = gen_rtx_UNKNOWN_VAR_LOC ();
5594 else if (type
== MO_VAL_USE
)
5596 enum machine_mode mode2
= VOIDmode
;
5597 enum micro_operation_type type2
;
5598 cselib_val
*val
= find_use_val (loc
, GET_MODE (loc
), cui
);
5599 rtx vloc
, oloc
= loc
, nloc
;
5601 gcc_assert (cui
->sets
);
5604 && !REG_P (XEXP (oloc
, 0))
5605 && !MEM_P (XEXP (oloc
, 0)))
5608 enum machine_mode address_mode
= get_address_mode (mloc
);
5610 = cselib_lookup (XEXP (mloc
, 0), address_mode
, 0,
5613 if (val
&& !cselib_preserved_value_p (val
))
5614 preserve_value (val
);
5617 type2
= use_type (loc
, 0, &mode2
);
5619 gcc_assert (type2
== MO_USE
|| type2
== MO_USE_NO_VAR
5620 || type2
== MO_CLOBBER
);
5622 if (type2
== MO_USE
)
5623 vloc
= var_lowpart (mode2
, loc
);
5627 /* The loc of a MO_VAL_USE may have two forms:
5629 (concat val src): val is at src, a value-based
5632 (concat (concat val use) src): same as above, with use as
5633 the MO_USE tracked value, if it differs from src.
5637 gcc_checking_assert (REG_P (loc
) || MEM_P (loc
));
5638 nloc
= replace_expr_with_values (loc
);
5643 oloc
= gen_rtx_CONCAT (mode2
, val
->val_rtx
, vloc
);
5645 oloc
= val
->val_rtx
;
5647 mo
.u
.loc
= gen_rtx_CONCAT (mode
, oloc
, nloc
);
5649 if (type2
== MO_USE
)
5650 VAL_HOLDS_TRACK_EXPR (mo
.u
.loc
) = 1;
5651 if (!cselib_preserved_value_p (val
))
5653 VAL_NEEDS_RESOLUTION (mo
.u
.loc
) = 1;
5654 preserve_value (val
);
5658 gcc_assert (type
== MO_USE
|| type
== MO_USE_NO_VAR
);
5660 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5661 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
5662 VTI (bb
)->mos
.safe_push (mo
);
5668 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
5671 add_uses_1 (rtx
*x
, void *cui
)
5673 for_each_rtx (x
, add_uses
, cui
);
5676 /* This is the value used during expansion of locations. We want it
5677 to be unbounded, so that variables expanded deep in a recursion
5678 nest are fully evaluated, so that their values are cached
5679 correctly. We avoid recursion cycles through other means, and we
5680 don't unshare RTL, so excess complexity is not a problem. */
5681 #define EXPR_DEPTH (INT_MAX)
5682 /* We use this to keep too-complex expressions from being emitted as
5683 location notes, and then to debug information. Users can trade
5684 compile time for ridiculously complex expressions, although they're
5685 seldom useful, and they may often have to be discarded as not
5686 representable anyway. */
5687 #define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
5689 /* Attempt to reverse the EXPR operation in the debug info and record
5690 it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
5691 no longer live we can express its value as VAL - 6. */
5694 reverse_op (rtx val
, const_rtx expr
, rtx insn
)
5698 struct elt_loc_list
*l
;
5702 if (GET_CODE (expr
) != SET
)
5705 if (!REG_P (SET_DEST (expr
)) || GET_MODE (val
) != GET_MODE (SET_DEST (expr
)))
5708 src
= SET_SRC (expr
);
5709 switch (GET_CODE (src
))
5716 if (!REG_P (XEXP (src
, 0)))
5721 if (!REG_P (XEXP (src
, 0)) && !MEM_P (XEXP (src
, 0)))
5728 if (!SCALAR_INT_MODE_P (GET_MODE (src
)) || XEXP (src
, 0) == cfa_base_rtx
)
5731 v
= cselib_lookup (XEXP (src
, 0), GET_MODE (XEXP (src
, 0)), 0, VOIDmode
);
5732 if (!v
|| !cselib_preserved_value_p (v
))
5735 /* Use canonical V to avoid creating multiple redundant expressions
5736 for different VALUES equivalent to V. */
5737 v
= canonical_cselib_val (v
);
5739 /* Adding a reverse op isn't useful if V already has an always valid
5740 location. Ignore ENTRY_VALUE, while it is always constant, we should
5741 prefer non-ENTRY_VALUE locations whenever possible. */
5742 for (l
= v
->locs
, count
= 0; l
; l
= l
->next
, count
++)
5743 if (CONSTANT_P (l
->loc
)
5744 && (GET_CODE (l
->loc
) != CONST
|| !references_value_p (l
->loc
, 0)))
5746 /* Avoid creating too large locs lists. */
5747 else if (count
== PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE
))
5750 switch (GET_CODE (src
))
5754 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5756 ret
= gen_rtx_fmt_e (GET_CODE (src
), GET_MODE (val
), val
);
5760 ret
= gen_lowpart_SUBREG (GET_MODE (v
->val_rtx
), val
);
5772 if (GET_MODE (v
->val_rtx
) != GET_MODE (val
))
5774 arg
= XEXP (src
, 1);
5775 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5777 arg
= cselib_expand_value_rtx (arg
, scratch_regs
, 5);
5778 if (arg
== NULL_RTX
)
5780 if (!CONST_INT_P (arg
) && GET_CODE (arg
) != SYMBOL_REF
)
5783 ret
= simplify_gen_binary (code
, GET_MODE (val
), val
, arg
);
5785 /* Ensure ret isn't VALUE itself (which can happen e.g. for
5786 (plus (reg1) (reg2)) when reg2 is known to be 0), as that
5787 breaks a lot of routines during var-tracking. */
5788 ret
= gen_rtx_fmt_ee (PLUS
, GET_MODE (val
), val
, const0_rtx
);
5794 cselib_add_permanent_equiv (v
, ret
, insn
);
5797 /* Add stores (register and memory references) LOC which will be tracked
5798 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5799 CUIP->insn is instruction which the LOC is part of. */
5802 add_stores (rtx loc
, const_rtx expr
, void *cuip
)
5804 enum machine_mode mode
= VOIDmode
, mode2
;
5805 struct count_use_info
*cui
= (struct count_use_info
*)cuip
;
5806 basic_block bb
= cui
->bb
;
5808 rtx oloc
= loc
, nloc
, src
= NULL
;
5809 enum micro_operation_type type
= use_type (loc
, cui
, &mode
);
5810 bool track_p
= false;
5812 bool resolve
, preserve
;
5814 if (type
== MO_CLOBBER
)
5821 gcc_assert (loc
!= cfa_base_rtx
);
5822 if ((GET_CODE (expr
) == CLOBBER
&& type
!= MO_VAL_SET
)
5823 || !(track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5824 || GET_CODE (expr
) == CLOBBER
)
5826 mo
.type
= MO_CLOBBER
;
5828 if (GET_CODE (expr
) == SET
5829 && SET_DEST (expr
) == loc
5830 && !unsuitable_loc (SET_SRC (expr
))
5831 && find_use_val (loc
, mode
, cui
))
5833 gcc_checking_assert (type
== MO_VAL_SET
);
5834 mo
.u
.loc
= gen_rtx_SET (VOIDmode
, loc
, SET_SRC (expr
));
5839 if (GET_CODE (expr
) == SET
5840 && SET_DEST (expr
) == loc
5841 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5842 src
= var_lowpart (mode2
, SET_SRC (expr
));
5843 loc
= var_lowpart (mode2
, loc
);
5852 rtx xexpr
= gen_rtx_SET (VOIDmode
, loc
, src
);
5853 if (same_variable_part_p (src
, REG_EXPR (loc
), REG_OFFSET (loc
)))
5855 /* If this is an instruction copying (part of) a parameter
5856 passed by invisible reference to its register location,
5857 pretend it's a SET so that the initial memory location
5858 is discarded, as the parameter register can be reused
5859 for other purposes and we do not track locations based
5860 on generic registers. */
5863 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5864 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5865 && MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5866 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0)
5877 mo
.insn
= cui
->insn
;
5879 else if (MEM_P (loc
)
5880 && ((track_p
= use_type (loc
, NULL
, &mode2
) == MO_USE
)
5883 if (MEM_P (loc
) && type
== MO_VAL_SET
5884 && !REG_P (XEXP (loc
, 0))
5885 && !MEM_P (XEXP (loc
, 0)))
5888 enum machine_mode address_mode
= get_address_mode (mloc
);
5889 cselib_val
*val
= cselib_lookup (XEXP (mloc
, 0),
5893 if (val
&& !cselib_preserved_value_p (val
))
5894 preserve_value (val
);
5897 if (GET_CODE (expr
) == CLOBBER
|| !track_p
)
5899 mo
.type
= MO_CLOBBER
;
5900 mo
.u
.loc
= track_p
? var_lowpart (mode2
, loc
) : loc
;
5904 if (GET_CODE (expr
) == SET
5905 && SET_DEST (expr
) == loc
5906 && GET_CODE (SET_SRC (expr
)) != ASM_OPERANDS
)
5907 src
= var_lowpart (mode2
, SET_SRC (expr
));
5908 loc
= var_lowpart (mode2
, loc
);
5917 rtx xexpr
= gen_rtx_SET (VOIDmode
, loc
, src
);
5918 if (same_variable_part_p (SET_SRC (xexpr
),
5920 INT_MEM_OFFSET (loc
)))
5927 mo
.insn
= cui
->insn
;
5932 if (type
!= MO_VAL_SET
)
5933 goto log_and_return
;
5935 v
= find_use_val (oloc
, mode
, cui
);
5938 goto log_and_return
;
5940 resolve
= preserve
= !cselib_preserved_value_p (v
);
5942 /* We cannot track values for multiple-part variables, so we track only
5943 locations for tracked parameters passed either by invisible reference
5944 or directly in multiple locations. */
5948 && TREE_CODE (REG_EXPR (loc
)) == PARM_DECL
5949 && DECL_MODE (REG_EXPR (loc
)) != BLKmode
5950 && TREE_CODE (TREE_TYPE (REG_EXPR (loc
))) != UNION_TYPE
5951 && ((MEM_P (DECL_INCOMING_RTL (REG_EXPR (loc
)))
5952 && XEXP (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) != arg_pointer_rtx
)
5953 || (GET_CODE (DECL_INCOMING_RTL (REG_EXPR (loc
))) == PARALLEL
5954 && XVECLEN (DECL_INCOMING_RTL (REG_EXPR (loc
)), 0) > 1)))
5956 /* Although we don't use the value here, it could be used later by the
5957 mere virtue of its existence as the operand of the reverse operation
5958 that gave rise to it (typically extension/truncation). Make sure it
5959 is preserved as required by vt_expand_var_loc_chain. */
5962 goto log_and_return
;
5965 if (loc
== stack_pointer_rtx
5966 && hard_frame_pointer_adjustment
!= -1
5968 cselib_set_value_sp_based (v
);
5970 nloc
= replace_expr_with_values (oloc
);
5974 if (GET_CODE (PATTERN (cui
->insn
)) == COND_EXEC
)
5976 cselib_val
*oval
= cselib_lookup (oloc
, GET_MODE (oloc
), 0, VOIDmode
);
5978 gcc_assert (oval
!= v
);
5979 gcc_assert (REG_P (oloc
) || MEM_P (oloc
));
5981 if (oval
&& !cselib_preserved_value_p (oval
))
5983 micro_operation moa
;
5985 preserve_value (oval
);
5987 moa
.type
= MO_VAL_USE
;
5988 moa
.u
.loc
= gen_rtx_CONCAT (mode
, oval
->val_rtx
, oloc
);
5989 VAL_NEEDS_RESOLUTION (moa
.u
.loc
) = 1;
5990 moa
.insn
= cui
->insn
;
5992 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5993 log_op_type (moa
.u
.loc
, cui
->bb
, cui
->insn
,
5994 moa
.type
, dump_file
);
5995 VTI (bb
)->mos
.safe_push (moa
);
6000 else if (resolve
&& GET_CODE (mo
.u
.loc
) == SET
)
6002 if (REG_P (SET_SRC (expr
)) || MEM_P (SET_SRC (expr
)))
6003 nloc
= replace_expr_with_values (SET_SRC (expr
));
6007 /* Avoid the mode mismatch between oexpr and expr. */
6008 if (!nloc
&& mode
!= mode2
)
6010 nloc
= SET_SRC (expr
);
6011 gcc_assert (oloc
== SET_DEST (expr
));
6014 if (nloc
&& nloc
!= SET_SRC (mo
.u
.loc
))
6015 oloc
= gen_rtx_SET (GET_MODE (mo
.u
.loc
), oloc
, nloc
);
6018 if (oloc
== SET_DEST (mo
.u
.loc
))
6019 /* No point in duplicating. */
6021 if (!REG_P (SET_SRC (mo
.u
.loc
)))
6027 if (GET_CODE (mo
.u
.loc
) == SET
6028 && oloc
== SET_DEST (mo
.u
.loc
))
6029 /* No point in duplicating. */
6035 loc
= gen_rtx_CONCAT (mode
, v
->val_rtx
, oloc
);
6037 if (mo
.u
.loc
!= oloc
)
6038 loc
= gen_rtx_CONCAT (GET_MODE (mo
.u
.loc
), loc
, mo
.u
.loc
);
6040 /* The loc of a MO_VAL_SET may have various forms:
6042 (concat val dst): dst now holds val
6044 (concat val (set dst src)): dst now holds val, copied from src
6046 (concat (concat val dstv) dst): dst now holds val; dstv is dst
6047 after replacing mems and non-top-level regs with values.
6049 (concat (concat val dstv) (set dst src)): dst now holds val,
6050 copied from src. dstv is a value-based representation of dst, if
6051 it differs from dst. If resolution is needed, src is a REG, and
6052 its mode is the same as that of val.
6054 (concat (concat val (set dstv srcv)) (set dst src)): src
6055 copied to dst, holding val. dstv and srcv are value-based
6056 representations of dst and src, respectively.
6060 if (GET_CODE (PATTERN (cui
->insn
)) != COND_EXEC
)
6061 reverse_op (v
->val_rtx
, expr
, cui
->insn
);
6066 VAL_HOLDS_TRACK_EXPR (loc
) = 1;
6069 VAL_NEEDS_RESOLUTION (loc
) = resolve
;
6072 if (mo
.type
== MO_CLOBBER
)
6073 VAL_EXPR_IS_CLOBBERED (loc
) = 1;
6074 if (mo
.type
== MO_COPY
)
6075 VAL_EXPR_IS_COPIED (loc
) = 1;
6077 mo
.type
= MO_VAL_SET
;
6080 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6081 log_op_type (mo
.u
.loc
, cui
->bb
, cui
->insn
, mo
.type
, dump_file
);
6082 VTI (bb
)->mos
.safe_push (mo
);
6085 /* Arguments to the call. */
6086 static rtx call_arguments
;
6088 /* Compute call_arguments. */
6091 prepare_call_arguments (basic_block bb
, rtx insn
)
6094 rtx prev
, cur
, next
;
6095 rtx this_arg
= NULL_RTX
;
6096 tree type
= NULL_TREE
, t
, fndecl
= NULL_TREE
;
6097 tree obj_type_ref
= NULL_TREE
;
6098 CUMULATIVE_ARGS args_so_far_v
;
6099 cumulative_args_t args_so_far
;
6101 memset (&args_so_far_v
, 0, sizeof (args_so_far_v
));
6102 args_so_far
= pack_cumulative_args (&args_so_far_v
);
6103 call
= get_call_rtx_from (insn
);
6106 if (GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
6108 rtx symbol
= XEXP (XEXP (call
, 0), 0);
6109 if (SYMBOL_REF_DECL (symbol
))
6110 fndecl
= SYMBOL_REF_DECL (symbol
);
6112 if (fndecl
== NULL_TREE
)
6113 fndecl
= MEM_EXPR (XEXP (call
, 0));
6115 && TREE_CODE (TREE_TYPE (fndecl
)) != FUNCTION_TYPE
6116 && TREE_CODE (TREE_TYPE (fndecl
)) != METHOD_TYPE
)
6118 if (fndecl
&& TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6119 type
= TREE_TYPE (fndecl
);
6120 if (fndecl
&& TREE_CODE (fndecl
) != FUNCTION_DECL
)
6122 if (TREE_CODE (fndecl
) == INDIRECT_REF
6123 && TREE_CODE (TREE_OPERAND (fndecl
, 0)) == OBJ_TYPE_REF
)
6124 obj_type_ref
= TREE_OPERAND (fndecl
, 0);
6129 for (t
= TYPE_ARG_TYPES (type
); t
&& t
!= void_list_node
;
6131 if (TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
6132 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_VALUE (t
))))
6134 if ((t
== NULL
|| t
== void_list_node
) && obj_type_ref
== NULL_TREE
)
6138 int nargs ATTRIBUTE_UNUSED
= list_length (TYPE_ARG_TYPES (type
));
6139 link
= CALL_INSN_FUNCTION_USAGE (insn
);
6140 #ifndef PCC_STATIC_STRUCT_RETURN
6141 if (aggregate_value_p (TREE_TYPE (type
), type
)
6142 && targetm
.calls
.struct_value_rtx (type
, 0) == 0)
6144 tree struct_addr
= build_pointer_type (TREE_TYPE (type
));
6145 enum machine_mode mode
= TYPE_MODE (struct_addr
);
6147 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6149 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6151 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6153 if (reg
== NULL_RTX
)
6155 for (; link
; link
= XEXP (link
, 1))
6156 if (GET_CODE (XEXP (link
, 0)) == USE
6157 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6159 link
= XEXP (link
, 1);
6166 INIT_CUMULATIVE_ARGS (args_so_far_v
, type
, NULL_RTX
, fndecl
,
6168 if (obj_type_ref
&& TYPE_ARG_TYPES (type
) != void_list_node
)
6170 enum machine_mode mode
;
6171 t
= TYPE_ARG_TYPES (type
);
6172 mode
= TYPE_MODE (TREE_VALUE (t
));
6173 this_arg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6174 TREE_VALUE (t
), true);
6175 if (this_arg
&& !REG_P (this_arg
))
6176 this_arg
= NULL_RTX
;
6177 else if (this_arg
== NULL_RTX
)
6179 for (; link
; link
= XEXP (link
, 1))
6180 if (GET_CODE (XEXP (link
, 0)) == USE
6181 && MEM_P (XEXP (XEXP (link
, 0), 0)))
6183 this_arg
= XEXP (XEXP (link
, 0), 0);
6191 t
= type
? TYPE_ARG_TYPES (type
) : NULL_TREE
;
6193 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
6194 if (GET_CODE (XEXP (link
, 0)) == USE
)
6196 rtx item
= NULL_RTX
;
6197 x
= XEXP (XEXP (link
, 0), 0);
6198 if (GET_MODE (link
) == VOIDmode
6199 || GET_MODE (link
) == BLKmode
6200 || (GET_MODE (link
) != GET_MODE (x
)
6201 && (GET_MODE_CLASS (GET_MODE (link
)) != MODE_INT
6202 || GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
)))
6203 /* Can't do anything for these, if the original type mode
6204 isn't known or can't be converted. */;
6207 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6208 if (val
&& cselib_preserved_value_p (val
))
6209 item
= val
->val_rtx
;
6210 else if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_INT
)
6212 enum machine_mode mode
= GET_MODE (x
);
6214 while ((mode
= GET_MODE_WIDER_MODE (mode
)) != VOIDmode
6215 && GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
6217 rtx reg
= simplify_subreg (mode
, x
, GET_MODE (x
), 0);
6219 if (reg
== NULL_RTX
|| !REG_P (reg
))
6221 val
= cselib_lookup (reg
, mode
, 0, VOIDmode
);
6222 if (val
&& cselib_preserved_value_p (val
))
6224 item
= val
->val_rtx
;
6235 if (!frame_pointer_needed
)
6237 struct adjust_mem_data amd
;
6238 amd
.mem_mode
= VOIDmode
;
6239 amd
.stack_adjust
= -VTI (bb
)->out
.stack_adjust
;
6240 amd
.side_effects
= NULL_RTX
;
6242 mem
= simplify_replace_fn_rtx (mem
, NULL_RTX
, adjust_mems
,
6244 gcc_assert (amd
.side_effects
== NULL_RTX
);
6246 val
= cselib_lookup (mem
, GET_MODE (mem
), 0, VOIDmode
);
6247 if (val
&& cselib_preserved_value_p (val
))
6248 item
= val
->val_rtx
;
6249 else if (GET_MODE_CLASS (GET_MODE (mem
)) != MODE_INT
)
6251 /* For non-integer stack argument see also if they weren't
6252 initialized by integers. */
6253 enum machine_mode imode
= int_mode_for_mode (GET_MODE (mem
));
6254 if (imode
!= GET_MODE (mem
) && imode
!= BLKmode
)
6256 val
= cselib_lookup (adjust_address_nv (mem
, imode
, 0),
6257 imode
, 0, VOIDmode
);
6258 if (val
&& cselib_preserved_value_p (val
))
6259 item
= lowpart_subreg (GET_MODE (x
), val
->val_rtx
,
6267 if (GET_MODE (item
) != GET_MODE (link
))
6268 item
= lowpart_subreg (GET_MODE (link
), item
, GET_MODE (item
));
6269 if (GET_MODE (x2
) != GET_MODE (link
))
6270 x2
= lowpart_subreg (GET_MODE (link
), x2
, GET_MODE (x2
));
6271 item
= gen_rtx_CONCAT (GET_MODE (link
), x2
, item
);
6273 = gen_rtx_EXPR_LIST (VOIDmode
, item
, call_arguments
);
6275 if (t
&& t
!= void_list_node
)
6277 tree argtype
= TREE_VALUE (t
);
6278 enum machine_mode mode
= TYPE_MODE (argtype
);
6280 if (pass_by_reference (&args_so_far_v
, mode
, argtype
, true))
6282 argtype
= build_pointer_type (argtype
);
6283 mode
= TYPE_MODE (argtype
);
6285 reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
6287 if (TREE_CODE (argtype
) == REFERENCE_TYPE
6288 && INTEGRAL_TYPE_P (TREE_TYPE (argtype
))
6291 && GET_MODE (reg
) == mode
6292 && GET_MODE_CLASS (mode
) == MODE_INT
6294 && REGNO (x
) == REGNO (reg
)
6295 && GET_MODE (x
) == mode
6298 enum machine_mode indmode
6299 = TYPE_MODE (TREE_TYPE (argtype
));
6300 rtx mem
= gen_rtx_MEM (indmode
, x
);
6301 cselib_val
*val
= cselib_lookup (mem
, indmode
, 0, VOIDmode
);
6302 if (val
&& cselib_preserved_value_p (val
))
6304 item
= gen_rtx_CONCAT (indmode
, mem
, val
->val_rtx
);
6305 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6310 struct elt_loc_list
*l
;
6313 /* Try harder, when passing address of a constant
6314 pool integer it can be easily read back. */
6315 item
= XEXP (item
, 1);
6316 if (GET_CODE (item
) == SUBREG
)
6317 item
= SUBREG_REG (item
);
6318 gcc_assert (GET_CODE (item
) == VALUE
);
6319 val
= CSELIB_VAL_PTR (item
);
6320 for (l
= val
->locs
; l
; l
= l
->next
)
6321 if (GET_CODE (l
->loc
) == SYMBOL_REF
6322 && TREE_CONSTANT_POOL_ADDRESS_P (l
->loc
)
6323 && SYMBOL_REF_DECL (l
->loc
)
6324 && DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
)))
6326 initial
= DECL_INITIAL (SYMBOL_REF_DECL (l
->loc
));
6327 if (tree_fits_shwi_p (initial
))
6329 item
= GEN_INT (tree_to_shwi (initial
));
6330 item
= gen_rtx_CONCAT (indmode
, mem
, item
);
6332 = gen_rtx_EXPR_LIST (VOIDmode
, item
,
6339 targetm
.calls
.function_arg_advance (args_so_far
, mode
,
6345 /* Add debug arguments. */
6347 && TREE_CODE (fndecl
) == FUNCTION_DECL
6348 && DECL_HAS_DEBUG_ARGS_P (fndecl
))
6350 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (fndecl
);
6355 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, ¶m
); ix
+= 2)
6358 tree dtemp
= (**debug_args
)[ix
+ 1];
6359 enum machine_mode mode
= DECL_MODE (dtemp
);
6360 item
= gen_rtx_DEBUG_PARAMETER_REF (mode
, param
);
6361 item
= gen_rtx_CONCAT (mode
, item
, DECL_RTL_KNOWN_SET (dtemp
));
6362 call_arguments
= gen_rtx_EXPR_LIST (VOIDmode
, item
,
6368 /* Reverse call_arguments chain. */
6370 for (cur
= call_arguments
; cur
; cur
= next
)
6372 next
= XEXP (cur
, 1);
6373 XEXP (cur
, 1) = prev
;
6376 call_arguments
= prev
;
6378 x
= get_call_rtx_from (insn
);
6381 x
= XEXP (XEXP (x
, 0), 0);
6382 if (GET_CODE (x
) == SYMBOL_REF
)
6383 /* Don't record anything. */;
6384 else if (CONSTANT_P (x
))
6386 x
= gen_rtx_CONCAT (GET_MODE (x
) == VOIDmode
? Pmode
: GET_MODE (x
),
6389 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6393 cselib_val
*val
= cselib_lookup (x
, GET_MODE (x
), 0, VOIDmode
);
6394 if (val
&& cselib_preserved_value_p (val
))
6396 x
= gen_rtx_CONCAT (GET_MODE (x
), pc_rtx
, val
->val_rtx
);
6398 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6404 enum machine_mode mode
6405 = TYPE_MODE (TREE_TYPE (OBJ_TYPE_REF_EXPR (obj_type_ref
)));
6406 rtx clobbered
= gen_rtx_MEM (mode
, this_arg
);
6408 = tree_to_shwi (OBJ_TYPE_REF_TOKEN (obj_type_ref
));
6410 clobbered
= plus_constant (mode
, clobbered
,
6411 token
* GET_MODE_SIZE (mode
));
6412 clobbered
= gen_rtx_MEM (mode
, clobbered
);
6413 x
= gen_rtx_CONCAT (mode
, gen_rtx_CLOBBER (VOIDmode
, pc_rtx
), clobbered
);
6415 = gen_rtx_EXPR_LIST (VOIDmode
, x
, call_arguments
);
6419 /* Callback for cselib_record_sets_hook, that records as micro
6420 operations uses and stores in an insn after cselib_record_sets has
6421 analyzed the sets in an insn, but before it modifies the stored
6422 values in the internal tables, unless cselib_record_sets doesn't
6423 call it directly (perhaps because we're not doing cselib in the
6424 first place, in which case sets and n_sets will be 0). */
6427 add_with_sets (rtx insn
, struct cselib_set
*sets
, int n_sets
)
6429 basic_block bb
= BLOCK_FOR_INSN (insn
);
6431 struct count_use_info cui
;
6432 micro_operation
*mos
;
6434 cselib_hook_called
= true;
6439 cui
.n_sets
= n_sets
;
6441 n1
= VTI (bb
)->mos
.length ();
6442 cui
.store_p
= false;
6443 note_uses (&PATTERN (insn
), add_uses_1
, &cui
);
6444 n2
= VTI (bb
)->mos
.length () - 1;
6445 mos
= VTI (bb
)->mos
.address ();
6447 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
6451 while (n1
< n2
&& mos
[n1
].type
== MO_USE
)
6453 while (n1
< n2
&& mos
[n2
].type
!= MO_USE
)
6465 n2
= VTI (bb
)->mos
.length () - 1;
6468 while (n1
< n2
&& mos
[n1
].type
!= MO_VAL_LOC
)
6470 while (n1
< n2
&& mos
[n2
].type
== MO_VAL_LOC
)
6488 mo
.u
.loc
= call_arguments
;
6489 call_arguments
= NULL_RTX
;
6491 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6492 log_op_type (PATTERN (insn
), bb
, insn
, mo
.type
, dump_file
);
6493 VTI (bb
)->mos
.safe_push (mo
);
6496 n1
= VTI (bb
)->mos
.length ();
6497 /* This will record NEXT_INSN (insn), such that we can
6498 insert notes before it without worrying about any
6499 notes that MO_USEs might emit after the insn. */
6501 note_stores (PATTERN (insn
), add_stores
, &cui
);
6502 n2
= VTI (bb
)->mos
.length () - 1;
6503 mos
= VTI (bb
)->mos
.address ();
6505 /* Order the MO_VAL_USEs first (note_stores does nothing
6506 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
6507 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
6510 while (n1
< n2
&& mos
[n1
].type
== MO_VAL_USE
)
6512 while (n1
< n2
&& mos
[n2
].type
!= MO_VAL_USE
)
6524 n2
= VTI (bb
)->mos
.length () - 1;
6527 while (n1
< n2
&& mos
[n1
].type
== MO_CLOBBER
)
6529 while (n1
< n2
&& mos
[n2
].type
!= MO_CLOBBER
)
6542 static enum var_init_status
6543 find_src_status (dataflow_set
*in
, rtx src
)
6545 tree decl
= NULL_TREE
;
6546 enum var_init_status status
= VAR_INIT_STATUS_UNINITIALIZED
;
6548 if (! flag_var_tracking_uninit
)
6549 status
= VAR_INIT_STATUS_INITIALIZED
;
6551 if (src
&& REG_P (src
))
6552 decl
= var_debug_decl (REG_EXPR (src
));
6553 else if (src
&& MEM_P (src
))
6554 decl
= var_debug_decl (MEM_EXPR (src
));
6557 status
= get_init_value (in
, src
, dv_from_decl (decl
));
6562 /* SRC is the source of an assignment. Use SET to try to find what
6563 was ultimately assigned to SRC. Return that value if known,
6564 otherwise return SRC itself. */
6567 find_src_set_src (dataflow_set
*set
, rtx src
)
6569 tree decl
= NULL_TREE
; /* The variable being copied around. */
6570 rtx set_src
= NULL_RTX
; /* The value for "decl" stored in "src". */
6572 location_chain nextp
;
6576 if (src
&& REG_P (src
))
6577 decl
= var_debug_decl (REG_EXPR (src
));
6578 else if (src
&& MEM_P (src
))
6579 decl
= var_debug_decl (MEM_EXPR (src
));
6583 decl_or_value dv
= dv_from_decl (decl
);
6585 var
= shared_hash_find (set
->vars
, dv
);
6589 for (i
= 0; i
< var
->n_var_parts
&& !found
; i
++)
6590 for (nextp
= var
->var_part
[i
].loc_chain
; nextp
&& !found
;
6591 nextp
= nextp
->next
)
6592 if (rtx_equal_p (nextp
->loc
, src
))
6594 set_src
= nextp
->set_src
;
6604 /* Compute the changes of variable locations in the basic block BB. */
6607 compute_bb_dataflow (basic_block bb
)
6610 micro_operation
*mo
;
6612 dataflow_set old_out
;
6613 dataflow_set
*in
= &VTI (bb
)->in
;
6614 dataflow_set
*out
= &VTI (bb
)->out
;
6616 dataflow_set_init (&old_out
);
6617 dataflow_set_copy (&old_out
, out
);
6618 dataflow_set_copy (out
, in
);
6620 if (MAY_HAVE_DEBUG_INSNS
)
6621 local_get_addr_cache
= pointer_map_create ();
6623 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
6625 rtx insn
= mo
->insn
;
6630 dataflow_set_clear_at_call (out
);
6635 rtx loc
= mo
->u
.loc
;
6638 var_reg_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6639 else if (MEM_P (loc
))
6640 var_mem_set (out
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
6646 rtx loc
= mo
->u
.loc
;
6650 if (GET_CODE (loc
) == CONCAT
)
6652 val
= XEXP (loc
, 0);
6653 vloc
= XEXP (loc
, 1);
6661 var
= PAT_VAR_LOCATION_DECL (vloc
);
6663 clobber_variable_part (out
, NULL_RTX
,
6664 dv_from_decl (var
), 0, NULL_RTX
);
6667 if (VAL_NEEDS_RESOLUTION (loc
))
6668 val_resolve (out
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
6669 set_variable_part (out
, val
, dv_from_decl (var
), 0,
6670 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6673 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
6674 set_variable_part (out
, PAT_VAR_LOCATION_LOC (vloc
),
6675 dv_from_decl (var
), 0,
6676 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
6683 rtx loc
= mo
->u
.loc
;
6684 rtx val
, vloc
, uloc
;
6686 vloc
= uloc
= XEXP (loc
, 1);
6687 val
= XEXP (loc
, 0);
6689 if (GET_CODE (val
) == CONCAT
)
6691 uloc
= XEXP (val
, 1);
6692 val
= XEXP (val
, 0);
6695 if (VAL_NEEDS_RESOLUTION (loc
))
6696 val_resolve (out
, val
, vloc
, insn
);
6698 val_store (out
, val
, uloc
, insn
, false);
6700 if (VAL_HOLDS_TRACK_EXPR (loc
))
6702 if (GET_CODE (uloc
) == REG
)
6703 var_reg_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6705 else if (GET_CODE (uloc
) == MEM
)
6706 var_mem_set (out
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
6714 rtx loc
= mo
->u
.loc
;
6715 rtx val
, vloc
, uloc
;
6719 uloc
= XEXP (vloc
, 1);
6720 val
= XEXP (vloc
, 0);
6723 if (GET_CODE (uloc
) == SET
)
6725 dstv
= SET_DEST (uloc
);
6726 srcv
= SET_SRC (uloc
);
6734 if (GET_CODE (val
) == CONCAT
)
6736 dstv
= vloc
= XEXP (val
, 1);
6737 val
= XEXP (val
, 0);
6740 if (GET_CODE (vloc
) == SET
)
6742 srcv
= SET_SRC (vloc
);
6744 gcc_assert (val
!= srcv
);
6745 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
6747 dstv
= vloc
= SET_DEST (vloc
);
6749 if (VAL_NEEDS_RESOLUTION (loc
))
6750 val_resolve (out
, val
, srcv
, insn
);
6752 else if (VAL_NEEDS_RESOLUTION (loc
))
6754 gcc_assert (GET_CODE (uloc
) == SET
6755 && GET_CODE (SET_SRC (uloc
)) == REG
);
6756 val_resolve (out
, val
, SET_SRC (uloc
), insn
);
6759 if (VAL_HOLDS_TRACK_EXPR (loc
))
6761 if (VAL_EXPR_IS_CLOBBERED (loc
))
6764 var_reg_delete (out
, uloc
, true);
6765 else if (MEM_P (uloc
))
6767 gcc_assert (MEM_P (dstv
));
6768 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
6769 var_mem_delete (out
, dstv
, true);
6774 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
6775 rtx src
= NULL
, dst
= uloc
;
6776 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
6778 if (GET_CODE (uloc
) == SET
)
6780 src
= SET_SRC (uloc
);
6781 dst
= SET_DEST (uloc
);
6786 if (flag_var_tracking_uninit
)
6788 status
= find_src_status (in
, src
);
6790 if (status
== VAR_INIT_STATUS_UNKNOWN
)
6791 status
= find_src_status (out
, src
);
6794 src
= find_src_set_src (in
, src
);
6798 var_reg_delete_and_set (out
, dst
, !copied_p
,
6800 else if (MEM_P (dst
))
6802 gcc_assert (MEM_P (dstv
));
6803 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
6804 var_mem_delete_and_set (out
, dstv
, !copied_p
,
6809 else if (REG_P (uloc
))
6810 var_regno_delete (out
, REGNO (uloc
));
6811 else if (MEM_P (uloc
))
6813 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
6814 gcc_checking_assert (dstv
== vloc
);
6816 clobber_overlapping_mems (out
, vloc
);
6819 val_store (out
, val
, dstv
, insn
, true);
6825 rtx loc
= mo
->u
.loc
;
6828 if (GET_CODE (loc
) == SET
)
6830 set_src
= SET_SRC (loc
);
6831 loc
= SET_DEST (loc
);
6835 var_reg_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6837 else if (MEM_P (loc
))
6838 var_mem_delete_and_set (out
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
6845 rtx loc
= mo
->u
.loc
;
6846 enum var_init_status src_status
;
6849 if (GET_CODE (loc
) == SET
)
6851 set_src
= SET_SRC (loc
);
6852 loc
= SET_DEST (loc
);
6855 if (! flag_var_tracking_uninit
)
6856 src_status
= VAR_INIT_STATUS_INITIALIZED
;
6859 src_status
= find_src_status (in
, set_src
);
6861 if (src_status
== VAR_INIT_STATUS_UNKNOWN
)
6862 src_status
= find_src_status (out
, set_src
);
6865 set_src
= find_src_set_src (in
, set_src
);
6868 var_reg_delete_and_set (out
, loc
, false, src_status
, set_src
);
6869 else if (MEM_P (loc
))
6870 var_mem_delete_and_set (out
, loc
, false, src_status
, set_src
);
6876 rtx loc
= mo
->u
.loc
;
6879 var_reg_delete (out
, loc
, false);
6880 else if (MEM_P (loc
))
6881 var_mem_delete (out
, loc
, false);
6887 rtx loc
= mo
->u
.loc
;
6890 var_reg_delete (out
, loc
, true);
6891 else if (MEM_P (loc
))
6892 var_mem_delete (out
, loc
, true);
6897 out
->stack_adjust
+= mo
->u
.adjust
;
6902 if (MAY_HAVE_DEBUG_INSNS
)
6904 pointer_map_destroy (local_get_addr_cache
);
6905 local_get_addr_cache
= NULL
;
6907 dataflow_set_equiv_regs (out
);
6908 shared_hash_htab (out
->vars
)
6909 .traverse
<dataflow_set
*, canonicalize_values_mark
> (out
);
6910 shared_hash_htab (out
->vars
)
6911 .traverse
<dataflow_set
*, canonicalize_values_star
> (out
);
6913 shared_hash_htab (out
->vars
)
6914 .traverse
<dataflow_set
*, canonicalize_loc_order_check
> (out
);
6917 changed
= dataflow_set_different (&old_out
, out
);
6918 dataflow_set_destroy (&old_out
);
6922 /* Find the locations of variables in the whole function. */
6925 vt_find_locations (void)
6927 fibheap_t worklist
, pending
, fibheap_swap
;
6928 sbitmap visited
, in_worklist
, in_pending
, sbitmap_swap
;
6935 int htabmax
= PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE
);
6936 bool success
= true;
6938 timevar_push (TV_VAR_TRACKING_DATAFLOW
);
6939 /* Compute reverse top sord order of the inverted CFG
6940 so that the data-flow runs faster. */
6941 rc_order
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
));
6942 bb_order
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
6943 int num
= inverted_post_order_compute (rc_order
);
6944 for (i
= 0; i
< num
; i
++)
6945 bb_order
[rc_order
[i
]] = i
;
6948 worklist
= fibheap_new ();
6949 pending
= fibheap_new ();
6950 visited
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6951 in_worklist
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6952 in_pending
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6953 bitmap_clear (in_worklist
);
6955 FOR_EACH_BB_FN (bb
, cfun
)
6956 fibheap_insert (pending
, bb_order
[bb
->index
], bb
);
6957 bitmap_ones (in_pending
);
6959 while (success
&& !fibheap_empty (pending
))
6961 fibheap_swap
= pending
;
6963 worklist
= fibheap_swap
;
6964 sbitmap_swap
= in_pending
;
6965 in_pending
= in_worklist
;
6966 in_worklist
= sbitmap_swap
;
6968 bitmap_clear (visited
);
6970 while (!fibheap_empty (worklist
))
6972 bb
= (basic_block
) fibheap_extract_min (worklist
);
6973 bitmap_clear_bit (in_worklist
, bb
->index
);
6974 gcc_assert (!bitmap_bit_p (visited
, bb
->index
));
6975 if (!bitmap_bit_p (visited
, bb
->index
))
6979 int oldinsz
, oldoutsz
;
6981 bitmap_set_bit (visited
, bb
->index
);
6983 if (VTI (bb
)->in
.vars
)
6986 -= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
6987 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
6988 oldinsz
= shared_hash_htab (VTI (bb
)->in
.vars
).elements ();
6989 oldoutsz
= shared_hash_htab (VTI (bb
)->out
.vars
).elements ();
6992 oldinsz
= oldoutsz
= 0;
6994 if (MAY_HAVE_DEBUG_INSNS
)
6996 dataflow_set
*in
= &VTI (bb
)->in
, *first_out
= NULL
;
6997 bool first
= true, adjust
= false;
6999 /* Calculate the IN set as the intersection of
7000 predecessor OUT sets. */
7002 dataflow_set_clear (in
);
7003 dst_can_be_shared
= true;
7005 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7006 if (!VTI (e
->src
)->flooded
)
7007 gcc_assert (bb_order
[bb
->index
]
7008 <= bb_order
[e
->src
->index
]);
7011 dataflow_set_copy (in
, &VTI (e
->src
)->out
);
7012 first_out
= &VTI (e
->src
)->out
;
7017 dataflow_set_merge (in
, &VTI (e
->src
)->out
);
7023 dataflow_post_merge_adjust (in
, &VTI (bb
)->permp
);
7025 /* Merge and merge_adjust should keep entries in
7027 shared_hash_htab (in
->vars
)
7028 .traverse
<dataflow_set
*,
7029 canonicalize_loc_order_check
> (in
);
7031 if (dst_can_be_shared
)
7033 shared_hash_destroy (in
->vars
);
7034 in
->vars
= shared_hash_copy (first_out
->vars
);
7038 VTI (bb
)->flooded
= true;
7042 /* Calculate the IN set as union of predecessor OUT sets. */
7043 dataflow_set_clear (&VTI (bb
)->in
);
7044 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7045 dataflow_set_union (&VTI (bb
)->in
, &VTI (e
->src
)->out
);
7048 changed
= compute_bb_dataflow (bb
);
7049 htabsz
+= shared_hash_htab (VTI (bb
)->in
.vars
).size ()
7050 + shared_hash_htab (VTI (bb
)->out
.vars
).size ();
7052 if (htabmax
&& htabsz
> htabmax
)
7054 if (MAY_HAVE_DEBUG_INSNS
)
7055 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7056 "variable tracking size limit exceeded with "
7057 "-fvar-tracking-assignments, retrying without");
7059 inform (DECL_SOURCE_LOCATION (cfun
->decl
),
7060 "variable tracking size limit exceeded");
7067 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7069 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7072 if (bitmap_bit_p (visited
, e
->dest
->index
))
7074 if (!bitmap_bit_p (in_pending
, e
->dest
->index
))
7076 /* Send E->DEST to next round. */
7077 bitmap_set_bit (in_pending
, e
->dest
->index
);
7078 fibheap_insert (pending
,
7079 bb_order
[e
->dest
->index
],
7083 else if (!bitmap_bit_p (in_worklist
, e
->dest
->index
))
7085 /* Add E->DEST to current round. */
7086 bitmap_set_bit (in_worklist
, e
->dest
->index
);
7087 fibheap_insert (worklist
, bb_order
[e
->dest
->index
],
7095 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
7097 (int)shared_hash_htab (VTI (bb
)->in
.vars
).size (),
7099 (int)shared_hash_htab (VTI (bb
)->out
.vars
).size (),
7101 (int)worklist
->nodes
, (int)pending
->nodes
, htabsz
);
7103 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7105 fprintf (dump_file
, "BB %i IN:\n", bb
->index
);
7106 dump_dataflow_set (&VTI (bb
)->in
);
7107 fprintf (dump_file
, "BB %i OUT:\n", bb
->index
);
7108 dump_dataflow_set (&VTI (bb
)->out
);
7114 if (success
&& MAY_HAVE_DEBUG_INSNS
)
7115 FOR_EACH_BB_FN (bb
, cfun
)
7116 gcc_assert (VTI (bb
)->flooded
);
7119 fibheap_delete (worklist
);
7120 fibheap_delete (pending
);
7121 sbitmap_free (visited
);
7122 sbitmap_free (in_worklist
);
7123 sbitmap_free (in_pending
);
7125 timevar_pop (TV_VAR_TRACKING_DATAFLOW
);
7129 /* Print the content of the LIST to dump file. */
7132 dump_attrs_list (attrs list
)
7134 for (; list
; list
= list
->next
)
7136 if (dv_is_decl_p (list
->dv
))
7137 print_mem_expr (dump_file
, dv_as_decl (list
->dv
));
7139 print_rtl_single (dump_file
, dv_as_value (list
->dv
));
7140 fprintf (dump_file
, "+" HOST_WIDE_INT_PRINT_DEC
, list
->offset
);
7142 fprintf (dump_file
, "\n");
7145 /* Print the information about variable *SLOT to dump file. */
7148 dump_var_tracking_slot (variable_def
**slot
, void *data ATTRIBUTE_UNUSED
)
7150 variable var
= *slot
;
7154 /* Continue traversing the hash table. */
7158 /* Print the information about variable VAR to dump file. */
7161 dump_var (variable var
)
7164 location_chain node
;
7166 if (dv_is_decl_p (var
->dv
))
7168 const_tree decl
= dv_as_decl (var
->dv
);
7170 if (DECL_NAME (decl
))
7172 fprintf (dump_file
, " name: %s",
7173 IDENTIFIER_POINTER (DECL_NAME (decl
)));
7174 if (dump_flags
& TDF_UID
)
7175 fprintf (dump_file
, "D.%u", DECL_UID (decl
));
7177 else if (TREE_CODE (decl
) == DEBUG_EXPR_DECL
)
7178 fprintf (dump_file
, " name: D#%u", DEBUG_TEMP_UID (decl
));
7180 fprintf (dump_file
, " name: D.%u", DECL_UID (decl
));
7181 fprintf (dump_file
, "\n");
7185 fputc (' ', dump_file
);
7186 print_rtl_single (dump_file
, dv_as_value (var
->dv
));
7189 for (i
= 0; i
< var
->n_var_parts
; i
++)
7191 fprintf (dump_file
, " offset %ld\n",
7192 (long)(var
->onepart
? 0 : VAR_PART_OFFSET (var
, i
)));
7193 for (node
= var
->var_part
[i
].loc_chain
; node
; node
= node
->next
)
7195 fprintf (dump_file
, " ");
7196 if (node
->init
== VAR_INIT_STATUS_UNINITIALIZED
)
7197 fprintf (dump_file
, "[uninit]");
7198 print_rtl_single (dump_file
, node
->loc
);
7203 /* Print the information about variables from hash table VARS to dump file. */
7206 dump_vars (variable_table_type vars
)
7208 if (vars
.elements () > 0)
7210 fprintf (dump_file
, "Variables:\n");
7211 vars
.traverse
<void *, dump_var_tracking_slot
> (NULL
);
7215 /* Print the dataflow set SET to dump file. */
7218 dump_dataflow_set (dataflow_set
*set
)
7222 fprintf (dump_file
, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC
"\n",
7224 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
7228 fprintf (dump_file
, "Reg %d:", i
);
7229 dump_attrs_list (set
->regs
[i
]);
7232 dump_vars (shared_hash_htab (set
->vars
));
7233 fprintf (dump_file
, "\n");
7236 /* Print the IN and OUT sets for each basic block to dump file. */
7239 dump_dataflow_sets (void)
7243 FOR_EACH_BB_FN (bb
, cfun
)
7245 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
7246 fprintf (dump_file
, "IN:\n");
7247 dump_dataflow_set (&VTI (bb
)->in
);
7248 fprintf (dump_file
, "OUT:\n");
7249 dump_dataflow_set (&VTI (bb
)->out
);
7253 /* Return the variable for DV in dropped_values, inserting one if
7254 requested with INSERT. */
7256 static inline variable
7257 variable_from_dropped (decl_or_value dv
, enum insert_option insert
)
7259 variable_def
**slot
;
7261 onepart_enum_t onepart
;
7263 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
), insert
);
7271 gcc_checking_assert (insert
== INSERT
);
7273 onepart
= dv_onepart_p (dv
);
7275 gcc_checking_assert (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
);
7277 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7279 empty_var
->refcount
= 1;
7280 empty_var
->n_var_parts
= 0;
7281 empty_var
->onepart
= onepart
;
7282 empty_var
->in_changed_variables
= false;
7283 empty_var
->var_part
[0].loc_chain
= NULL
;
7284 empty_var
->var_part
[0].cur_loc
= NULL
;
7285 VAR_LOC_1PAUX (empty_var
) = NULL
;
7286 set_dv_changed (dv
, true);
7293 /* Recover the one-part aux from dropped_values. */
7295 static struct onepart_aux
*
7296 recover_dropped_1paux (variable var
)
7300 gcc_checking_assert (var
->onepart
);
7302 if (VAR_LOC_1PAUX (var
))
7303 return VAR_LOC_1PAUX (var
);
7305 if (var
->onepart
== ONEPART_VDECL
)
7308 dvar
= variable_from_dropped (var
->dv
, NO_INSERT
);
7313 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (dvar
);
7314 VAR_LOC_1PAUX (dvar
) = NULL
;
7316 return VAR_LOC_1PAUX (var
);
7319 /* Add variable VAR to the hash table of changed variables and
7320 if it has no locations delete it from SET's hash table. */
7323 variable_was_changed (variable var
, dataflow_set
*set
)
7325 hashval_t hash
= dv_htab_hash (var
->dv
);
7329 variable_def
**slot
;
7331 /* Remember this decl or VALUE has been added to changed_variables. */
7332 set_dv_changed (var
->dv
, true);
7334 slot
= changed_variables
.find_slot_with_hash (var
->dv
, hash
, INSERT
);
7338 variable old_var
= *slot
;
7339 gcc_assert (old_var
->in_changed_variables
);
7340 old_var
->in_changed_variables
= false;
7341 if (var
!= old_var
&& var
->onepart
)
7343 /* Restore the auxiliary info from an empty variable
7344 previously created for changed_variables, so it is
7346 gcc_checking_assert (!VAR_LOC_1PAUX (var
));
7347 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (old_var
);
7348 VAR_LOC_1PAUX (old_var
) = NULL
;
7350 variable_htab_free (*slot
);
7353 if (set
&& var
->n_var_parts
== 0)
7355 onepart_enum_t onepart
= var
->onepart
;
7356 variable empty_var
= NULL
;
7357 variable_def
**dslot
= NULL
;
7359 if (onepart
== ONEPART_VALUE
|| onepart
== ONEPART_DEXPR
)
7361 dslot
= dropped_values
.find_slot_with_hash (var
->dv
,
7362 dv_htab_hash (var
->dv
),
7368 gcc_checking_assert (!empty_var
->in_changed_variables
);
7369 if (!VAR_LOC_1PAUX (var
))
7371 VAR_LOC_1PAUX (var
) = VAR_LOC_1PAUX (empty_var
);
7372 VAR_LOC_1PAUX (empty_var
) = NULL
;
7375 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
7381 empty_var
= (variable
) pool_alloc (onepart_pool (onepart
));
7382 empty_var
->dv
= var
->dv
;
7383 empty_var
->refcount
= 1;
7384 empty_var
->n_var_parts
= 0;
7385 empty_var
->onepart
= onepart
;
7388 empty_var
->refcount
++;
7393 empty_var
->refcount
++;
7394 empty_var
->in_changed_variables
= true;
7398 empty_var
->var_part
[0].loc_chain
= NULL
;
7399 empty_var
->var_part
[0].cur_loc
= NULL
;
7400 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (var
);
7401 VAR_LOC_1PAUX (var
) = NULL
;
7407 if (var
->onepart
&& !VAR_LOC_1PAUX (var
))
7408 recover_dropped_1paux (var
);
7410 var
->in_changed_variables
= true;
7417 if (var
->n_var_parts
== 0)
7419 variable_def
**slot
;
7422 slot
= shared_hash_find_slot_noinsert (set
->vars
, var
->dv
);
7425 if (shared_hash_shared (set
->vars
))
7426 slot
= shared_hash_find_slot_unshare (&set
->vars
, var
->dv
,
7428 shared_hash_htab (set
->vars
).clear_slot (slot
);
7434 /* Look for the index in VAR->var_part corresponding to OFFSET.
7435 Return -1 if not found. If INSERTION_POINT is non-NULL, the
7436 referenced int will be set to the index that the part has or should
7437 have, if it should be inserted. */
7440 find_variable_location_part (variable var
, HOST_WIDE_INT offset
,
7441 int *insertion_point
)
7450 if (insertion_point
)
7451 *insertion_point
= 0;
7453 return var
->n_var_parts
- 1;
7456 /* Find the location part. */
7458 high
= var
->n_var_parts
;
7461 pos
= (low
+ high
) / 2;
7462 if (VAR_PART_OFFSET (var
, pos
) < offset
)
7469 if (insertion_point
)
7470 *insertion_point
= pos
;
7472 if (pos
< var
->n_var_parts
&& VAR_PART_OFFSET (var
, pos
) == offset
)
7478 static variable_def
**
7479 set_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7480 decl_or_value dv
, HOST_WIDE_INT offset
,
7481 enum var_init_status initialized
, rtx set_src
)
7484 location_chain node
, next
;
7485 location_chain
*nextp
;
7487 onepart_enum_t onepart
;
7492 onepart
= var
->onepart
;
7494 onepart
= dv_onepart_p (dv
);
7496 gcc_checking_assert (offset
== 0 || !onepart
);
7497 gcc_checking_assert (loc
!= dv_as_opaque (dv
));
7499 if (! flag_var_tracking_uninit
)
7500 initialized
= VAR_INIT_STATUS_INITIALIZED
;
7504 /* Create new variable information. */
7505 var
= (variable
) pool_alloc (onepart_pool (onepart
));
7508 var
->n_var_parts
= 1;
7509 var
->onepart
= onepart
;
7510 var
->in_changed_variables
= false;
7512 VAR_LOC_1PAUX (var
) = NULL
;
7514 VAR_PART_OFFSET (var
, 0) = offset
;
7515 var
->var_part
[0].loc_chain
= NULL
;
7516 var
->var_part
[0].cur_loc
= NULL
;
7519 nextp
= &var
->var_part
[0].loc_chain
;
7525 gcc_assert (dv_as_opaque (var
->dv
) == dv_as_opaque (dv
));
7529 if (GET_CODE (loc
) == VALUE
)
7531 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7532 nextp
= &node
->next
)
7533 if (GET_CODE (node
->loc
) == VALUE
)
7535 if (node
->loc
== loc
)
7540 if (canon_value_cmp (node
->loc
, loc
))
7548 else if (REG_P (node
->loc
) || MEM_P (node
->loc
))
7556 else if (REG_P (loc
))
7558 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7559 nextp
= &node
->next
)
7560 if (REG_P (node
->loc
))
7562 if (REGNO (node
->loc
) < REGNO (loc
))
7566 if (REGNO (node
->loc
) == REGNO (loc
))
7579 else if (MEM_P (loc
))
7581 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7582 nextp
= &node
->next
)
7583 if (REG_P (node
->loc
))
7585 else if (MEM_P (node
->loc
))
7587 if ((r
= loc_cmp (XEXP (node
->loc
, 0), XEXP (loc
, 0))) >= 0)
7599 for (nextp
= &var
->var_part
[0].loc_chain
; (node
= *nextp
);
7600 nextp
= &node
->next
)
7601 if ((r
= loc_cmp (node
->loc
, loc
)) >= 0)
7609 if (shared_var_p (var
, set
->vars
))
7611 slot
= unshare_variable (set
, slot
, var
, initialized
);
7613 for (nextp
= &var
->var_part
[0].loc_chain
; c
;
7614 nextp
= &(*nextp
)->next
)
7616 gcc_assert ((!node
&& !*nextp
) || node
->loc
== (*nextp
)->loc
);
7623 gcc_assert (dv_as_decl (var
->dv
) == dv_as_decl (dv
));
7625 pos
= find_variable_location_part (var
, offset
, &inspos
);
7629 node
= var
->var_part
[pos
].loc_chain
;
7632 && ((REG_P (node
->loc
) && REG_P (loc
)
7633 && REGNO (node
->loc
) == REGNO (loc
))
7634 || rtx_equal_p (node
->loc
, loc
)))
7636 /* LOC is in the beginning of the chain so we have nothing
7638 if (node
->init
< initialized
)
7639 node
->init
= initialized
;
7640 if (set_src
!= NULL
)
7641 node
->set_src
= set_src
;
7647 /* We have to make a copy of a shared variable. */
7648 if (shared_var_p (var
, set
->vars
))
7650 slot
= unshare_variable (set
, slot
, var
, initialized
);
7657 /* We have not found the location part, new one will be created. */
7659 /* We have to make a copy of the shared variable. */
7660 if (shared_var_p (var
, set
->vars
))
7662 slot
= unshare_variable (set
, slot
, var
, initialized
);
7666 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
7667 thus there are at most MAX_VAR_PARTS different offsets. */
7668 gcc_assert (var
->n_var_parts
< MAX_VAR_PARTS
7669 && (!var
->n_var_parts
|| !onepart
));
7671 /* We have to move the elements of array starting at index
7672 inspos to the next position. */
7673 for (pos
= var
->n_var_parts
; pos
> inspos
; pos
--)
7674 var
->var_part
[pos
] = var
->var_part
[pos
- 1];
7677 gcc_checking_assert (!onepart
);
7678 VAR_PART_OFFSET (var
, pos
) = offset
;
7679 var
->var_part
[pos
].loc_chain
= NULL
;
7680 var
->var_part
[pos
].cur_loc
= NULL
;
7683 /* Delete the location from the list. */
7684 nextp
= &var
->var_part
[pos
].loc_chain
;
7685 for (node
= var
->var_part
[pos
].loc_chain
; node
; node
= next
)
7688 if ((REG_P (node
->loc
) && REG_P (loc
)
7689 && REGNO (node
->loc
) == REGNO (loc
))
7690 || rtx_equal_p (node
->loc
, loc
))
7692 /* Save these values, to assign to the new node, before
7693 deleting this one. */
7694 if (node
->init
> initialized
)
7695 initialized
= node
->init
;
7696 if (node
->set_src
!= NULL
&& set_src
== NULL
)
7697 set_src
= node
->set_src
;
7698 if (var
->var_part
[pos
].cur_loc
== node
->loc
)
7699 var
->var_part
[pos
].cur_loc
= NULL
;
7700 pool_free (loc_chain_pool
, node
);
7705 nextp
= &node
->next
;
7708 nextp
= &var
->var_part
[pos
].loc_chain
;
7711 /* Add the location to the beginning. */
7712 node
= (location_chain
) pool_alloc (loc_chain_pool
);
7714 node
->init
= initialized
;
7715 node
->set_src
= set_src
;
7716 node
->next
= *nextp
;
7719 /* If no location was emitted do so. */
7720 if (var
->var_part
[pos
].cur_loc
== NULL
)
7721 variable_was_changed (var
, set
);
7726 /* Set the part of variable's location in the dataflow set SET. The
7727 variable part is specified by variable's declaration in DV and
7728 offset OFFSET and the part's location by LOC. IOPT should be
7729 NO_INSERT if the variable is known to be in SET already and the
7730 variable hash table must not be resized, and INSERT otherwise. */
7733 set_variable_part (dataflow_set
*set
, rtx loc
,
7734 decl_or_value dv
, HOST_WIDE_INT offset
,
7735 enum var_init_status initialized
, rtx set_src
,
7736 enum insert_option iopt
)
7738 variable_def
**slot
;
7740 if (iopt
== NO_INSERT
)
7741 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7744 slot
= shared_hash_find_slot (set
->vars
, dv
);
7746 slot
= shared_hash_find_slot_unshare (&set
->vars
, dv
, iopt
);
7748 set_slot_part (set
, loc
, slot
, dv
, offset
, initialized
, set_src
);
7751 /* Remove all recorded register locations for the given variable part
7752 from dataflow set SET, except for those that are identical to loc.
7753 The variable part is specified by variable's declaration or value
7754 DV and offset OFFSET. */
7756 static variable_def
**
7757 clobber_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7758 HOST_WIDE_INT offset
, rtx set_src
)
7760 variable var
= *slot
;
7761 int pos
= find_variable_location_part (var
, offset
, NULL
);
7765 location_chain node
, next
;
7767 /* Remove the register locations from the dataflow set. */
7768 next
= var
->var_part
[pos
].loc_chain
;
7769 for (node
= next
; node
; node
= next
)
7772 if (node
->loc
!= loc
7773 && (!flag_var_tracking_uninit
7776 || !rtx_equal_p (set_src
, node
->set_src
)))
7778 if (REG_P (node
->loc
))
7783 /* Remove the variable part from the register's
7784 list, but preserve any other variable parts
7785 that might be regarded as live in that same
7787 anextp
= &set
->regs
[REGNO (node
->loc
)];
7788 for (anode
= *anextp
; anode
; anode
= anext
)
7790 anext
= anode
->next
;
7791 if (dv_as_opaque (anode
->dv
) == dv_as_opaque (var
->dv
)
7792 && anode
->offset
== offset
)
7794 pool_free (attrs_pool
, anode
);
7798 anextp
= &anode
->next
;
7802 slot
= delete_slot_part (set
, node
->loc
, slot
, offset
);
7810 /* Remove all recorded register locations for the given variable part
7811 from dataflow set SET, except for those that are identical to loc.
7812 The variable part is specified by variable's declaration or value
7813 DV and offset OFFSET. */
7816 clobber_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7817 HOST_WIDE_INT offset
, rtx set_src
)
7819 variable_def
**slot
;
7821 if (!dv_as_opaque (dv
)
7822 || (!dv_is_value_p (dv
) && ! DECL_P (dv_as_decl (dv
))))
7825 slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7829 clobber_slot_part (set
, loc
, slot
, offset
, set_src
);
7832 /* Delete the part of variable's location from dataflow set SET. The
7833 variable part is specified by its SET->vars slot SLOT and offset
7834 OFFSET and the part's location by LOC. */
7836 static variable_def
**
7837 delete_slot_part (dataflow_set
*set
, rtx loc
, variable_def
**slot
,
7838 HOST_WIDE_INT offset
)
7840 variable var
= *slot
;
7841 int pos
= find_variable_location_part (var
, offset
, NULL
);
7845 location_chain node
, next
;
7846 location_chain
*nextp
;
7850 if (shared_var_p (var
, set
->vars
))
7852 /* If the variable contains the location part we have to
7853 make a copy of the variable. */
7854 for (node
= var
->var_part
[pos
].loc_chain
; node
;
7857 if ((REG_P (node
->loc
) && REG_P (loc
)
7858 && REGNO (node
->loc
) == REGNO (loc
))
7859 || rtx_equal_p (node
->loc
, loc
))
7861 slot
= unshare_variable (set
, slot
, var
,
7862 VAR_INIT_STATUS_UNKNOWN
);
7869 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7870 cur_loc
= VAR_LOC_FROM (var
);
7872 cur_loc
= var
->var_part
[pos
].cur_loc
;
7874 /* Delete the location part. */
7876 nextp
= &var
->var_part
[pos
].loc_chain
;
7877 for (node
= *nextp
; node
; node
= next
)
7880 if ((REG_P (node
->loc
) && REG_P (loc
)
7881 && REGNO (node
->loc
) == REGNO (loc
))
7882 || rtx_equal_p (node
->loc
, loc
))
7884 /* If we have deleted the location which was last emitted
7885 we have to emit new location so add the variable to set
7886 of changed variables. */
7887 if (cur_loc
== node
->loc
)
7890 var
->var_part
[pos
].cur_loc
= NULL
;
7891 if (pos
== 0 && var
->onepart
&& VAR_LOC_1PAUX (var
))
7892 VAR_LOC_FROM (var
) = NULL
;
7894 pool_free (loc_chain_pool
, node
);
7899 nextp
= &node
->next
;
7902 if (var
->var_part
[pos
].loc_chain
== NULL
)
7906 while (pos
< var
->n_var_parts
)
7908 var
->var_part
[pos
] = var
->var_part
[pos
+ 1];
7913 variable_was_changed (var
, set
);
7919 /* Delete the part of variable's location from dataflow set SET. The
7920 variable part is specified by variable's declaration or value DV
7921 and offset OFFSET and the part's location by LOC. */
7924 delete_variable_part (dataflow_set
*set
, rtx loc
, decl_or_value dv
,
7925 HOST_WIDE_INT offset
)
7927 variable_def
**slot
= shared_hash_find_slot_noinsert (set
->vars
, dv
);
7931 delete_slot_part (set
, loc
, slot
, offset
);
7935 /* Structure for passing some other parameters to function
7936 vt_expand_loc_callback. */
7937 struct expand_loc_callback_data
7939 /* The variables and values active at this point. */
7940 variable_table_type vars
;
7942 /* Stack of values and debug_exprs under expansion, and their
7944 auto_vec
<rtx
, 4> expanding
;
7946 /* Stack of values and debug_exprs whose expansion hit recursion
7947 cycles. They will have VALUE_RECURSED_INTO marked when added to
7948 this list. This flag will be cleared if any of its dependencies
7949 resolves to a valid location. So, if the flag remains set at the
7950 end of the search, we know no valid location for this one can
7952 auto_vec
<rtx
, 4> pending
;
7954 /* The maximum depth among the sub-expressions under expansion.
7955 Zero indicates no expansion so far. */
7959 /* Allocate the one-part auxiliary data structure for VAR, with enough
7960 room for COUNT dependencies. */
7963 loc_exp_dep_alloc (variable var
, int count
)
7967 gcc_checking_assert (var
->onepart
);
7969 /* We can be called with COUNT == 0 to allocate the data structure
7970 without any dependencies, e.g. for the backlinks only. However,
7971 if we are specifying a COUNT, then the dependency list must have
7972 been emptied before. It would be possible to adjust pointers or
7973 force it empty here, but this is better done at an earlier point
7974 in the algorithm, so we instead leave an assertion to catch
7976 gcc_checking_assert (!count
7977 || VAR_LOC_DEP_VEC (var
) == NULL
7978 || VAR_LOC_DEP_VEC (var
)->is_empty ());
7980 if (VAR_LOC_1PAUX (var
) && VAR_LOC_DEP_VEC (var
)->space (count
))
7983 allocsize
= offsetof (struct onepart_aux
, deps
)
7984 + vec
<loc_exp_dep
, va_heap
, vl_embed
>::embedded_size (count
);
7986 if (VAR_LOC_1PAUX (var
))
7988 VAR_LOC_1PAUX (var
) = XRESIZEVAR (struct onepart_aux
,
7989 VAR_LOC_1PAUX (var
), allocsize
);
7990 /* If the reallocation moves the onepaux structure, the
7991 back-pointer to BACKLINKS in the first list member will still
7992 point to its old location. Adjust it. */
7993 if (VAR_LOC_DEP_LST (var
))
7994 VAR_LOC_DEP_LST (var
)->pprev
= VAR_LOC_DEP_LSTP (var
);
7998 VAR_LOC_1PAUX (var
) = XNEWVAR (struct onepart_aux
, allocsize
);
7999 *VAR_LOC_DEP_LSTP (var
) = NULL
;
8000 VAR_LOC_FROM (var
) = NULL
;
8001 VAR_LOC_DEPTH (var
).complexity
= 0;
8002 VAR_LOC_DEPTH (var
).entryvals
= 0;
8004 VAR_LOC_DEP_VEC (var
)->embedded_init (count
);
8007 /* Remove all entries from the vector of active dependencies of VAR,
8008 removing them from the back-links lists too. */
8011 loc_exp_dep_clear (variable var
)
8013 while (VAR_LOC_DEP_VEC (var
) && !VAR_LOC_DEP_VEC (var
)->is_empty ())
8015 loc_exp_dep
*led
= &VAR_LOC_DEP_VEC (var
)->last ();
8017 led
->next
->pprev
= led
->pprev
;
8019 *led
->pprev
= led
->next
;
8020 VAR_LOC_DEP_VEC (var
)->pop ();
8024 /* Insert an active dependency from VAR on X to the vector of
8025 dependencies, and add the corresponding back-link to X's list of
8026 back-links in VARS. */
8029 loc_exp_insert_dep (variable var
, rtx x
, variable_table_type vars
)
8035 dv
= dv_from_rtx (x
);
8037 /* ??? Build a vector of variables parallel to EXPANDING, to avoid
8038 an additional look up? */
8039 xvar
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8043 xvar
= variable_from_dropped (dv
, NO_INSERT
);
8044 gcc_checking_assert (xvar
);
8047 /* No point in adding the same backlink more than once. This may
8048 arise if say the same value appears in two complex expressions in
8049 the same loc_list, or even more than once in a single
8051 if (VAR_LOC_DEP_LST (xvar
) && VAR_LOC_DEP_LST (xvar
)->dv
== var
->dv
)
8054 if (var
->onepart
== NOT_ONEPART
)
8055 led
= (loc_exp_dep
*) pool_alloc (loc_exp_dep_pool
);
8059 memset (&empty
, 0, sizeof (empty
));
8060 VAR_LOC_DEP_VEC (var
)->quick_push (empty
);
8061 led
= &VAR_LOC_DEP_VEC (var
)->last ();
8066 loc_exp_dep_alloc (xvar
, 0);
8067 led
->pprev
= VAR_LOC_DEP_LSTP (xvar
);
8068 led
->next
= *led
->pprev
;
8070 led
->next
->pprev
= &led
->next
;
8074 /* Create active dependencies of VAR on COUNT values starting at
8075 VALUE, and corresponding back-links to the entries in VARS. Return
8076 true if we found any pending-recursion results. */
8079 loc_exp_dep_set (variable var
, rtx result
, rtx
*value
, int count
,
8080 variable_table_type vars
)
8082 bool pending_recursion
= false;
8084 gcc_checking_assert (VAR_LOC_DEP_VEC (var
) == NULL
8085 || VAR_LOC_DEP_VEC (var
)->is_empty ());
8087 /* Set up all dependencies from last_child (as set up at the end of
8088 the loop above) to the end. */
8089 loc_exp_dep_alloc (var
, count
);
8095 if (!pending_recursion
)
8096 pending_recursion
= !result
&& VALUE_RECURSED_INTO (x
);
8098 loc_exp_insert_dep (var
, x
, vars
);
8101 return pending_recursion
;
8104 /* Notify the back-links of IVAR that are pending recursion that we
8105 have found a non-NIL value for it, so they are cleared for another
8106 attempt to compute a current location. */
8109 notify_dependents_of_resolved_value (variable ivar
, variable_table_type vars
)
8111 loc_exp_dep
*led
, *next
;
8113 for (led
= VAR_LOC_DEP_LST (ivar
); led
; led
= next
)
8115 decl_or_value dv
= led
->dv
;
8120 if (dv_is_value_p (dv
))
8122 rtx value
= dv_as_value (dv
);
8124 /* If we have already resolved it, leave it alone. */
8125 if (!VALUE_RECURSED_INTO (value
))
8128 /* Check that VALUE_RECURSED_INTO, true from the test above,
8129 implies NO_LOC_P. */
8130 gcc_checking_assert (NO_LOC_P (value
));
8132 /* We won't notify variables that are being expanded,
8133 because their dependency list is cleared before
8135 NO_LOC_P (value
) = false;
8136 VALUE_RECURSED_INTO (value
) = false;
8138 gcc_checking_assert (dv_changed_p (dv
));
8142 gcc_checking_assert (dv_onepart_p (dv
) != NOT_ONEPART
);
8143 if (!dv_changed_p (dv
))
8147 var
= vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8150 var
= variable_from_dropped (dv
, NO_INSERT
);
8153 notify_dependents_of_resolved_value (var
, vars
);
8156 next
->pprev
= led
->pprev
;
8164 static rtx
vt_expand_loc_callback (rtx x
, bitmap regs
,
8165 int max_depth
, void *data
);
8167 /* Return the combined depth, when one sub-expression evaluated to
8168 BEST_DEPTH and the previous known depth was SAVED_DEPTH. */
8170 static inline expand_depth
8171 update_depth (expand_depth saved_depth
, expand_depth best_depth
)
8173 /* If we didn't find anything, stick with what we had. */
8174 if (!best_depth
.complexity
)
8177 /* If we found hadn't found anything, use the depth of the current
8178 expression. Do NOT add one extra level, we want to compute the
8179 maximum depth among sub-expressions. We'll increment it later,
8181 if (!saved_depth
.complexity
)
8184 /* Combine the entryval count so that regardless of which one we
8185 return, the entryval count is accurate. */
8186 best_depth
.entryvals
= saved_depth
.entryvals
8187 = best_depth
.entryvals
+ saved_depth
.entryvals
;
8189 if (saved_depth
.complexity
< best_depth
.complexity
)
8195 /* Expand VAR to a location RTX, updating its cur_loc. Use REGS and
8196 DATA for cselib expand callback. If PENDRECP is given, indicate in
8197 it whether any sub-expression couldn't be fully evaluated because
8198 it is pending recursion resolution. */
8201 vt_expand_var_loc_chain (variable var
, bitmap regs
, void *data
, bool *pendrecp
)
8203 struct expand_loc_callback_data
*elcd
8204 = (struct expand_loc_callback_data
*) data
;
8205 location_chain loc
, next
;
8207 int first_child
, result_first_child
, last_child
;
8208 bool pending_recursion
;
8209 rtx loc_from
= NULL
;
8210 struct elt_loc_list
*cloc
= NULL
;
8211 expand_depth depth
= { 0, 0 }, saved_depth
= elcd
->depth
;
8212 int wanted_entryvals
, found_entryvals
= 0;
8214 /* Clear all backlinks pointing at this, so that we're not notified
8215 while we're active. */
8216 loc_exp_dep_clear (var
);
8219 if (var
->onepart
== ONEPART_VALUE
)
8221 cselib_val
*val
= CSELIB_VAL_PTR (dv_as_value (var
->dv
));
8223 gcc_checking_assert (cselib_preserved_value_p (val
));
8228 first_child
= result_first_child
= last_child
8229 = elcd
->expanding
.length ();
8231 wanted_entryvals
= found_entryvals
;
8233 /* Attempt to expand each available location in turn. */
8234 for (next
= loc
= var
->n_var_parts
? var
->var_part
[0].loc_chain
: NULL
;
8235 loc
|| cloc
; loc
= next
)
8237 result_first_child
= last_child
;
8241 loc_from
= cloc
->loc
;
8244 if (unsuitable_loc (loc_from
))
8249 loc_from
= loc
->loc
;
8253 gcc_checking_assert (!unsuitable_loc (loc_from
));
8255 elcd
->depth
.complexity
= elcd
->depth
.entryvals
= 0;
8256 result
= cselib_expand_value_rtx_cb (loc_from
, regs
, EXPR_DEPTH
,
8257 vt_expand_loc_callback
, data
);
8258 last_child
= elcd
->expanding
.length ();
8262 depth
= elcd
->depth
;
8264 gcc_checking_assert (depth
.complexity
8265 || result_first_child
== last_child
);
8267 if (last_child
- result_first_child
!= 1)
8269 if (!depth
.complexity
&& GET_CODE (result
) == ENTRY_VALUE
)
8274 if (depth
.complexity
<= EXPR_USE_DEPTH
)
8276 if (depth
.entryvals
<= wanted_entryvals
)
8278 else if (!found_entryvals
|| depth
.entryvals
< found_entryvals
)
8279 found_entryvals
= depth
.entryvals
;
8285 /* Set it up in case we leave the loop. */
8286 depth
.complexity
= depth
.entryvals
= 0;
8288 result_first_child
= first_child
;
8291 if (!loc_from
&& wanted_entryvals
< found_entryvals
)
8293 /* We found entries with ENTRY_VALUEs and skipped them. Since
8294 we could not find any expansions without ENTRY_VALUEs, but we
8295 found at least one with them, go back and get an entry with
8296 the minimum number ENTRY_VALUE count that we found. We could
8297 avoid looping, but since each sub-loc is already resolved,
8298 the re-expansion should be trivial. ??? Should we record all
8299 attempted locs as dependencies, so that we retry the
8300 expansion should any of them change, in the hope it can give
8301 us a new entry without an ENTRY_VALUE? */
8302 elcd
->expanding
.truncate (first_child
);
8306 /* Register all encountered dependencies as active. */
8307 pending_recursion
= loc_exp_dep_set
8308 (var
, result
, elcd
->expanding
.address () + result_first_child
,
8309 last_child
- result_first_child
, elcd
->vars
);
8311 elcd
->expanding
.truncate (first_child
);
8313 /* Record where the expansion came from. */
8314 gcc_checking_assert (!result
|| !pending_recursion
);
8315 VAR_LOC_FROM (var
) = loc_from
;
8316 VAR_LOC_DEPTH (var
) = depth
;
8318 gcc_checking_assert (!depth
.complexity
== !result
);
8320 elcd
->depth
= update_depth (saved_depth
, depth
);
8322 /* Indicate whether any of the dependencies are pending recursion
8325 *pendrecp
= pending_recursion
;
8327 if (!pendrecp
|| !pending_recursion
)
8328 var
->var_part
[0].cur_loc
= result
;
8333 /* Callback for cselib_expand_value, that looks for expressions
8334 holding the value in the var-tracking hash tables. Return X for
8335 standard processing, anything else is to be used as-is. */
8338 vt_expand_loc_callback (rtx x
, bitmap regs
,
8339 int max_depth ATTRIBUTE_UNUSED
,
8342 struct expand_loc_callback_data
*elcd
8343 = (struct expand_loc_callback_data
*) data
;
8347 bool pending_recursion
= false;
8348 bool from_empty
= false;
8350 switch (GET_CODE (x
))
8353 subreg
= cselib_expand_value_rtx_cb (SUBREG_REG (x
), regs
,
8355 vt_expand_loc_callback
, data
);
8360 result
= simplify_gen_subreg (GET_MODE (x
), subreg
,
8361 GET_MODE (SUBREG_REG (x
)),
8364 /* Invalid SUBREGs are ok in debug info. ??? We could try
8365 alternate expansions for the VALUE as well. */
8367 result
= gen_rtx_raw_SUBREG (GET_MODE (x
), subreg
, SUBREG_BYTE (x
));
8373 dv
= dv_from_rtx (x
);
8380 elcd
->expanding
.safe_push (x
);
8382 /* Check that VALUE_RECURSED_INTO implies NO_LOC_P. */
8383 gcc_checking_assert (!VALUE_RECURSED_INTO (x
) || NO_LOC_P (x
));
8387 gcc_checking_assert (VALUE_RECURSED_INTO (x
) || !dv_changed_p (dv
));
8391 var
= elcd
->vars
.find_with_hash (dv
, dv_htab_hash (dv
));
8396 var
= variable_from_dropped (dv
, INSERT
);
8399 gcc_checking_assert (var
);
8401 if (!dv_changed_p (dv
))
8403 gcc_checking_assert (!NO_LOC_P (x
));
8404 gcc_checking_assert (var
->var_part
[0].cur_loc
);
8405 gcc_checking_assert (VAR_LOC_1PAUX (var
));
8406 gcc_checking_assert (VAR_LOC_1PAUX (var
)->depth
.complexity
);
8408 elcd
->depth
= update_depth (elcd
->depth
, VAR_LOC_1PAUX (var
)->depth
);
8410 return var
->var_part
[0].cur_loc
;
8413 VALUE_RECURSED_INTO (x
) = true;
8414 /* This is tentative, but it makes some tests simpler. */
8415 NO_LOC_P (x
) = true;
8417 gcc_checking_assert (var
->n_var_parts
== 1 || from_empty
);
8419 result
= vt_expand_var_loc_chain (var
, regs
, data
, &pending_recursion
);
8421 if (pending_recursion
)
8423 gcc_checking_assert (!result
);
8424 elcd
->pending
.safe_push (x
);
8428 NO_LOC_P (x
) = !result
;
8429 VALUE_RECURSED_INTO (x
) = false;
8430 set_dv_changed (dv
, false);
8433 notify_dependents_of_resolved_value (var
, elcd
->vars
);
8439 /* While expanding variables, we may encounter recursion cycles
8440 because of mutual (possibly indirect) dependencies between two
8441 particular variables (or values), say A and B. If we're trying to
8442 expand A when we get to B, which in turn attempts to expand A, if
8443 we can't find any other expansion for B, we'll add B to this
8444 pending-recursion stack, and tentatively return NULL for its
8445 location. This tentative value will be used for any other
8446 occurrences of B, unless A gets some other location, in which case
8447 it will notify B that it is worth another try at computing a
8448 location for it, and it will use the location computed for A then.
8449 At the end of the expansion, the tentative NULL locations become
8450 final for all members of PENDING that didn't get a notification.
8451 This function performs this finalization of NULL locations. */
8454 resolve_expansions_pending_recursion (vec
<rtx
, va_heap
> *pending
)
8456 while (!pending
->is_empty ())
8458 rtx x
= pending
->pop ();
8461 if (!VALUE_RECURSED_INTO (x
))
8464 gcc_checking_assert (NO_LOC_P (x
));
8465 VALUE_RECURSED_INTO (x
) = false;
8466 dv
= dv_from_rtx (x
);
8467 gcc_checking_assert (dv_changed_p (dv
));
8468 set_dv_changed (dv
, false);
8472 /* Initialize expand_loc_callback_data D with variable hash table V.
8473 It must be a macro because of alloca (vec stack). */
8474 #define INIT_ELCD(d, v) \
8478 (d).depth.complexity = (d).depth.entryvals = 0; \
8481 /* Finalize expand_loc_callback_data D, resolved to location L. */
8482 #define FINI_ELCD(d, l) \
8485 resolve_expansions_pending_recursion (&(d).pending); \
8486 (d).pending.release (); \
8487 (d).expanding.release (); \
8489 if ((l) && MEM_P (l)) \
8490 (l) = targetm.delegitimize_address (l); \
8494 /* Expand VALUEs and DEBUG_EXPRs in LOC to a location, using the
8495 equivalences in VARS, updating their CUR_LOCs in the process. */
8498 vt_expand_loc (rtx loc
, variable_table_type vars
)
8500 struct expand_loc_callback_data data
;
8503 if (!MAY_HAVE_DEBUG_INSNS
)
8506 INIT_ELCD (data
, vars
);
8508 result
= cselib_expand_value_rtx_cb (loc
, scratch_regs
, EXPR_DEPTH
,
8509 vt_expand_loc_callback
, &data
);
8511 FINI_ELCD (data
, result
);
8516 /* Expand the one-part VARiable to a location, using the equivalences
8517 in VARS, updating their CUR_LOCs in the process. */
8520 vt_expand_1pvar (variable var
, variable_table_type vars
)
8522 struct expand_loc_callback_data data
;
8525 gcc_checking_assert (var
->onepart
&& var
->n_var_parts
== 1);
8527 if (!dv_changed_p (var
->dv
))
8528 return var
->var_part
[0].cur_loc
;
8530 INIT_ELCD (data
, vars
);
8532 loc
= vt_expand_var_loc_chain (var
, scratch_regs
, &data
, NULL
);
8534 gcc_checking_assert (data
.expanding
.is_empty ());
8536 FINI_ELCD (data
, loc
);
8541 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
8542 additional parameters: WHERE specifies whether the note shall be emitted
8543 before or after instruction INSN. */
8546 emit_note_insn_var_location (variable_def
**varp
, emit_note_data
*data
)
8548 variable var
= *varp
;
8549 rtx insn
= data
->insn
;
8550 enum emit_note_where where
= data
->where
;
8551 variable_table_type vars
= data
->vars
;
8553 int i
, j
, n_var_parts
;
8555 enum var_init_status initialized
= VAR_INIT_STATUS_UNINITIALIZED
;
8556 HOST_WIDE_INT last_limit
;
8557 tree type_size_unit
;
8558 HOST_WIDE_INT offsets
[MAX_VAR_PARTS
];
8559 rtx loc
[MAX_VAR_PARTS
];
8563 gcc_checking_assert (var
->onepart
== NOT_ONEPART
8564 || var
->onepart
== ONEPART_VDECL
);
8566 decl
= dv_as_decl (var
->dv
);
8572 for (i
= 0; i
< var
->n_var_parts
; i
++)
8573 if (var
->var_part
[i
].cur_loc
== NULL
&& var
->var_part
[i
].loc_chain
)
8574 var
->var_part
[i
].cur_loc
= var
->var_part
[i
].loc_chain
->loc
;
8575 for (i
= 0; i
< var
->n_var_parts
; i
++)
8577 enum machine_mode mode
, wider_mode
;
8579 HOST_WIDE_INT offset
;
8581 if (i
== 0 && var
->onepart
)
8583 gcc_checking_assert (var
->n_var_parts
== 1);
8585 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8586 loc2
= vt_expand_1pvar (var
, vars
);
8590 if (last_limit
< VAR_PART_OFFSET (var
, i
))
8595 else if (last_limit
> VAR_PART_OFFSET (var
, i
))
8597 offset
= VAR_PART_OFFSET (var
, i
);
8598 loc2
= var
->var_part
[i
].cur_loc
;
8599 if (loc2
&& GET_CODE (loc2
) == MEM
8600 && GET_CODE (XEXP (loc2
, 0)) == VALUE
)
8602 rtx depval
= XEXP (loc2
, 0);
8604 loc2
= vt_expand_loc (loc2
, vars
);
8607 loc_exp_insert_dep (var
, depval
, vars
);
8614 gcc_checking_assert (GET_CODE (loc2
) != VALUE
);
8615 for (lc
= var
->var_part
[i
].loc_chain
; lc
; lc
= lc
->next
)
8616 if (var
->var_part
[i
].cur_loc
== lc
->loc
)
8618 initialized
= lc
->init
;
8624 offsets
[n_var_parts
] = offset
;
8630 loc
[n_var_parts
] = loc2
;
8631 mode
= GET_MODE (var
->var_part
[i
].cur_loc
);
8632 if (mode
== VOIDmode
&& var
->onepart
)
8633 mode
= DECL_MODE (decl
);
8634 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8636 /* Attempt to merge adjacent registers or memory. */
8637 wider_mode
= GET_MODE_WIDER_MODE (mode
);
8638 for (j
= i
+ 1; j
< var
->n_var_parts
; j
++)
8639 if (last_limit
<= VAR_PART_OFFSET (var
, j
))
8641 if (j
< var
->n_var_parts
8642 && wider_mode
!= VOIDmode
8643 && var
->var_part
[j
].cur_loc
8644 && mode
== GET_MODE (var
->var_part
[j
].cur_loc
)
8645 && (REG_P (loc
[n_var_parts
]) || MEM_P (loc
[n_var_parts
]))
8646 && last_limit
== (var
->onepart
? 0 : VAR_PART_OFFSET (var
, j
))
8647 && (loc2
= vt_expand_loc (var
->var_part
[j
].cur_loc
, vars
))
8648 && GET_CODE (loc
[n_var_parts
]) == GET_CODE (loc2
))
8652 if (REG_P (loc
[n_var_parts
])
8653 && hard_regno_nregs
[REGNO (loc
[n_var_parts
])][mode
] * 2
8654 == hard_regno_nregs
[REGNO (loc
[n_var_parts
])][wider_mode
]
8655 && end_hard_regno (mode
, REGNO (loc
[n_var_parts
]))
8658 if (! WORDS_BIG_ENDIAN
&& ! BYTES_BIG_ENDIAN
)
8659 new_loc
= simplify_subreg (wider_mode
, loc
[n_var_parts
],
8661 else if (WORDS_BIG_ENDIAN
&& BYTES_BIG_ENDIAN
)
8662 new_loc
= simplify_subreg (wider_mode
, loc2
, mode
, 0);
8665 if (!REG_P (new_loc
)
8666 || REGNO (new_loc
) != REGNO (loc
[n_var_parts
]))
8669 REG_ATTRS (new_loc
) = REG_ATTRS (loc
[n_var_parts
]);
8672 else if (MEM_P (loc
[n_var_parts
])
8673 && GET_CODE (XEXP (loc2
, 0)) == PLUS
8674 && REG_P (XEXP (XEXP (loc2
, 0), 0))
8675 && CONST_INT_P (XEXP (XEXP (loc2
, 0), 1)))
8677 if ((REG_P (XEXP (loc
[n_var_parts
], 0))
8678 && rtx_equal_p (XEXP (loc
[n_var_parts
], 0),
8679 XEXP (XEXP (loc2
, 0), 0))
8680 && INTVAL (XEXP (XEXP (loc2
, 0), 1))
8681 == GET_MODE_SIZE (mode
))
8682 || (GET_CODE (XEXP (loc
[n_var_parts
], 0)) == PLUS
8683 && CONST_INT_P (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8684 && rtx_equal_p (XEXP (XEXP (loc
[n_var_parts
], 0), 0),
8685 XEXP (XEXP (loc2
, 0), 0))
8686 && INTVAL (XEXP (XEXP (loc
[n_var_parts
], 0), 1))
8687 + GET_MODE_SIZE (mode
)
8688 == INTVAL (XEXP (XEXP (loc2
, 0), 1))))
8689 new_loc
= adjust_address_nv (loc
[n_var_parts
],
8695 loc
[n_var_parts
] = new_loc
;
8697 last_limit
= offsets
[n_var_parts
] + GET_MODE_SIZE (mode
);
8703 type_size_unit
= TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8704 if ((unsigned HOST_WIDE_INT
) last_limit
< TREE_INT_CST_LOW (type_size_unit
))
8707 if (! flag_var_tracking_uninit
)
8708 initialized
= VAR_INIT_STATUS_INITIALIZED
;
8712 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, NULL_RTX
,
8714 else if (n_var_parts
== 1)
8718 if (offsets
[0] || GET_CODE (loc
[0]) == PARALLEL
)
8719 expr_list
= gen_rtx_EXPR_LIST (VOIDmode
, loc
[0], GEN_INT (offsets
[0]));
8723 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
, expr_list
,
8726 else if (n_var_parts
)
8730 for (i
= 0; i
< n_var_parts
; i
++)
8732 = gen_rtx_EXPR_LIST (VOIDmode
, loc
[i
], GEN_INT (offsets
[i
]));
8734 parallel
= gen_rtx_PARALLEL (VOIDmode
,
8735 gen_rtvec_v (n_var_parts
, loc
));
8736 note_vl
= gen_rtx_VAR_LOCATION (VOIDmode
, decl
,
8737 parallel
, (int) initialized
);
8740 if (where
!= EMIT_NOTE_BEFORE_INSN
)
8742 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8743 if (where
== EMIT_NOTE_AFTER_CALL_INSN
)
8744 NOTE_DURING_CALL_P (note
) = true;
8748 /* Make sure that the call related notes come first. */
8749 while (NEXT_INSN (insn
)
8751 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8752 && NOTE_DURING_CALL_P (insn
))
8753 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8754 insn
= NEXT_INSN (insn
);
8756 && ((NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
8757 && NOTE_DURING_CALL_P (insn
))
8758 || NOTE_KIND (insn
) == NOTE_INSN_CALL_ARG_LOCATION
))
8759 note
= emit_note_after (NOTE_INSN_VAR_LOCATION
, insn
);
8761 note
= emit_note_before (NOTE_INSN_VAR_LOCATION
, insn
);
8763 NOTE_VAR_LOCATION (note
) = note_vl
;
8765 set_dv_changed (var
->dv
, false);
8766 gcc_assert (var
->in_changed_variables
);
8767 var
->in_changed_variables
= false;
8768 changed_variables
.clear_slot (varp
);
8770 /* Continue traversing the hash table. */
8774 /* While traversing changed_variables, push onto DATA (a stack of RTX
8775 values) entries that aren't user variables. */
8778 var_track_values_to_stack (variable_def
**slot
,
8779 vec
<rtx
, va_heap
> *changed_values_stack
)
8781 variable var
= *slot
;
8783 if (var
->onepart
== ONEPART_VALUE
)
8784 changed_values_stack
->safe_push (dv_as_value (var
->dv
));
8785 else if (var
->onepart
== ONEPART_DEXPR
)
8786 changed_values_stack
->safe_push (DECL_RTL_KNOWN_SET (dv_as_decl (var
->dv
)));
8791 /* Remove from changed_variables the entry whose DV corresponds to
8792 value or debug_expr VAL. */
8794 remove_value_from_changed_variables (rtx val
)
8796 decl_or_value dv
= dv_from_rtx (val
);
8797 variable_def
**slot
;
8800 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8803 var
->in_changed_variables
= false;
8804 changed_variables
.clear_slot (slot
);
8807 /* If VAL (a value or debug_expr) has backlinks to variables actively
8808 dependent on it in HTAB or in CHANGED_VARIABLES, mark them as
8809 changed, adding to CHANGED_VALUES_STACK any dependencies that may
8810 have dependencies of their own to notify. */
8813 notify_dependents_of_changed_value (rtx val
, variable_table_type htab
,
8814 vec
<rtx
, va_heap
> *changed_values_stack
)
8816 variable_def
**slot
;
8819 decl_or_value dv
= dv_from_rtx (val
);
8821 slot
= changed_variables
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8824 slot
= htab
.find_slot_with_hash (dv
, dv_htab_hash (dv
), NO_INSERT
);
8826 slot
= dropped_values
.find_slot_with_hash (dv
, dv_htab_hash (dv
),
8830 while ((led
= VAR_LOC_DEP_LST (var
)))
8832 decl_or_value ldv
= led
->dv
;
8835 /* Deactivate and remove the backlink, as it was “used up”. It
8836 makes no sense to attempt to notify the same entity again:
8837 either it will be recomputed and re-register an active
8838 dependency, or it will still have the changed mark. */
8840 led
->next
->pprev
= led
->pprev
;
8842 *led
->pprev
= led
->next
;
8846 if (dv_changed_p (ldv
))
8849 switch (dv_onepart_p (ldv
))
8853 set_dv_changed (ldv
, true);
8854 changed_values_stack
->safe_push (dv_as_rtx (ldv
));
8858 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8859 gcc_checking_assert (!VAR_LOC_DEP_LST (ivar
));
8860 variable_was_changed (ivar
, NULL
);
8864 pool_free (loc_exp_dep_pool
, led
);
8865 ivar
= htab
.find_with_hash (ldv
, dv_htab_hash (ldv
));
8868 int i
= ivar
->n_var_parts
;
8871 rtx loc
= ivar
->var_part
[i
].cur_loc
;
8873 if (loc
&& GET_CODE (loc
) == MEM
8874 && XEXP (loc
, 0) == val
)
8876 variable_was_changed (ivar
, NULL
);
8889 /* Take out of changed_variables any entries that don't refer to use
8890 variables. Back-propagate change notifications from values and
8891 debug_exprs to their active dependencies in HTAB or in
8892 CHANGED_VARIABLES. */
8895 process_changed_values (variable_table_type htab
)
8899 auto_vec
<rtx
, 20> changed_values_stack
;
8901 /* Move values from changed_variables to changed_values_stack. */
8903 .traverse
<vec
<rtx
, va_heap
>*, var_track_values_to_stack
>
8904 (&changed_values_stack
);
8906 /* Back-propagate change notifications in values while popping
8907 them from the stack. */
8908 for (n
= i
= changed_values_stack
.length ();
8909 i
> 0; i
= changed_values_stack
.length ())
8911 val
= changed_values_stack
.pop ();
8912 notify_dependents_of_changed_value (val
, htab
, &changed_values_stack
);
8914 /* This condition will hold when visiting each of the entries
8915 originally in changed_variables. We can't remove them
8916 earlier because this could drop the backlinks before we got a
8917 chance to use them. */
8920 remove_value_from_changed_variables (val
);
8926 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
8927 CHANGED_VARIABLES and delete this chain. WHERE specifies whether
8928 the notes shall be emitted before of after instruction INSN. */
8931 emit_notes_for_changes (rtx insn
, enum emit_note_where where
,
8934 emit_note_data data
;
8935 variable_table_type htab
= shared_hash_htab (vars
);
8937 if (!changed_variables
.elements ())
8940 if (MAY_HAVE_DEBUG_INSNS
)
8941 process_changed_values (htab
);
8948 .traverse
<emit_note_data
*, emit_note_insn_var_location
> (&data
);
8951 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
8952 same variable in hash table DATA or is not there at all. */
8955 emit_notes_for_differences_1 (variable_def
**slot
, variable_table_type new_vars
)
8957 variable old_var
, new_var
;
8960 new_var
= new_vars
.find_with_hash (old_var
->dv
, dv_htab_hash (old_var
->dv
));
8964 /* Variable has disappeared. */
8965 variable empty_var
= NULL
;
8967 if (old_var
->onepart
== ONEPART_VALUE
8968 || old_var
->onepart
== ONEPART_DEXPR
)
8970 empty_var
= variable_from_dropped (old_var
->dv
, NO_INSERT
);
8973 gcc_checking_assert (!empty_var
->in_changed_variables
);
8974 if (!VAR_LOC_1PAUX (old_var
))
8976 VAR_LOC_1PAUX (old_var
) = VAR_LOC_1PAUX (empty_var
);
8977 VAR_LOC_1PAUX (empty_var
) = NULL
;
8980 gcc_checking_assert (!VAR_LOC_1PAUX (empty_var
));
8986 empty_var
= (variable
) pool_alloc (onepart_pool (old_var
->onepart
));
8987 empty_var
->dv
= old_var
->dv
;
8988 empty_var
->refcount
= 0;
8989 empty_var
->n_var_parts
= 0;
8990 empty_var
->onepart
= old_var
->onepart
;
8991 empty_var
->in_changed_variables
= false;
8994 if (empty_var
->onepart
)
8996 /* Propagate the auxiliary data to (ultimately)
8997 changed_variables. */
8998 empty_var
->var_part
[0].loc_chain
= NULL
;
8999 empty_var
->var_part
[0].cur_loc
= NULL
;
9000 VAR_LOC_1PAUX (empty_var
) = VAR_LOC_1PAUX (old_var
);
9001 VAR_LOC_1PAUX (old_var
) = NULL
;
9003 variable_was_changed (empty_var
, NULL
);
9004 /* Continue traversing the hash table. */
9007 /* Update cur_loc and one-part auxiliary data, before new_var goes
9008 through variable_was_changed. */
9009 if (old_var
!= new_var
&& new_var
->onepart
)
9011 gcc_checking_assert (VAR_LOC_1PAUX (new_var
) == NULL
);
9012 VAR_LOC_1PAUX (new_var
) = VAR_LOC_1PAUX (old_var
);
9013 VAR_LOC_1PAUX (old_var
) = NULL
;
9014 new_var
->var_part
[0].cur_loc
= old_var
->var_part
[0].cur_loc
;
9016 if (variable_different_p (old_var
, new_var
))
9017 variable_was_changed (new_var
, NULL
);
9019 /* Continue traversing the hash table. */
9023 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
9027 emit_notes_for_differences_2 (variable_def
**slot
, variable_table_type old_vars
)
9029 variable old_var
, new_var
;
9032 old_var
= old_vars
.find_with_hash (new_var
->dv
, dv_htab_hash (new_var
->dv
));
9036 for (i
= 0; i
< new_var
->n_var_parts
; i
++)
9037 new_var
->var_part
[i
].cur_loc
= NULL
;
9038 variable_was_changed (new_var
, NULL
);
9041 /* Continue traversing the hash table. */
9045 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
9049 emit_notes_for_differences (rtx insn
, dataflow_set
*old_set
,
9050 dataflow_set
*new_set
)
9052 shared_hash_htab (old_set
->vars
)
9053 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9054 (shared_hash_htab (new_set
->vars
));
9055 shared_hash_htab (new_set
->vars
)
9056 .traverse
<variable_table_type
, emit_notes_for_differences_2
>
9057 (shared_hash_htab (old_set
->vars
));
9058 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, new_set
->vars
);
9061 /* Return the next insn after INSN that is not a NOTE_INSN_VAR_LOCATION. */
9064 next_non_note_insn_var_location (rtx insn
)
9068 insn
= NEXT_INSN (insn
);
9071 || NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
)
9078 /* Emit the notes for changes of location parts in the basic block BB. */
9081 emit_notes_in_bb (basic_block bb
, dataflow_set
*set
)
9084 micro_operation
*mo
;
9086 dataflow_set_clear (set
);
9087 dataflow_set_copy (set
, &VTI (bb
)->in
);
9089 FOR_EACH_VEC_ELT (VTI (bb
)->mos
, i
, mo
)
9091 rtx insn
= mo
->insn
;
9092 rtx next_insn
= next_non_note_insn_var_location (insn
);
9097 dataflow_set_clear_at_call (set
);
9098 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_CALL_INSN
, set
->vars
);
9100 rtx arguments
= mo
->u
.loc
, *p
= &arguments
, note
;
9103 XEXP (XEXP (*p
, 0), 1)
9104 = vt_expand_loc (XEXP (XEXP (*p
, 0), 1),
9105 shared_hash_htab (set
->vars
));
9106 /* If expansion is successful, keep it in the list. */
9107 if (XEXP (XEXP (*p
, 0), 1))
9109 /* Otherwise, if the following item is data_value for it,
9111 else if (XEXP (*p
, 1)
9112 && REG_P (XEXP (XEXP (*p
, 0), 0))
9113 && MEM_P (XEXP (XEXP (XEXP (*p
, 1), 0), 0))
9114 && REG_P (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0), 0),
9116 && REGNO (XEXP (XEXP (*p
, 0), 0))
9117 == REGNO (XEXP (XEXP (XEXP (XEXP (*p
, 1), 0),
9119 *p
= XEXP (XEXP (*p
, 1), 1);
9120 /* Just drop this item. */
9124 note
= emit_note_after (NOTE_INSN_CALL_ARG_LOCATION
, insn
);
9125 NOTE_VAR_LOCATION (note
) = arguments
;
9131 rtx loc
= mo
->u
.loc
;
9134 var_reg_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9136 var_mem_set (set
, loc
, VAR_INIT_STATUS_UNINITIALIZED
, NULL
);
9138 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9144 rtx loc
= mo
->u
.loc
;
9148 if (GET_CODE (loc
) == CONCAT
)
9150 val
= XEXP (loc
, 0);
9151 vloc
= XEXP (loc
, 1);
9159 var
= PAT_VAR_LOCATION_DECL (vloc
);
9161 clobber_variable_part (set
, NULL_RTX
,
9162 dv_from_decl (var
), 0, NULL_RTX
);
9165 if (VAL_NEEDS_RESOLUTION (loc
))
9166 val_resolve (set
, val
, PAT_VAR_LOCATION_LOC (vloc
), insn
);
9167 set_variable_part (set
, val
, dv_from_decl (var
), 0,
9168 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9171 else if (!VAR_LOC_UNKNOWN_P (PAT_VAR_LOCATION_LOC (vloc
)))
9172 set_variable_part (set
, PAT_VAR_LOCATION_LOC (vloc
),
9173 dv_from_decl (var
), 0,
9174 VAR_INIT_STATUS_INITIALIZED
, NULL_RTX
,
9177 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9183 rtx loc
= mo
->u
.loc
;
9184 rtx val
, vloc
, uloc
;
9186 vloc
= uloc
= XEXP (loc
, 1);
9187 val
= XEXP (loc
, 0);
9189 if (GET_CODE (val
) == CONCAT
)
9191 uloc
= XEXP (val
, 1);
9192 val
= XEXP (val
, 0);
9195 if (VAL_NEEDS_RESOLUTION (loc
))
9196 val_resolve (set
, val
, vloc
, insn
);
9198 val_store (set
, val
, uloc
, insn
, false);
9200 if (VAL_HOLDS_TRACK_EXPR (loc
))
9202 if (GET_CODE (uloc
) == REG
)
9203 var_reg_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9205 else if (GET_CODE (uloc
) == MEM
)
9206 var_mem_set (set
, uloc
, VAR_INIT_STATUS_UNINITIALIZED
,
9210 emit_notes_for_changes (insn
, EMIT_NOTE_BEFORE_INSN
, set
->vars
);
9216 rtx loc
= mo
->u
.loc
;
9217 rtx val
, vloc
, uloc
;
9221 uloc
= XEXP (vloc
, 1);
9222 val
= XEXP (vloc
, 0);
9225 if (GET_CODE (uloc
) == SET
)
9227 dstv
= SET_DEST (uloc
);
9228 srcv
= SET_SRC (uloc
);
9236 if (GET_CODE (val
) == CONCAT
)
9238 dstv
= vloc
= XEXP (val
, 1);
9239 val
= XEXP (val
, 0);
9242 if (GET_CODE (vloc
) == SET
)
9244 srcv
= SET_SRC (vloc
);
9246 gcc_assert (val
!= srcv
);
9247 gcc_assert (vloc
== uloc
|| VAL_NEEDS_RESOLUTION (loc
));
9249 dstv
= vloc
= SET_DEST (vloc
);
9251 if (VAL_NEEDS_RESOLUTION (loc
))
9252 val_resolve (set
, val
, srcv
, insn
);
9254 else if (VAL_NEEDS_RESOLUTION (loc
))
9256 gcc_assert (GET_CODE (uloc
) == SET
9257 && GET_CODE (SET_SRC (uloc
)) == REG
);
9258 val_resolve (set
, val
, SET_SRC (uloc
), insn
);
9261 if (VAL_HOLDS_TRACK_EXPR (loc
))
9263 if (VAL_EXPR_IS_CLOBBERED (loc
))
9266 var_reg_delete (set
, uloc
, true);
9267 else if (MEM_P (uloc
))
9269 gcc_assert (MEM_P (dstv
));
9270 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (uloc
));
9271 var_mem_delete (set
, dstv
, true);
9276 bool copied_p
= VAL_EXPR_IS_COPIED (loc
);
9277 rtx src
= NULL
, dst
= uloc
;
9278 enum var_init_status status
= VAR_INIT_STATUS_INITIALIZED
;
9280 if (GET_CODE (uloc
) == SET
)
9282 src
= SET_SRC (uloc
);
9283 dst
= SET_DEST (uloc
);
9288 status
= find_src_status (set
, src
);
9290 src
= find_src_set_src (set
, src
);
9294 var_reg_delete_and_set (set
, dst
, !copied_p
,
9296 else if (MEM_P (dst
))
9298 gcc_assert (MEM_P (dstv
));
9299 gcc_assert (MEM_ATTRS (dstv
) == MEM_ATTRS (dst
));
9300 var_mem_delete_and_set (set
, dstv
, !copied_p
,
9305 else if (REG_P (uloc
))
9306 var_regno_delete (set
, REGNO (uloc
));
9307 else if (MEM_P (uloc
))
9309 gcc_checking_assert (GET_CODE (vloc
) == MEM
);
9310 gcc_checking_assert (vloc
== dstv
);
9312 clobber_overlapping_mems (set
, vloc
);
9315 val_store (set
, val
, dstv
, insn
, true);
9317 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9324 rtx loc
= mo
->u
.loc
;
9327 if (GET_CODE (loc
) == SET
)
9329 set_src
= SET_SRC (loc
);
9330 loc
= SET_DEST (loc
);
9334 var_reg_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9337 var_mem_delete_and_set (set
, loc
, true, VAR_INIT_STATUS_INITIALIZED
,
9340 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9347 rtx loc
= mo
->u
.loc
;
9348 enum var_init_status src_status
;
9351 if (GET_CODE (loc
) == SET
)
9353 set_src
= SET_SRC (loc
);
9354 loc
= SET_DEST (loc
);
9357 src_status
= find_src_status (set
, set_src
);
9358 set_src
= find_src_set_src (set
, set_src
);
9361 var_reg_delete_and_set (set
, loc
, false, src_status
, set_src
);
9363 var_mem_delete_and_set (set
, loc
, false, src_status
, set_src
);
9365 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9372 rtx loc
= mo
->u
.loc
;
9375 var_reg_delete (set
, loc
, false);
9377 var_mem_delete (set
, loc
, false);
9379 emit_notes_for_changes (insn
, EMIT_NOTE_AFTER_INSN
, set
->vars
);
9385 rtx loc
= mo
->u
.loc
;
9388 var_reg_delete (set
, loc
, true);
9390 var_mem_delete (set
, loc
, true);
9392 emit_notes_for_changes (next_insn
, EMIT_NOTE_BEFORE_INSN
,
9398 set
->stack_adjust
+= mo
->u
.adjust
;
9404 /* Emit notes for the whole function. */
9407 vt_emit_notes (void)
9412 gcc_assert (!changed_variables
.elements ());
9414 /* Free memory occupied by the out hash tables, as they aren't used
9416 FOR_EACH_BB_FN (bb
, cfun
)
9417 dataflow_set_clear (&VTI (bb
)->out
);
9419 /* Enable emitting notes by functions (mainly by set_variable_part and
9420 delete_variable_part). */
9423 if (MAY_HAVE_DEBUG_INSNS
)
9425 dropped_values
.create (cselib_get_next_uid () * 2);
9426 loc_exp_dep_pool
= create_alloc_pool ("loc_exp_dep pool",
9427 sizeof (loc_exp_dep
), 64);
9430 dataflow_set_init (&cur
);
9432 FOR_EACH_BB_FN (bb
, cfun
)
9434 /* Emit the notes for changes of variable locations between two
9435 subsequent basic blocks. */
9436 emit_notes_for_differences (BB_HEAD (bb
), &cur
, &VTI (bb
)->in
);
9438 if (MAY_HAVE_DEBUG_INSNS
)
9439 local_get_addr_cache
= pointer_map_create ();
9441 /* Emit the notes for the changes in the basic block itself. */
9442 emit_notes_in_bb (bb
, &cur
);
9444 if (MAY_HAVE_DEBUG_INSNS
)
9445 pointer_map_destroy (local_get_addr_cache
);
9446 local_get_addr_cache
= NULL
;
9448 /* Free memory occupied by the in hash table, we won't need it
9450 dataflow_set_clear (&VTI (bb
)->in
);
9452 #ifdef ENABLE_CHECKING
9453 shared_hash_htab (cur
.vars
)
9454 .traverse
<variable_table_type
, emit_notes_for_differences_1
>
9455 (shared_hash_htab (empty_shared_hash
));
9457 dataflow_set_destroy (&cur
);
9459 if (MAY_HAVE_DEBUG_INSNS
)
9460 dropped_values
.dispose ();
9465 /* If there is a declaration and offset associated with register/memory RTL
9466 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
9469 vt_get_decl_and_offset (rtx rtl
, tree
*declp
, HOST_WIDE_INT
*offsetp
)
9473 if (REG_ATTRS (rtl
))
9475 *declp
= REG_EXPR (rtl
);
9476 *offsetp
= REG_OFFSET (rtl
);
9480 else if (GET_CODE (rtl
) == PARALLEL
)
9482 tree decl
= NULL_TREE
;
9483 HOST_WIDE_INT offset
= MAX_VAR_PARTS
;
9484 int len
= XVECLEN (rtl
, 0), i
;
9486 for (i
= 0; i
< len
; i
++)
9488 rtx reg
= XEXP (XVECEXP (rtl
, 0, i
), 0);
9489 if (!REG_P (reg
) || !REG_ATTRS (reg
))
9492 decl
= REG_EXPR (reg
);
9493 if (REG_EXPR (reg
) != decl
)
9495 if (REG_OFFSET (reg
) < offset
)
9496 offset
= REG_OFFSET (reg
);
9506 else if (MEM_P (rtl
))
9508 if (MEM_ATTRS (rtl
))
9510 *declp
= MEM_EXPR (rtl
);
9511 *offsetp
= INT_MEM_OFFSET (rtl
);
9518 /* Record the value for the ENTRY_VALUE of RTL as a global equivalence
9522 record_entry_value (cselib_val
*val
, rtx rtl
)
9524 rtx ev
= gen_rtx_ENTRY_VALUE (GET_MODE (rtl
));
9526 ENTRY_VALUE_EXP (ev
) = rtl
;
9528 cselib_add_permanent_equiv (val
, ev
, get_insns ());
9531 /* Insert function parameter PARM in IN and OUT sets of ENTRY_BLOCK. */
9534 vt_add_function_parameter (tree parm
)
9536 rtx decl_rtl
= DECL_RTL_IF_SET (parm
);
9537 rtx incoming
= DECL_INCOMING_RTL (parm
);
9539 enum machine_mode mode
;
9540 HOST_WIDE_INT offset
;
9544 if (TREE_CODE (parm
) != PARM_DECL
)
9547 if (!decl_rtl
|| !incoming
)
9550 if (GET_MODE (decl_rtl
) == BLKmode
|| GET_MODE (incoming
) == BLKmode
)
9553 /* If there is a DRAP register or a pseudo in internal_arg_pointer,
9554 rewrite the incoming location of parameters passed on the stack
9555 into MEMs based on the argument pointer, so that incoming doesn't
9556 depend on a pseudo. */
9557 if (MEM_P (incoming
)
9558 && (XEXP (incoming
, 0) == crtl
->args
.internal_arg_pointer
9559 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
9560 && XEXP (XEXP (incoming
, 0), 0)
9561 == crtl
->args
.internal_arg_pointer
9562 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
9564 HOST_WIDE_INT off
= -FIRST_PARM_OFFSET (current_function_decl
);
9565 if (GET_CODE (XEXP (incoming
, 0)) == PLUS
)
9566 off
+= INTVAL (XEXP (XEXP (incoming
, 0), 1));
9568 = replace_equiv_address_nv (incoming
,
9569 plus_constant (Pmode
,
9570 arg_pointer_rtx
, off
));
9573 #ifdef HAVE_window_save
9574 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
9575 If the target machine has an explicit window save instruction, the
9576 actual entry value is the corresponding OUTGOING_REGNO instead. */
9577 if (HAVE_window_save
&& !crtl
->uses_only_leaf_regs
)
9579 if (REG_P (incoming
)
9580 && HARD_REGISTER_P (incoming
)
9581 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
9584 p
.incoming
= incoming
;
9586 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
9587 OUTGOING_REGNO (REGNO (incoming
)), 0);
9588 p
.outgoing
= incoming
;
9589 vec_safe_push (windowed_parm_regs
, p
);
9591 else if (GET_CODE (incoming
) == PARALLEL
)
9594 = gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (XVECLEN (incoming
, 0)));
9597 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9599 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9602 reg
= gen_rtx_REG_offset (reg
, GET_MODE (reg
),
9603 OUTGOING_REGNO (REGNO (reg
)), 0);
9605 XVECEXP (outgoing
, 0, i
)
9606 = gen_rtx_EXPR_LIST (VOIDmode
, reg
,
9607 XEXP (XVECEXP (incoming
, 0, i
), 1));
9608 vec_safe_push (windowed_parm_regs
, p
);
9611 incoming
= outgoing
;
9613 else if (MEM_P (incoming
)
9614 && REG_P (XEXP (incoming
, 0))
9615 && HARD_REGISTER_P (XEXP (incoming
, 0)))
9617 rtx reg
= XEXP (incoming
, 0);
9618 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
9622 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
9624 vec_safe_push (windowed_parm_regs
, p
);
9625 incoming
= replace_equiv_address_nv (incoming
, reg
);
9631 if (!vt_get_decl_and_offset (incoming
, &decl
, &offset
))
9633 if (MEM_P (incoming
))
9635 /* This means argument is passed by invisible reference. */
9641 if (!vt_get_decl_and_offset (decl_rtl
, &decl
, &offset
))
9643 offset
+= byte_lowpart_offset (GET_MODE (incoming
),
9644 GET_MODE (decl_rtl
));
9653 /* If that DECL_RTL wasn't a pseudo that got spilled to
9654 memory, bail out. Otherwise, the spill slot sharing code
9655 will force the memory to reference spill_slot_decl (%sfp),
9656 so we don't match above. That's ok, the pseudo must have
9657 referenced the entire parameter, so just reset OFFSET. */
9658 if (decl
!= get_spill_slot_decl (false))
9663 if (!track_loc_p (incoming
, parm
, offset
, false, &mode
, &offset
))
9666 out
= &VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->out
;
9668 dv
= dv_from_decl (parm
);
9670 if (target_for_debug_bind (parm
)
9671 /* We can't deal with these right now, because this kind of
9672 variable is single-part. ??? We could handle parallels
9673 that describe multiple locations for the same single
9674 value, but ATM we don't. */
9675 && GET_CODE (incoming
) != PARALLEL
)
9680 /* ??? We shouldn't ever hit this, but it may happen because
9681 arguments passed by invisible reference aren't dealt with
9682 above: incoming-rtl will have Pmode rather than the
9683 expected mode for the type. */
9687 lowpart
= var_lowpart (mode
, incoming
);
9691 val
= cselib_lookup_from_insn (lowpart
, mode
, true,
9692 VOIDmode
, get_insns ());
9694 /* ??? Float-typed values in memory are not handled by
9698 preserve_value (val
);
9699 set_variable_part (out
, val
->val_rtx
, dv
, offset
,
9700 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9701 dv
= dv_from_value (val
->val_rtx
);
9704 if (MEM_P (incoming
))
9706 val
= cselib_lookup_from_insn (XEXP (incoming
, 0), mode
, true,
9707 VOIDmode
, get_insns ());
9710 preserve_value (val
);
9711 incoming
= replace_equiv_address_nv (incoming
, val
->val_rtx
);
9716 if (REG_P (incoming
))
9718 incoming
= var_lowpart (mode
, incoming
);
9719 gcc_assert (REGNO (incoming
) < FIRST_PSEUDO_REGISTER
);
9720 attrs_list_insert (&out
->regs
[REGNO (incoming
)], dv
, offset
,
9722 set_variable_part (out
, incoming
, dv
, offset
,
9723 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9724 if (dv_is_value_p (dv
))
9726 record_entry_value (CSELIB_VAL_PTR (dv_as_value (dv
)), incoming
);
9727 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
9728 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm
))))
9730 enum machine_mode indmode
9731 = TYPE_MODE (TREE_TYPE (TREE_TYPE (parm
)));
9732 rtx mem
= gen_rtx_MEM (indmode
, incoming
);
9733 cselib_val
*val
= cselib_lookup_from_insn (mem
, indmode
, true,
9738 preserve_value (val
);
9739 record_entry_value (val
, mem
);
9740 set_variable_part (out
, mem
, dv_from_value (val
->val_rtx
), 0,
9741 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9746 else if (GET_CODE (incoming
) == PARALLEL
&& !dv_onepart_p (dv
))
9750 for (i
= 0; i
< XVECLEN (incoming
, 0); i
++)
9752 rtx reg
= XEXP (XVECEXP (incoming
, 0, i
), 0);
9753 offset
= REG_OFFSET (reg
);
9754 gcc_assert (REGNO (reg
) < FIRST_PSEUDO_REGISTER
);
9755 attrs_list_insert (&out
->regs
[REGNO (reg
)], dv
, offset
, reg
);
9756 set_variable_part (out
, reg
, dv
, offset
,
9757 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9760 else if (MEM_P (incoming
))
9762 incoming
= var_lowpart (mode
, incoming
);
9763 set_variable_part (out
, incoming
, dv
, offset
,
9764 VAR_INIT_STATUS_INITIALIZED
, NULL
, INSERT
);
9768 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
9771 vt_add_function_parameters (void)
9775 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9776 parm
; parm
= DECL_CHAIN (parm
))
9777 vt_add_function_parameter (parm
);
9779 if (DECL_HAS_VALUE_EXPR_P (DECL_RESULT (current_function_decl
)))
9781 tree vexpr
= DECL_VALUE_EXPR (DECL_RESULT (current_function_decl
));
9783 if (TREE_CODE (vexpr
) == INDIRECT_REF
)
9784 vexpr
= TREE_OPERAND (vexpr
, 0);
9786 if (TREE_CODE (vexpr
) == PARM_DECL
9787 && DECL_ARTIFICIAL (vexpr
)
9788 && !DECL_IGNORED_P (vexpr
)
9789 && DECL_NAMELESS (vexpr
))
9790 vt_add_function_parameter (vexpr
);
9794 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
9795 ensure it isn't flushed during cselib_reset_table.
9796 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
9797 has been eliminated. */
9800 vt_init_cfa_base (void)
9804 #ifdef FRAME_POINTER_CFA_OFFSET
9805 cfa_base_rtx
= frame_pointer_rtx
;
9806 cfa_base_offset
= -FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9808 cfa_base_rtx
= arg_pointer_rtx
;
9809 cfa_base_offset
= -ARG_POINTER_CFA_OFFSET (current_function_decl
);
9811 if (cfa_base_rtx
== hard_frame_pointer_rtx
9812 || !fixed_regs
[REGNO (cfa_base_rtx
)])
9814 cfa_base_rtx
= NULL_RTX
;
9817 if (!MAY_HAVE_DEBUG_INSNS
)
9820 /* Tell alias analysis that cfa_base_rtx should share
9821 find_base_term value with stack pointer or hard frame pointer. */
9822 if (!frame_pointer_needed
)
9823 vt_equate_reg_base_value (cfa_base_rtx
, stack_pointer_rtx
);
9824 else if (!crtl
->stack_realign_tried
)
9825 vt_equate_reg_base_value (cfa_base_rtx
, hard_frame_pointer_rtx
);
9827 val
= cselib_lookup_from_insn (cfa_base_rtx
, GET_MODE (cfa_base_rtx
), 1,
9828 VOIDmode
, get_insns ());
9829 preserve_value (val
);
9830 cselib_preserve_cfa_base_value (val
, REGNO (cfa_base_rtx
));
9833 /* Allocate and initialize the data structures for variable tracking
9834 and parse the RTL to get the micro operations. */
9837 vt_initialize (void)
9840 HOST_WIDE_INT fp_cfa_offset
= -1;
9842 alloc_aux_for_blocks (sizeof (struct variable_tracking_info_def
));
9844 attrs_pool
= create_alloc_pool ("attrs_def pool",
9845 sizeof (struct attrs_def
), 1024);
9846 var_pool
= create_alloc_pool ("variable_def pool",
9847 sizeof (struct variable_def
)
9848 + (MAX_VAR_PARTS
- 1)
9849 * sizeof (((variable
)NULL
)->var_part
[0]), 64);
9850 loc_chain_pool
= create_alloc_pool ("location_chain_def pool",
9851 sizeof (struct location_chain_def
),
9853 shared_hash_pool
= create_alloc_pool ("shared_hash_def pool",
9854 sizeof (struct shared_hash_def
), 256);
9855 empty_shared_hash
= (shared_hash
) pool_alloc (shared_hash_pool
);
9856 empty_shared_hash
->refcount
= 1;
9857 empty_shared_hash
->htab
.create (1);
9858 changed_variables
.create (10);
9860 /* Init the IN and OUT sets. */
9861 FOR_ALL_BB_FN (bb
, cfun
)
9863 VTI (bb
)->visited
= false;
9864 VTI (bb
)->flooded
= false;
9865 dataflow_set_init (&VTI (bb
)->in
);
9866 dataflow_set_init (&VTI (bb
)->out
);
9867 VTI (bb
)->permp
= NULL
;
9870 if (MAY_HAVE_DEBUG_INSNS
)
9872 cselib_init (CSELIB_RECORD_MEMORY
| CSELIB_PRESERVE_CONSTANTS
);
9873 scratch_regs
= BITMAP_ALLOC (NULL
);
9874 valvar_pool
= create_alloc_pool ("small variable_def pool",
9875 sizeof (struct variable_def
), 256);
9876 preserved_values
.create (256);
9877 global_get_addr_cache
= pointer_map_create ();
9881 scratch_regs
= NULL
;
9883 global_get_addr_cache
= NULL
;
9886 if (MAY_HAVE_DEBUG_INSNS
)
9892 #ifdef FRAME_POINTER_CFA_OFFSET
9893 reg
= frame_pointer_rtx
;
9894 ofst
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9896 reg
= arg_pointer_rtx
;
9897 ofst
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9900 ofst
-= INCOMING_FRAME_SP_OFFSET
;
9902 val
= cselib_lookup_from_insn (reg
, GET_MODE (reg
), 1,
9903 VOIDmode
, get_insns ());
9904 preserve_value (val
);
9905 cselib_preserve_cfa_base_value (val
, REGNO (reg
));
9906 expr
= plus_constant (GET_MODE (stack_pointer_rtx
),
9907 stack_pointer_rtx
, -ofst
);
9908 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9912 val
= cselib_lookup_from_insn (stack_pointer_rtx
,
9913 GET_MODE (stack_pointer_rtx
), 1,
9914 VOIDmode
, get_insns ());
9915 preserve_value (val
);
9916 expr
= plus_constant (GET_MODE (reg
), reg
, ofst
);
9917 cselib_add_permanent_equiv (val
, expr
, get_insns ());
9921 /* In order to factor out the adjustments made to the stack pointer or to
9922 the hard frame pointer and thus be able to use DW_OP_fbreg operations
9923 instead of individual location lists, we're going to rewrite MEMs based
9924 on them into MEMs based on the CFA by de-eliminating stack_pointer_rtx
9925 or hard_frame_pointer_rtx to the virtual CFA pointer frame_pointer_rtx
9926 resp. arg_pointer_rtx. We can do this either when there is no frame
9927 pointer in the function and stack adjustments are consistent for all
9928 basic blocks or when there is a frame pointer and no stack realignment.
9929 But we first have to check that frame_pointer_rtx resp. arg_pointer_rtx
9930 has been eliminated. */
9931 if (!frame_pointer_needed
)
9935 if (!vt_stack_adjustments ())
9938 #ifdef FRAME_POINTER_CFA_OFFSET
9939 reg
= frame_pointer_rtx
;
9941 reg
= arg_pointer_rtx
;
9943 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9946 if (GET_CODE (elim
) == PLUS
)
9947 elim
= XEXP (elim
, 0);
9948 if (elim
== stack_pointer_rtx
)
9949 vt_init_cfa_base ();
9952 else if (!crtl
->stack_realign_tried
)
9956 #ifdef FRAME_POINTER_CFA_OFFSET
9957 reg
= frame_pointer_rtx
;
9958 fp_cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
9960 reg
= arg_pointer_rtx
;
9961 fp_cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
9963 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9966 if (GET_CODE (elim
) == PLUS
)
9968 fp_cfa_offset
-= INTVAL (XEXP (elim
, 1));
9969 elim
= XEXP (elim
, 0);
9971 if (elim
!= hard_frame_pointer_rtx
)
9978 /* If the stack is realigned and a DRAP register is used, we're going to
9979 rewrite MEMs based on it representing incoming locations of parameters
9980 passed on the stack into MEMs based on the argument pointer. Although
9981 we aren't going to rewrite other MEMs, we still need to initialize the
9982 virtual CFA pointer in order to ensure that the argument pointer will
9983 be seen as a constant throughout the function.
9985 ??? This doesn't work if FRAME_POINTER_CFA_OFFSET is defined. */
9986 else if (stack_realign_drap
)
9990 #ifdef FRAME_POINTER_CFA_OFFSET
9991 reg
= frame_pointer_rtx
;
9993 reg
= arg_pointer_rtx
;
9995 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9998 if (GET_CODE (elim
) == PLUS
)
9999 elim
= XEXP (elim
, 0);
10000 if (elim
== hard_frame_pointer_rtx
)
10001 vt_init_cfa_base ();
10005 hard_frame_pointer_adjustment
= -1;
10007 vt_add_function_parameters ();
10009 FOR_EACH_BB_FN (bb
, cfun
)
10012 HOST_WIDE_INT pre
, post
= 0;
10013 basic_block first_bb
, last_bb
;
10015 if (MAY_HAVE_DEBUG_INSNS
)
10017 cselib_record_sets_hook
= add_with_sets
;
10018 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10019 fprintf (dump_file
, "first value: %i\n",
10020 cselib_get_next_uid ());
10027 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
10028 || ! single_pred_p (bb
->next_bb
))
10030 e
= find_edge (bb
, bb
->next_bb
);
10031 if (! e
|| (e
->flags
& EDGE_FALLTHRU
) == 0)
10037 /* Add the micro-operations to the vector. */
10038 FOR_BB_BETWEEN (bb
, first_bb
, last_bb
->next_bb
, next_bb
)
10040 HOST_WIDE_INT offset
= VTI (bb
)->out
.stack_adjust
;
10041 VTI (bb
)->out
.stack_adjust
= VTI (bb
)->in
.stack_adjust
;
10042 for (insn
= BB_HEAD (bb
); insn
!= NEXT_INSN (BB_END (bb
));
10043 insn
= NEXT_INSN (insn
))
10047 if (!frame_pointer_needed
)
10049 insn_stack_adjust_offset_pre_post (insn
, &pre
, &post
);
10052 micro_operation mo
;
10053 mo
.type
= MO_ADJUST
;
10056 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10057 log_op_type (PATTERN (insn
), bb
, insn
,
10058 MO_ADJUST
, dump_file
);
10059 VTI (bb
)->mos
.safe_push (mo
);
10060 VTI (bb
)->out
.stack_adjust
+= pre
;
10064 cselib_hook_called
= false;
10065 adjust_insn (bb
, insn
);
10066 if (MAY_HAVE_DEBUG_INSNS
)
10069 prepare_call_arguments (bb
, insn
);
10070 cselib_process_insn (insn
);
10071 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10073 print_rtl_single (dump_file
, insn
);
10074 dump_cselib_table (dump_file
);
10077 if (!cselib_hook_called
)
10078 add_with_sets (insn
, 0, 0);
10079 cancel_changes (0);
10081 if (!frame_pointer_needed
&& post
)
10083 micro_operation mo
;
10084 mo
.type
= MO_ADJUST
;
10085 mo
.u
.adjust
= post
;
10087 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10088 log_op_type (PATTERN (insn
), bb
, insn
,
10089 MO_ADJUST
, dump_file
);
10090 VTI (bb
)->mos
.safe_push (mo
);
10091 VTI (bb
)->out
.stack_adjust
+= post
;
10094 if (fp_cfa_offset
!= -1
10095 && hard_frame_pointer_adjustment
== -1
10096 && fp_setter_insn (insn
))
10098 vt_init_cfa_base ();
10099 hard_frame_pointer_adjustment
= fp_cfa_offset
;
10100 /* Disassociate sp from fp now. */
10101 if (MAY_HAVE_DEBUG_INSNS
)
10104 cselib_invalidate_rtx (stack_pointer_rtx
);
10105 v
= cselib_lookup (stack_pointer_rtx
, Pmode
, 1,
10107 if (v
&& !cselib_preserved_value_p (v
))
10109 cselib_set_value_sp_based (v
);
10110 preserve_value (v
);
10116 gcc_assert (offset
== VTI (bb
)->out
.stack_adjust
);
10121 if (MAY_HAVE_DEBUG_INSNS
)
10123 cselib_preserve_only_values ();
10124 cselib_reset_table (cselib_get_next_uid ());
10125 cselib_record_sets_hook
= NULL
;
10129 hard_frame_pointer_adjustment
= -1;
10130 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flooded
= true;
10131 cfa_base_rtx
= NULL_RTX
;
10135 /* This is *not* reset after each function. It gives each
10136 NOTE_INSN_DELETED_DEBUG_LABEL in the entire compilation
10137 a unique label number. */
10139 static int debug_label_num
= 1;
10141 /* Get rid of all debug insns from the insn stream. */
10144 delete_debug_insns (void)
10149 if (!MAY_HAVE_DEBUG_INSNS
)
10152 FOR_EACH_BB_FN (bb
, cfun
)
10154 FOR_BB_INSNS_SAFE (bb
, insn
, next
)
10155 if (DEBUG_INSN_P (insn
))
10157 tree decl
= INSN_VAR_LOCATION_DECL (insn
);
10158 if (TREE_CODE (decl
) == LABEL_DECL
10159 && DECL_NAME (decl
)
10160 && !DECL_RTL_SET_P (decl
))
10162 PUT_CODE (insn
, NOTE
);
10163 NOTE_KIND (insn
) = NOTE_INSN_DELETED_DEBUG_LABEL
;
10164 NOTE_DELETED_LABEL_NAME (insn
)
10165 = IDENTIFIER_POINTER (DECL_NAME (decl
));
10166 SET_DECL_RTL (decl
, insn
);
10167 CODE_LABEL_NUMBER (insn
) = debug_label_num
++;
10170 delete_insn (insn
);
10175 /* Run a fast, BB-local only version of var tracking, to take care of
10176 information that we don't do global analysis on, such that not all
10177 information is lost. If SKIPPED holds, we're skipping the global
10178 pass entirely, so we should try to use information it would have
10179 handled as well.. */
10182 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED
)
10184 /* ??? Just skip it all for now. */
10185 delete_debug_insns ();
10188 /* Free the data structures needed for variable tracking. */
10195 FOR_EACH_BB_FN (bb
, cfun
)
10197 VTI (bb
)->mos
.release ();
10200 FOR_ALL_BB_FN (bb
, cfun
)
10202 dataflow_set_destroy (&VTI (bb
)->in
);
10203 dataflow_set_destroy (&VTI (bb
)->out
);
10204 if (VTI (bb
)->permp
)
10206 dataflow_set_destroy (VTI (bb
)->permp
);
10207 XDELETE (VTI (bb
)->permp
);
10210 free_aux_for_blocks ();
10211 empty_shared_hash
->htab
.dispose ();
10212 changed_variables
.dispose ();
10213 free_alloc_pool (attrs_pool
);
10214 free_alloc_pool (var_pool
);
10215 free_alloc_pool (loc_chain_pool
);
10216 free_alloc_pool (shared_hash_pool
);
10218 if (MAY_HAVE_DEBUG_INSNS
)
10220 if (global_get_addr_cache
)
10221 pointer_map_destroy (global_get_addr_cache
);
10222 global_get_addr_cache
= NULL
;
10223 if (loc_exp_dep_pool
)
10224 free_alloc_pool (loc_exp_dep_pool
);
10225 loc_exp_dep_pool
= NULL
;
10226 free_alloc_pool (valvar_pool
);
10227 preserved_values
.release ();
10229 BITMAP_FREE (scratch_regs
);
10230 scratch_regs
= NULL
;
10233 #ifdef HAVE_window_save
10234 vec_free (windowed_parm_regs
);
10238 XDELETEVEC (vui_vec
);
10243 /* The entry point to variable tracking pass. */
10245 static inline unsigned int
10246 variable_tracking_main_1 (void)
10250 if (flag_var_tracking_assignments
< 0)
10252 delete_debug_insns ();
10256 if (n_basic_blocks_for_fn (cfun
) > 500 &&
10257 n_edges_for_fn (cfun
) / n_basic_blocks_for_fn (cfun
) >= 20)
10259 vt_debug_insns_local (true);
10263 mark_dfs_back_edges ();
10264 if (!vt_initialize ())
10267 vt_debug_insns_local (true);
10271 success
= vt_find_locations ();
10273 if (!success
&& flag_var_tracking_assignments
> 0)
10277 delete_debug_insns ();
10279 /* This is later restored by our caller. */
10280 flag_var_tracking_assignments
= 0;
10282 success
= vt_initialize ();
10283 gcc_assert (success
);
10285 success
= vt_find_locations ();
10291 vt_debug_insns_local (false);
10295 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10297 dump_dataflow_sets ();
10298 dump_reg_info (dump_file
);
10299 dump_flow_info (dump_file
, dump_flags
);
10302 timevar_push (TV_VAR_TRACKING_EMIT
);
10304 timevar_pop (TV_VAR_TRACKING_EMIT
);
10307 vt_debug_insns_local (false);
10312 variable_tracking_main (void)
10315 int save
= flag_var_tracking_assignments
;
10317 ret
= variable_tracking_main_1 ();
10319 flag_var_tracking_assignments
= save
;
10325 gate_handle_var_tracking (void)
10327 return (flag_var_tracking
&& !targetm
.delay_vartrack
);
10334 const pass_data pass_data_variable_tracking
=
10336 RTL_PASS
, /* type */
10337 "vartrack", /* name */
10338 OPTGROUP_NONE
, /* optinfo_flags */
10339 true, /* has_gate */
10340 true, /* has_execute */
10341 TV_VAR_TRACKING
, /* tv_id */
10342 0, /* properties_required */
10343 0, /* properties_provided */
10344 0, /* properties_destroyed */
10345 0, /* todo_flags_start */
10346 ( TODO_verify_rtl_sharing
| TODO_verify_flow
), /* todo_flags_finish */
10349 class pass_variable_tracking
: public rtl_opt_pass
10352 pass_variable_tracking (gcc::context
*ctxt
)
10353 : rtl_opt_pass (pass_data_variable_tracking
, ctxt
)
10356 /* opt_pass methods: */
10357 bool gate () { return gate_handle_var_tracking (); }
10358 unsigned int execute () { return variable_tracking_main (); }
10360 }; // class pass_variable_tracking
10362 } // anon namespace
10365 make_pass_variable_tracking (gcc::context
*ctxt
)
10367 return new pass_variable_tracking (ctxt
);