1 /* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file contains the variable tracking pass. It computes where
22 variables are located (which registers or where in memory) at each position
23 in instruction stream and emits notes describing the locations.
24 Debug information (DWARF2 location lists) is finally generated from
26 With this debug information, it is possible to show variables
27 even when debugging optimized code.
29 How does the variable tracking pass work?
31 First, it scans RTL code for uses, stores and clobbers (register/memory
32 references in instructions), for call insns and for stack adjustments
33 separately for each basic block and saves them to an array of micro
35 The micro operations of one instruction are ordered so that
36 pre-modifying stack adjustment < use < use with no var < call insn <
37 < set < clobber < post-modifying stack adjustment
39 Then, a forward dataflow analysis is performed to find out how locations
40 of variables change through code and to propagate the variable locations
41 along control flow graph.
42 The IN set for basic block BB is computed as a union of OUT sets of BB's
43 predecessors, the OUT set for BB is copied from the IN set for BB and
44 is changed according to micro operations in BB.
46 The IN and OUT sets for basic blocks consist of a current stack adjustment
47 (used for adjusting offset of variables addressed using stack pointer),
48 the table of structures describing the locations of parts of a variable
49 and for each physical register a linked list for each physical register.
50 The linked list is a list of variable parts stored in the register,
51 i.e. it is a list of triplets (reg, decl, offset) where decl is
52 REG_EXPR (reg) and offset is REG_OFFSET (reg). The linked list is used for
53 effective deleting appropriate variable parts when we set or clobber the
56 There may be more than one variable part in a register. The linked lists
57 should be pretty short so it is a good data structure here.
58 For example in the following code, register allocator may assign same
59 register to variables A and B, and both of them are stored in the same
72 Finally, the NOTE_INSN_VAR_LOCATION notes describing the variable locations
73 are emitted to appropriate positions in RTL code. Each such a note describes
74 the location of one variable at the point in instruction stream where the
75 note is. There is no need to emit a note for each variable before each
76 instruction, we only emit these notes where the location of variable changes
77 (this means that we also emit notes for changes between the OUT set of the
78 previous block and the IN set of the current block).
80 The notes consist of two parts:
81 1. the declaration (from REG_EXPR or MEM_EXPR)
82 2. the location of a variable - it is either a simple register/memory
83 reference (for simple variables, for example int),
84 or a parallel of register/memory references (for a large variables
85 which consist of several parts, for example long long).
91 #include "coretypes.h"
95 #include "hard-reg-set.h"
96 #include "basic-block.h"
99 #include "insn-config.h"
102 #include "alloc-pool.h"
108 #include "tree-pass.h"
109 #include "tree-flow.h"
114 #include "diagnostic.h"
115 #include "pointer-set.h"
118 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
119 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
120 Currently the value is the same as IDENTIFIER_NODE, which has such
121 a property. If this compile time assertion ever fails, make sure that
122 the new tree code that equals (int) VALUE has the same property. */
123 extern char check_value_val[(int) VALUE == (int) IDENTIFIER_NODE ? 1 : -1];
125 /* Type of micro operation. */
126 enum micro_operation_type
128 MO_USE, /* Use location (REG or MEM). */
129 MO_USE_NO_VAR,/* Use location which is not associated with a variable
130 or the variable is not trackable. */
131 MO_VAL_USE, /* Use location which is associated with a value. */
132 MO_VAL_LOC, /* Use location which appears in a debug insn. */
133 MO_VAL_SET, /* Set location associated with a value. */
134 MO_SET, /* Set location. */
135 MO_COPY, /* Copy the same portion of a variable from one
136 location to another. */
137 MO_CLOBBER, /* Clobber location. */
138 MO_CALL, /* Call insn. */
139 MO_ADJUST /* Adjust stack pointer. */
143 static const char * const ATTRIBUTE_UNUSED
144 micro_operation_type_name[] = {
157 /* Where shall the note be emitted? BEFORE or AFTER the instruction.
158 Notes emitted as AFTER_CALL are to take effect during the call,
159 rather than after the call. */
162 EMIT_NOTE_BEFORE_INSN,
163 EMIT_NOTE_AFTER_INSN,
164 EMIT_NOTE_AFTER_CALL_INSN
167 /* Structure holding information about micro operation. */
168 typedef struct micro_operation_def
170 /* Type of micro operation. */
171 enum micro_operation_type type;
173 /* The instruction which the micro operation is in, for MO_USE,
174 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
175 instruction or note in the original flow (before any var-tracking
176 notes are inserted, to simplify emission of notes), for MO_SET
181 /* Location. For MO_SET and MO_COPY, this is the SET that
182 performs the assignment, if known, otherwise it is the target
183 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
184 CONCAT of the VALUE and the LOC associated with it. For
185 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
186 associated with it. */
189 /* Stack adjustment. */
190 HOST_WIDE_INT adjust;
194 DEF_VEC_O(micro_operation);
195 DEF_VEC_ALLOC_O(micro_operation,heap);
197 /* A declaration of a variable, or an RTL value being handled like a
199 typedef void *decl_or_value;
201 /* Structure for passing some other parameters to function
202 emit_note_insn_var_location. */
203 typedef struct emit_note_data_def
205 /* The instruction which the note will be emitted before/after. */
208 /* Where the note will be emitted (before/after insn)? */
209 enum emit_note_where where;
211 /* The variables and values active at this point. */
215 /* Description of location of a part of a variable. The content of a physical
216 register is described by a chain of these structures.
217 The chains are pretty short (usually 1 or 2 elements) and thus
218 chain is the best data structure. */
219 typedef struct attrs_def
221 /* Pointer to next member of the list. */
222 struct attrs_def *next;
224 /* The rtx of register. */
227 /* The declaration corresponding to LOC. */
230 /* Offset from start of DECL. */
231 HOST_WIDE_INT offset;
234 /* Structure holding a refcounted hash table. If refcount > 1,
235 it must be first unshared before modified. */
236 typedef struct shared_hash_def
238 /* Reference count. */
241 /* Actual hash table. */
245 /* Structure holding the IN or OUT set for a basic block. */
246 typedef struct dataflow_set_def
248 /* Adjustment of stack offset. */
249 HOST_WIDE_INT stack_adjust;
251 /* Attributes for registers (lists of attrs). */
252 attrs regs[FIRST_PSEUDO_REGISTER];
254 /* Variable locations. */
257 /* Vars that is being traversed. */
258 shared_hash traversed_vars;
261 /* The structure (one for each basic block) containing the information
262 needed for variable tracking. */
263 typedef struct variable_tracking_info_def
265 /* The vector of micro operations. */
266 VEC(micro_operation, heap) *mos;
268 /* The IN and OUT set for dataflow analysis. */
272 /* The permanent-in dataflow set for this block. This is used to
273 hold values for which we had to compute entry values. ??? This
274 should probably be dynamically allocated, to avoid using more
275 memory in non-debug builds. */
278 /* Has the block been visited in DFS? */
281 /* Has the block been flooded in VTA? */
284 } *variable_tracking_info;
286 /* Structure for chaining the locations. */
287 typedef struct location_chain_def
289 /* Next element in the chain. */
290 struct location_chain_def *next;
292 /* The location (REG, MEM or VALUE). */
295 /* The "value" stored in this location. */
299 enum var_init_status init;
302 /* Structure describing one part of variable. */
303 typedef struct variable_part_def
305 /* Chain of locations of the part. */
306 location_chain loc_chain;
308 /* Location which was last emitted to location list. */
311 /* The offset in the variable. */
312 HOST_WIDE_INT offset;
315 /* Maximum number of location parts. */
316 #define MAX_VAR_PARTS 16
318 /* Structure describing where the variable is located. */
319 typedef struct variable_def
321 /* The declaration of the variable, or an RTL value being handled
322 like a declaration. */
325 /* Reference count. */
328 /* Number of variable parts. */
331 /* True if this variable changed (any of its) cur_loc fields
332 during the current emit_notes_for_changes resp.
333 emit_notes_for_differences call. */
334 bool cur_loc_changed;
336 /* True if this variable_def struct is currently in the
337 changed_variables hash table. */
338 bool in_changed_variables;
340 /* The variable parts. */
341 variable_part var_part[1];
343 typedef const struct variable_def *const_variable;
345 /* Structure for chaining backlinks from referenced VALUEs to
346 DVs that are referencing them. */
347 typedef struct value_chain_def
349 /* Next value_chain entry. */
350 struct value_chain_def *next;
352 /* The declaration of the variable, or an RTL value
353 being handled like a declaration, whose var_parts[0].loc_chain
354 references the VALUE owning this value_chain. */
357 /* Reference count. */
360 typedef const struct value_chain_def *const_value_chain;
362 /* Pointer to the BB's information specific to variable tracking pass. */
363 #define VTI(BB) ((variable_tracking_info) (BB)->aux)
365 /* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
366 #define INT_MEM_OFFSET(mem) (MEM_OFFSET (mem) ? INTVAL (MEM_OFFSET (mem)) : 0)
368 /* Alloc pool for struct attrs_def. */
369 static alloc_pool attrs_pool;
371 /* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
372 static alloc_pool var_pool;
374 /* Alloc pool for struct variable_def with a single var_part entry. */
375 static alloc_pool valvar_pool;
377 /* Alloc pool for struct location_chain_def. */
378 static alloc_pool loc_chain_pool;
380 /* Alloc pool for struct shared_hash_def. */
381 static alloc_pool shared_hash_pool;
383 /* Alloc pool for struct value_chain_def. */
384 static alloc_pool value_chain_pool;
386 /* Changed variables, notes will be emitted for them. */
387 static htab_t changed_variables;
389 /* Links from VALUEs to DVs referencing them in their current loc_chains. */
390 static htab_t value_chains;
392 /* Shall notes be emitted? */
393 static bool emit_notes;
395 /* Empty shared hashtable. */
396 static shared_hash empty_shared_hash;
398 /* Scratch register bitmap used by cselib_expand_value_rtx. */
399 static bitmap scratch_regs = NULL;
401 /* Variable used to tell whether cselib_process_insn called our hook. */
402 static bool cselib_hook_called;
404 /* Local function prototypes. */
405 static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,
407 static void insn_stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,
409 static bool vt_stack_adjustments (void);
410 static rtx compute_cfa_pointer (HOST_WIDE_INT);
411 static hashval_t variable_htab_hash (const void *);
412 static int variable_htab_eq (const void *, const void *);
413 static void variable_htab_free (void *);
415 static void init_attrs_list_set (attrs *);
416 static void attrs_list_clear (attrs *);
417 static attrs attrs_list_member (attrs, decl_or_value, HOST_WIDE_INT);
418 static void attrs_list_insert (attrs *, decl_or_value, HOST_WIDE_INT, rtx);
419 static void attrs_list_copy (attrs *, attrs);
420 static void attrs_list_union (attrs *, attrs);
422 static void **unshare_variable (dataflow_set *set, void **slot, variable var,
423 enum var_init_status);
424 static int vars_copy_1 (void **, void *);
425 static void vars_copy (htab_t, htab_t);
426 static tree var_debug_decl (tree);
427 static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx);
428 static void var_reg_delete_and_set (dataflow_set *, rtx, bool,
429 enum var_init_status, rtx);
430 static void var_reg_delete (dataflow_set *, rtx, bool);
431 static void var_regno_delete (dataflow_set *, int);
432 static void var_mem_set (dataflow_set *, rtx, enum var_init_status, rtx);
433 static void var_mem_delete_and_set (dataflow_set *, rtx, bool,
434 enum var_init_status, rtx);
435 static void var_mem_delete (dataflow_set *, rtx, bool);
437 static void dataflow_set_init (dataflow_set *);
438 static void dataflow_set_clear (dataflow_set *);
439 static void dataflow_set_copy (dataflow_set *, dataflow_set *);
440 static int variable_union_info_cmp_pos (const void *, const void *);
441 static int variable_union (void **, void *);
442 static void dataflow_set_union (dataflow_set *, dataflow_set *);
443 static location_chain find_loc_in_1pdv (rtx, variable, htab_t);
444 static bool canon_value_cmp (rtx, rtx);
445 static int loc_cmp (rtx, rtx);
446 static bool variable_part_different_p (variable_part *, variable_part *);
447 static bool onepart_variable_different_p (variable, variable);
448 static bool variable_different_p (variable, variable);
449 static int dataflow_set_different_1 (void **, void *);
450 static bool dataflow_set_different (dataflow_set *, dataflow_set *);
451 static void dataflow_set_destroy (dataflow_set *);
453 static bool contains_symbol_ref (rtx);
454 static bool track_expr_p (tree, bool);
455 static bool same_variable_part_p (rtx, tree, HOST_WIDE_INT);
456 static int add_uses (rtx *, void *);
457 static void add_uses_1 (rtx *, void *);
458 static void add_stores (rtx, const_rtx, void *);
459 static bool compute_bb_dataflow (basic_block);
460 static bool vt_find_locations (void);
462 static void dump_attrs_list (attrs);
463 static int dump_var_slot (void **, void *);
464 static void dump_var (variable);
465 static void dump_vars (htab_t);
466 static void dump_dataflow_set (dataflow_set *);
467 static void dump_dataflow_sets (void);
469 static void variable_was_changed (variable, dataflow_set *);
470 static void **set_slot_part (dataflow_set *, rtx, void **,
471 decl_or_value, HOST_WIDE_INT,
472 enum var_init_status, rtx);
473 static void set_variable_part (dataflow_set *, rtx,
474 decl_or_value, HOST_WIDE_INT,
475 enum var_init_status, rtx, enum insert_option);
476 static void **clobber_slot_part (dataflow_set *, rtx,
477 void **, HOST_WIDE_INT, rtx);
478 static void clobber_variable_part (dataflow_set *, rtx,
479 decl_or_value, HOST_WIDE_INT, rtx);
480 static void **delete_slot_part (dataflow_set *, rtx, void **, HOST_WIDE_INT);
481 static void delete_variable_part (dataflow_set *, rtx,
482 decl_or_value, HOST_WIDE_INT);
483 static int emit_note_insn_var_location (void **, void *);
484 static void emit_notes_for_changes (rtx, enum emit_note_where, shared_hash);
485 static int emit_notes_for_differences_1 (void **, void *);
486 static int emit_notes_for_differences_2 (void **, void *);
487 static void emit_notes_for_differences (rtx, dataflow_set *, dataflow_set *);
488 static void emit_notes_in_bb (basic_block, dataflow_set *);
489 static void vt_emit_notes (void);
491 static bool vt_get_decl_and_offset (rtx, tree *, HOST_WIDE_INT *);
492 static void vt_add_function_parameters (void);
493 static bool vt_initialize (void);
494 static void vt_finalize (void);
496 /* Given a SET, calculate the amount of stack adjustment it contains
497 PRE- and POST-modifying stack pointer.
498 This function is similar to stack_adjust_offset. */
501 stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INT *pre,
504 rtx src = SET_SRC (pattern);
505 rtx dest = SET_DEST (pattern);
508 if (dest == stack_pointer_rtx)
510 /* (set (reg sp) (plus (reg sp) (const_int))) */
511 code = GET_CODE (src);
512 if (! (code == PLUS || code == MINUS)
513 || XEXP (src, 0) != stack_pointer_rtx
514 || !CONST_INT_P (XEXP (src, 1)))
518 *post += INTVAL (XEXP (src, 1));
520 *post -= INTVAL (XEXP (src, 1));
522 else if (MEM_P (dest))
524 /* (set (mem (pre_dec (reg sp))) (foo)) */
525 src = XEXP (dest, 0);
526 code = GET_CODE (src);
532 if (XEXP (src, 0) == stack_pointer_rtx)
534 rtx val = XEXP (XEXP (src, 1), 1);
535 /* We handle only adjustments by constant amount. */
536 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS &&
539 if (code == PRE_MODIFY)
540 *pre -= INTVAL (val);
542 *post -= INTVAL (val);
548 if (XEXP (src, 0) == stack_pointer_rtx)
550 *pre += GET_MODE_SIZE (GET_MODE (dest));
556 if (XEXP (src, 0) == stack_pointer_rtx)
558 *post += GET_MODE_SIZE (GET_MODE (dest));
564 if (XEXP (src, 0) == stack_pointer_rtx)
566 *pre -= GET_MODE_SIZE (GET_MODE (dest));
572 if (XEXP (src, 0) == stack_pointer_rtx)
574 *post -= GET_MODE_SIZE (GET_MODE (dest));
585 /* Given an INSN, calculate the amount of stack adjustment it contains
586 PRE- and POST-modifying stack pointer. */
589 insn_stack_adjust_offset_pre_post (rtx insn, HOST_WIDE_INT *pre,
597 pattern = PATTERN (insn);
598 if (RTX_FRAME_RELATED_P (insn))
600 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
602 pattern = XEXP (expr, 0);
605 if (GET_CODE (pattern) == SET)
606 stack_adjust_offset_pre_post (pattern, pre, post);
607 else if (GET_CODE (pattern) == PARALLEL
608 || GET_CODE (pattern) == SEQUENCE)
612 /* There may be stack adjustments inside compound insns. Search
614 for ( i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
615 if (GET_CODE (XVECEXP (pattern, 0, i)) == SET)
616 stack_adjust_offset_pre_post (XVECEXP (pattern, 0, i), pre, post);
620 /* Compute stack adjustments for all blocks by traversing DFS tree.
621 Return true when the adjustments on all incoming edges are consistent.
622 Heavily borrowed from pre_and_rev_post_order_compute. */
625 vt_stack_adjustments (void)
627 edge_iterator *stack;
630 /* Initialize entry block. */
631 VTI (ENTRY_BLOCK_PTR)->visited = true;
632 VTI (ENTRY_BLOCK_PTR)->in.stack_adjust = INCOMING_FRAME_SP_OFFSET;
633 VTI (ENTRY_BLOCK_PTR)->out.stack_adjust = INCOMING_FRAME_SP_OFFSET;
635 /* Allocate stack for back-tracking up CFG. */
636 stack = XNEWVEC (edge_iterator, n_basic_blocks + 1);
639 /* Push the first edge on to the stack. */
640 stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs);
648 /* Look at the edge on the top of the stack. */
650 src = ei_edge (ei)->src;
651 dest = ei_edge (ei)->dest;
653 /* Check if the edge destination has been visited yet. */
654 if (!VTI (dest)->visited)
657 HOST_WIDE_INT pre, post, offset;
658 VTI (dest)->visited = true;
659 VTI (dest)->in.stack_adjust = offset = VTI (src)->out.stack_adjust;
661 if (dest != EXIT_BLOCK_PTR)
662 for (insn = BB_HEAD (dest);
663 insn != NEXT_INSN (BB_END (dest));
664 insn = NEXT_INSN (insn))
667 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
668 offset += pre + post;
671 VTI (dest)->out.stack_adjust = offset;
673 if (EDGE_COUNT (dest->succs) > 0)
674 /* Since the DEST node has been visited for the first
675 time, check its successors. */
676 stack[sp++] = ei_start (dest->succs);
680 /* Check whether the adjustments on the edges are the same. */
681 if (VTI (dest)->in.stack_adjust != VTI (src)->out.stack_adjust)
687 if (! ei_one_before_end_p (ei))
688 /* Go to the next edge. */
689 ei_next (&stack[sp - 1]);
691 /* Return to previous level if there are no more edges. */
700 /* Compute a CFA-based value for the stack pointer. */
703 compute_cfa_pointer (HOST_WIDE_INT adjustment)
707 #ifdef FRAME_POINTER_CFA_OFFSET
708 adjustment -= FRAME_POINTER_CFA_OFFSET (current_function_decl);
709 cfa = plus_constant (frame_pointer_rtx, adjustment);
711 adjustment -= ARG_POINTER_CFA_OFFSET (current_function_decl);
712 cfa = plus_constant (arg_pointer_rtx, adjustment);
718 /* Adjustment for hard_frame_pointer_rtx to cfa base reg,
719 or -1 if the replacement shouldn't be done. */
720 static HOST_WIDE_INT hard_frame_pointer_adjustment = -1;
722 /* Data for adjust_mems callback. */
724 struct adjust_mem_data
727 enum machine_mode mem_mode;
728 HOST_WIDE_INT stack_adjust;
732 /* Helper function for adjusting used MEMs. */
735 adjust_mems (rtx loc, const_rtx old_rtx, void *data)
737 struct adjust_mem_data *amd = (struct adjust_mem_data *) data;
738 rtx mem, addr = loc, tem;
739 enum machine_mode mem_mode_save;
741 switch (GET_CODE (loc))
744 /* Don't do any sp or fp replacements outside of MEM addresses. */
745 if (amd->mem_mode == VOIDmode)
747 if (loc == stack_pointer_rtx
748 && !frame_pointer_needed)
749 return compute_cfa_pointer (amd->stack_adjust);
750 else if (loc == hard_frame_pointer_rtx
751 && frame_pointer_needed
752 && hard_frame_pointer_adjustment != -1)
753 return compute_cfa_pointer (hard_frame_pointer_adjustment);
759 mem = targetm.delegitimize_address (mem);
760 if (mem != loc && !MEM_P (mem))
761 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
764 addr = XEXP (mem, 0);
765 mem_mode_save = amd->mem_mode;
766 amd->mem_mode = GET_MODE (mem);
767 store_save = amd->store;
769 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
770 amd->store = store_save;
771 amd->mem_mode = mem_mode_save;
773 addr = targetm.delegitimize_address (addr);
774 if (addr != XEXP (mem, 0))
775 mem = replace_equiv_address_nv (mem, addr);
777 mem = avoid_constant_pool_reference (mem);
781 addr = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
782 GEN_INT (GET_CODE (loc) == PRE_INC
783 ? GET_MODE_SIZE (amd->mem_mode)
784 : -GET_MODE_SIZE (amd->mem_mode)));
788 addr = XEXP (loc, 0);
789 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
790 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
791 tem = gen_rtx_PLUS (GET_MODE (loc), XEXP (loc, 0),
792 GEN_INT ((GET_CODE (loc) == PRE_INC
793 || GET_CODE (loc) == POST_INC)
794 ? GET_MODE_SIZE (amd->mem_mode)
795 : -GET_MODE_SIZE (amd->mem_mode)));
796 amd->side_effects = alloc_EXPR_LIST (0,
797 gen_rtx_SET (VOIDmode,
803 addr = XEXP (loc, 1);
806 addr = XEXP (loc, 0);
807 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode);
808 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
809 amd->side_effects = alloc_EXPR_LIST (0,
810 gen_rtx_SET (VOIDmode,
816 /* First try without delegitimization of whole MEMs and
817 avoid_constant_pool_reference, which is more likely to succeed. */
818 store_save = amd->store;
820 addr = simplify_replace_fn_rtx (SUBREG_REG (loc), old_rtx, adjust_mems,
822 amd->store = store_save;
823 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
824 if (mem == SUBREG_REG (loc))
826 tem = simplify_gen_subreg (GET_MODE (loc), mem,
827 GET_MODE (SUBREG_REG (loc)),
831 tem = simplify_gen_subreg (GET_MODE (loc), addr,
832 GET_MODE (SUBREG_REG (loc)),
836 return gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc));
843 /* Helper function for replacement of uses. */
846 adjust_mem_uses (rtx *x, void *data)
848 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX, adjust_mems, data);
850 validate_change (NULL_RTX, x, new_x, true);
853 /* Helper function for replacement of stores. */
856 adjust_mem_stores (rtx loc, const_rtx expr, void *data)
860 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr), NULL_RTX,
862 if (new_dest != SET_DEST (expr))
864 rtx xexpr = CONST_CAST_RTX (expr);
865 validate_change (NULL_RTX, &SET_DEST (xexpr), new_dest, true);
870 /* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
871 replace them with their value in the insn and add the side-effects
872 as other sets to the insn. */
875 adjust_insn (basic_block bb, rtx insn)
877 struct adjust_mem_data amd;
879 amd.mem_mode = VOIDmode;
880 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
881 amd.side_effects = NULL_RTX;
884 note_stores (PATTERN (insn), adjust_mem_stores, &amd);
887 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
889 /* For read-only MEMs containing some constant, prefer those
891 set = single_set (insn);
892 if (set && MEM_P (SET_SRC (set)) && MEM_READONLY_P (SET_SRC (set)))
894 rtx note = find_reg_equal_equiv_note (insn);
896 if (note && CONSTANT_P (XEXP (note, 0)))
897 validate_change (NULL_RTX, &SET_SRC (set), XEXP (note, 0), true);
900 if (amd.side_effects)
902 rtx *pat, new_pat, s;
905 pat = &PATTERN (insn);
906 if (GET_CODE (*pat) == COND_EXEC)
907 pat = &COND_EXEC_CODE (*pat);
908 if (GET_CODE (*pat) == PARALLEL)
909 oldn = XVECLEN (*pat, 0);
912 for (s = amd.side_effects, newn = 0; s; newn++)
914 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn));
915 if (GET_CODE (*pat) == PARALLEL)
916 for (i = 0; i < oldn; i++)
917 XVECEXP (new_pat, 0, i) = XVECEXP (*pat, 0, i);
919 XVECEXP (new_pat, 0, 0) = *pat;
920 for (s = amd.side_effects, i = oldn; i < oldn + newn; i++, s = XEXP (s, 1))
921 XVECEXP (new_pat, 0, i) = XEXP (s, 0);
922 free_EXPR_LIST_list (&amd.side_effects);
923 validate_change (NULL_RTX, pat, new_pat, true);
927 /* Return true if a decl_or_value DV is a DECL or NULL. */
929 dv_is_decl_p (decl_or_value dv)
931 return !dv || (int) TREE_CODE ((tree) dv) != (int) VALUE;
934 /* Return true if a decl_or_value is a VALUE rtl. */
936 dv_is_value_p (decl_or_value dv)
938 return dv && !dv_is_decl_p (dv);
941 /* Return the decl in the decl_or_value. */
943 dv_as_decl (decl_or_value dv)
945 #ifdef ENABLE_CHECKING
946 gcc_assert (dv_is_decl_p (dv));
951 /* Return the value in the decl_or_value. */
953 dv_as_value (decl_or_value dv)
955 #ifdef ENABLE_CHECKING
956 gcc_assert (dv_is_value_p (dv));
961 /* Return the opaque pointer in the decl_or_value. */
963 dv_as_opaque (decl_or_value dv)
968 /* Return true if a decl_or_value must not have more than one variable
971 dv_onepart_p (decl_or_value dv)
975 if (!MAY_HAVE_DEBUG_INSNS)
978 if (dv_is_value_p (dv))
981 decl = dv_as_decl (dv);
986 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
989 return (target_for_debug_bind (decl) != NULL_TREE);
992 /* Return the variable pool to be used for dv, depending on whether it
993 can have multiple parts or not. */
994 static inline alloc_pool
995 dv_pool (decl_or_value dv)
997 return dv_onepart_p (dv) ? valvar_pool : var_pool;
1000 /* Build a decl_or_value out of a decl. */
1001 static inline decl_or_value
1002 dv_from_decl (tree decl)
1006 #ifdef ENABLE_CHECKING
1007 gcc_assert (dv_is_decl_p (dv));
1012 /* Build a decl_or_value out of a value. */
1013 static inline decl_or_value
1014 dv_from_value (rtx value)
1018 #ifdef ENABLE_CHECKING
1019 gcc_assert (dv_is_value_p (dv));
1024 extern void debug_dv (decl_or_value dv);
1027 debug_dv (decl_or_value dv)
1029 if (dv_is_value_p (dv))
1030 debug_rtx (dv_as_value (dv));
1032 debug_generic_stmt (dv_as_decl (dv));
1035 typedef unsigned int dvuid;
1037 /* Return the uid of DV. */
1040 dv_uid (decl_or_value dv)
1042 if (dv_is_value_p (dv))
1043 return CSELIB_VAL_PTR (dv_as_value (dv))->uid;
1045 return DECL_UID (dv_as_decl (dv));
1048 /* Compute the hash from the uid. */
1050 static inline hashval_t
1051 dv_uid2hash (dvuid uid)
1056 /* The hash function for a mask table in a shared_htab chain. */
1058 static inline hashval_t
1059 dv_htab_hash (decl_or_value dv)
1061 return dv_uid2hash (dv_uid (dv));
1064 /* The hash function for variable_htab, computes the hash value
1065 from the declaration of variable X. */
1068 variable_htab_hash (const void *x)
1070 const_variable const v = (const_variable) x;
1072 return dv_htab_hash (v->dv);
1075 /* Compare the declaration of variable X with declaration Y. */
1078 variable_htab_eq (const void *x, const void *y)
1080 const_variable const v = (const_variable) x;
1081 decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y);
1083 return (dv_as_opaque (v->dv) == dv_as_opaque (dv));
1086 /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1089 variable_htab_free (void *elem)
1092 variable var = (variable) elem;
1093 location_chain node, next;
1095 gcc_assert (var->refcount > 0);
1098 if (var->refcount > 0)
1101 for (i = 0; i < var->n_var_parts; i++)
1103 for (node = var->var_part[i].loc_chain; node; node = next)
1106 pool_free (loc_chain_pool, node);
1108 var->var_part[i].loc_chain = NULL;
1110 pool_free (dv_pool (var->dv), var);
1113 /* The hash function for value_chains htab, computes the hash value
1117 value_chain_htab_hash (const void *x)
1119 const_value_chain const v = (const_value_chain) x;
1121 return dv_htab_hash (v->dv);
1124 /* Compare the VALUE X with VALUE Y. */
1127 value_chain_htab_eq (const void *x, const void *y)
1129 const_value_chain const v = (const_value_chain) x;
1130 decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y);
1132 return dv_as_opaque (v->dv) == dv_as_opaque (dv);
1135 /* Initialize the set (array) SET of attrs to empty lists. */
1138 init_attrs_list_set (attrs *set)
1142 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1146 /* Make the list *LISTP empty. */
1149 attrs_list_clear (attrs *listp)
1153 for (list = *listp; list; list = next)
1156 pool_free (attrs_pool, list);
1161 /* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1164 attrs_list_member (attrs list, decl_or_value dv, HOST_WIDE_INT offset)
1166 for (; list; list = list->next)
1167 if (dv_as_opaque (list->dv) == dv_as_opaque (dv) && list->offset == offset)
1172 /* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1175 attrs_list_insert (attrs *listp, decl_or_value dv,
1176 HOST_WIDE_INT offset, rtx loc)
1180 list = (attrs) pool_alloc (attrs_pool);
1183 list->offset = offset;
1184 list->next = *listp;
1188 /* Copy all nodes from SRC and create a list *DSTP of the copies. */
1191 attrs_list_copy (attrs *dstp, attrs src)
1195 attrs_list_clear (dstp);
1196 for (; src; src = src->next)
1198 n = (attrs) pool_alloc (attrs_pool);
1201 n->offset = src->offset;
1207 /* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1210 attrs_list_union (attrs *dstp, attrs src)
1212 for (; src; src = src->next)
1214 if (!attrs_list_member (*dstp, src->dv, src->offset))
1215 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1219 /* Combine nodes that are not onepart nodes from SRC and SRC2 into
1223 attrs_list_mpdv_union (attrs *dstp, attrs src, attrs src2)
1225 gcc_assert (!*dstp);
1226 for (; src; src = src->next)
1228 if (!dv_onepart_p (src->dv))
1229 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1231 for (src = src2; src; src = src->next)
1233 if (!dv_onepart_p (src->dv)
1234 && !attrs_list_member (*dstp, src->dv, src->offset))
1235 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1239 /* Shared hashtable support. */
1241 /* Return true if VARS is shared. */
1244 shared_hash_shared (shared_hash vars)
1246 return vars->refcount > 1;
1249 /* Return the hash table for VARS. */
1251 static inline htab_t
1252 shared_hash_htab (shared_hash vars)
1257 /* Return true if VAR is shared, or maybe because VARS is shared. */
1260 shared_var_p (variable var, shared_hash vars)
1262 /* Don't count an entry in the changed_variables table as a duplicate. */
1263 return ((var->refcount > 1 + (int) var->in_changed_variables)
1264 || shared_hash_shared (vars));
1267 /* Copy variables into a new hash table. */
1270 shared_hash_unshare (shared_hash vars)
1272 shared_hash new_vars = (shared_hash) pool_alloc (shared_hash_pool);
1273 gcc_assert (vars->refcount > 1);
1274 new_vars->refcount = 1;
1276 = htab_create (htab_elements (vars->htab) + 3, variable_htab_hash,
1277 variable_htab_eq, variable_htab_free);
1278 vars_copy (new_vars->htab, vars->htab);
1283 /* Increment reference counter on VARS and return it. */
1285 static inline shared_hash
1286 shared_hash_copy (shared_hash vars)
1292 /* Decrement reference counter and destroy hash table if not shared
1296 shared_hash_destroy (shared_hash vars)
1298 gcc_assert (vars->refcount > 0);
1299 if (--vars->refcount == 0)
1301 htab_delete (vars->htab);
1302 pool_free (shared_hash_pool, vars);
1306 /* Unshare *PVARS if shared and return slot for DV. If INS is
1307 INSERT, insert it if not already present. */
1309 static inline void **
1310 shared_hash_find_slot_unshare_1 (shared_hash *pvars, decl_or_value dv,
1311 hashval_t dvhash, enum insert_option ins)
1313 if (shared_hash_shared (*pvars))
1314 *pvars = shared_hash_unshare (*pvars);
1315 return htab_find_slot_with_hash (shared_hash_htab (*pvars), dv, dvhash, ins);
1318 static inline void **
1319 shared_hash_find_slot_unshare (shared_hash *pvars, decl_or_value dv,
1320 enum insert_option ins)
1322 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1325 /* Return slot for DV, if it is already present in the hash table.
1326 If it is not present, insert it only VARS is not shared, otherwise
1329 static inline void **
1330 shared_hash_find_slot_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
1332 return htab_find_slot_with_hash (shared_hash_htab (vars), dv, dvhash,
1333 shared_hash_shared (vars)
1334 ? NO_INSERT : INSERT);
1337 static inline void **
1338 shared_hash_find_slot (shared_hash vars, decl_or_value dv)
1340 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1343 /* Return slot for DV only if it is already present in the hash table. */
1345 static inline void **
1346 shared_hash_find_slot_noinsert_1 (shared_hash vars, decl_or_value dv,
1349 return htab_find_slot_with_hash (shared_hash_htab (vars), dv, dvhash,
1353 static inline void **
1354 shared_hash_find_slot_noinsert (shared_hash vars, decl_or_value dv)
1356 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1359 /* Return variable for DV or NULL if not already present in the hash
1362 static inline variable
1363 shared_hash_find_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
1365 return (variable) htab_find_with_hash (shared_hash_htab (vars), dv, dvhash);
1368 static inline variable
1369 shared_hash_find (shared_hash vars, decl_or_value dv)
1371 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1374 /* Return true if TVAL is better than CVAL as a canonival value. We
1375 choose lowest-numbered VALUEs, using the RTX address as a
1376 tie-breaker. The idea is to arrange them into a star topology,
1377 such that all of them are at most one step away from the canonical
1378 value, and the canonical value has backlinks to all of them, in
1379 addition to all the actual locations. We don't enforce this
1380 topology throughout the entire dataflow analysis, though.
1384 canon_value_cmp (rtx tval, rtx cval)
1387 || CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
1390 static bool dst_can_be_shared;
1392 /* Return a copy of a variable VAR and insert it to dataflow set SET. */
1395 unshare_variable (dataflow_set *set, void **slot, variable var,
1396 enum var_init_status initialized)
1401 new_var = (variable) pool_alloc (dv_pool (var->dv));
1402 new_var->dv = var->dv;
1403 new_var->refcount = 1;
1405 new_var->n_var_parts = var->n_var_parts;
1406 new_var->cur_loc_changed = var->cur_loc_changed;
1407 var->cur_loc_changed = false;
1408 new_var->in_changed_variables = false;
1410 if (! flag_var_tracking_uninit)
1411 initialized = VAR_INIT_STATUS_INITIALIZED;
1413 for (i = 0; i < var->n_var_parts; i++)
1415 location_chain node;
1416 location_chain *nextp;
1418 new_var->var_part[i].offset = var->var_part[i].offset;
1419 nextp = &new_var->var_part[i].loc_chain;
1420 for (node = var->var_part[i].loc_chain; node; node = node->next)
1422 location_chain new_lc;
1424 new_lc = (location_chain) pool_alloc (loc_chain_pool);
1425 new_lc->next = NULL;
1426 if (node->init > initialized)
1427 new_lc->init = node->init;
1429 new_lc->init = initialized;
1430 if (node->set_src && !(MEM_P (node->set_src)))
1431 new_lc->set_src = node->set_src;
1433 new_lc->set_src = NULL;
1434 new_lc->loc = node->loc;
1437 nextp = &new_lc->next;
1440 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1443 dst_can_be_shared = false;
1444 if (shared_hash_shared (set->vars))
1445 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1446 else if (set->traversed_vars && set->vars != set->traversed_vars)
1447 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1449 if (var->in_changed_variables)
1452 = htab_find_slot_with_hash (changed_variables, var->dv,
1453 dv_htab_hash (var->dv), NO_INSERT);
1454 gcc_assert (*cslot == (void *) var);
1455 var->in_changed_variables = false;
1456 variable_htab_free (var);
1458 new_var->in_changed_variables = true;
1463 /* Add a variable from *SLOT to hash table DATA and increase its reference
1467 vars_copy_1 (void **slot, void *data)
1469 htab_t dst = (htab_t) data;
1473 src = (variable) *slot;
1476 dstp = htab_find_slot_with_hash (dst, src->dv,
1477 dv_htab_hash (src->dv),
1481 /* Continue traversing the hash table. */
1485 /* Copy all variables from hash table SRC to hash table DST. */
1488 vars_copy (htab_t dst, htab_t src)
1490 htab_traverse_noresize (src, vars_copy_1, dst);
1493 /* Map a decl to its main debug decl. */
1496 var_debug_decl (tree decl)
1498 if (decl && DECL_P (decl)
1499 && DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
1500 && DECL_P (DECL_DEBUG_EXPR (decl)))
1501 decl = DECL_DEBUG_EXPR (decl);
1506 /* Set the register LOC to contain DV, OFFSET. */
1509 var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1510 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1511 enum insert_option iopt)
1514 bool decl_p = dv_is_decl_p (dv);
1517 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1519 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1520 if (dv_as_opaque (node->dv) == dv_as_opaque (dv)
1521 && node->offset == offset)
1524 attrs_list_insert (&set->regs[REGNO (loc)], dv, offset, loc);
1525 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1528 /* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1531 var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1534 tree decl = REG_EXPR (loc);
1535 HOST_WIDE_INT offset = REG_OFFSET (loc);
1537 var_reg_decl_set (set, loc, initialized,
1538 dv_from_decl (decl), offset, set_src, INSERT);
1541 static enum var_init_status
1542 get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1546 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1548 if (! flag_var_tracking_uninit)
1549 return VAR_INIT_STATUS_INITIALIZED;
1551 var = shared_hash_find (set->vars, dv);
1554 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1556 location_chain nextp;
1557 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1558 if (rtx_equal_p (nextp->loc, loc))
1560 ret_val = nextp->init;
1569 /* Delete current content of register LOC in dataflow set SET and set
1570 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1571 MODIFY is true, any other live copies of the same variable part are
1572 also deleted from the dataflow set, otherwise the variable part is
1573 assumed to be copied from another location holding the same
1577 var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1578 enum var_init_status initialized, rtx set_src)
1580 tree decl = REG_EXPR (loc);
1581 HOST_WIDE_INT offset = REG_OFFSET (loc);
1585 decl = var_debug_decl (decl);
1587 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1588 initialized = get_init_value (set, loc, dv_from_decl (decl));
1590 nextp = &set->regs[REGNO (loc)];
1591 for (node = *nextp; node; node = next)
1594 if (dv_as_opaque (node->dv) != decl || node->offset != offset)
1596 delete_variable_part (set, node->loc, node->dv, node->offset);
1597 pool_free (attrs_pool, node);
1603 nextp = &node->next;
1607 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1608 var_reg_set (set, loc, initialized, set_src);
1611 /* Delete the association of register LOC in dataflow set SET with any
1612 variables that aren't onepart. If CLOBBER is true, also delete any
1613 other live copies of the same variable part, and delete the
1614 association with onepart dvs too. */
1617 var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1619 attrs *nextp = &set->regs[REGNO (loc)];
1624 tree decl = REG_EXPR (loc);
1625 HOST_WIDE_INT offset = REG_OFFSET (loc);
1627 decl = var_debug_decl (decl);
1629 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1632 for (node = *nextp; node; node = next)
1635 if (clobber || !dv_onepart_p (node->dv))
1637 delete_variable_part (set, node->loc, node->dv, node->offset);
1638 pool_free (attrs_pool, node);
1642 nextp = &node->next;
1646 /* Delete content of register with number REGNO in dataflow set SET. */
1649 var_regno_delete (dataflow_set *set, int regno)
1651 attrs *reg = &set->regs[regno];
1654 for (node = *reg; node; node = next)
1657 delete_variable_part (set, node->loc, node->dv, node->offset);
1658 pool_free (attrs_pool, node);
1663 /* Set the location of DV, OFFSET as the MEM LOC. */
1666 var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1667 decl_or_value dv, HOST_WIDE_INT offset, rtx set_src,
1668 enum insert_option iopt)
1670 if (dv_is_decl_p (dv))
1671 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1673 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1676 /* Set the location part of variable MEM_EXPR (LOC) in dataflow set
1678 Adjust the address first if it is stack pointer based. */
1681 var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1684 tree decl = MEM_EXPR (loc);
1685 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
1687 var_mem_decl_set (set, loc, initialized,
1688 dv_from_decl (decl), offset, set_src, INSERT);
1691 /* Delete and set the location part of variable MEM_EXPR (LOC) in
1692 dataflow set SET to LOC. If MODIFY is true, any other live copies
1693 of the same variable part are also deleted from the dataflow set,
1694 otherwise the variable part is assumed to be copied from another
1695 location holding the same part.
1696 Adjust the address first if it is stack pointer based. */
1699 var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1700 enum var_init_status initialized, rtx set_src)
1702 tree decl = MEM_EXPR (loc);
1703 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
1705 decl = var_debug_decl (decl);
1707 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1708 initialized = get_init_value (set, loc, dv_from_decl (decl));
1711 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, set_src);
1712 var_mem_set (set, loc, initialized, set_src);
1715 /* Delete the location part LOC from dataflow set SET. If CLOBBER is
1716 true, also delete any other live copies of the same variable part.
1717 Adjust the address first if it is stack pointer based. */
1720 var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
1722 tree decl = MEM_EXPR (loc);
1723 HOST_WIDE_INT offset = INT_MEM_OFFSET (loc);
1725 decl = var_debug_decl (decl);
1727 clobber_variable_part (set, NULL, dv_from_decl (decl), offset, NULL);
1728 delete_variable_part (set, loc, dv_from_decl (decl), offset);
1731 /* Bind a value to a location it was just stored in. If MODIFIED
1732 holds, assume the location was modified, detaching it from any
1733 values bound to it. */
1736 val_store (dataflow_set *set, rtx val, rtx loc, rtx insn, bool modified)
1738 cselib_val *v = CSELIB_VAL_PTR (val);
1740 gcc_assert (cselib_preserved_value_p (v));
1744 fprintf (dump_file, "%i: ", INSN_UID (insn));
1745 print_inline_rtx (dump_file, val, 0);
1746 fprintf (dump_file, " stored in ");
1747 print_inline_rtx (dump_file, loc, 0);
1750 struct elt_loc_list *l;
1751 for (l = v->locs; l; l = l->next)
1753 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
1754 print_inline_rtx (dump_file, l->loc, 0);
1757 fprintf (dump_file, "\n");
1763 var_regno_delete (set, REGNO (loc));
1764 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
1765 dv_from_value (val), 0, NULL_RTX, INSERT);
1767 else if (MEM_P (loc))
1768 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
1769 dv_from_value (val), 0, NULL_RTX, INSERT);
1771 set_variable_part (set, loc, dv_from_value (val), 0,
1772 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
1775 /* Reset this node, detaching all its equivalences. Return the slot
1776 in the variable hash table that holds dv, if there is one. */
1779 val_reset (dataflow_set *set, decl_or_value dv)
1781 variable var = shared_hash_find (set->vars, dv) ;
1782 location_chain node;
1785 if (!var || !var->n_var_parts)
1788 gcc_assert (var->n_var_parts == 1);
1791 for (node = var->var_part[0].loc_chain; node; node = node->next)
1792 if (GET_CODE (node->loc) == VALUE
1793 && canon_value_cmp (node->loc, cval))
1796 for (node = var->var_part[0].loc_chain; node; node = node->next)
1797 if (GET_CODE (node->loc) == VALUE && cval != node->loc)
1799 /* Redirect the equivalence link to the new canonical
1800 value, or simply remove it if it would point at
1803 set_variable_part (set, cval, dv_from_value (node->loc),
1804 0, node->init, node->set_src, NO_INSERT);
1805 delete_variable_part (set, dv_as_value (dv),
1806 dv_from_value (node->loc), 0);
1811 decl_or_value cdv = dv_from_value (cval);
1813 /* Keep the remaining values connected, accummulating links
1814 in the canonical value. */
1815 for (node = var->var_part[0].loc_chain; node; node = node->next)
1817 if (node->loc == cval)
1819 else if (GET_CODE (node->loc) == REG)
1820 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
1821 node->set_src, NO_INSERT);
1822 else if (GET_CODE (node->loc) == MEM)
1823 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
1824 node->set_src, NO_INSERT);
1826 set_variable_part (set, node->loc, cdv, 0,
1827 node->init, node->set_src, NO_INSERT);
1831 /* We remove this last, to make sure that the canonical value is not
1832 removed to the point of requiring reinsertion. */
1834 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
1836 clobber_variable_part (set, NULL, dv, 0, NULL);
1838 /* ??? Should we make sure there aren't other available values or
1839 variables whose values involve this one other than by
1840 equivalence? E.g., at the very least we should reset MEMs, those
1841 shouldn't be too hard to find cselib-looking up the value as an
1842 address, then locating the resulting value in our own hash
1846 /* Find the values in a given location and map the val to another
1847 value, if it is unique, or add the location as one holding the
1851 val_resolve (dataflow_set *set, rtx val, rtx loc, rtx insn)
1853 decl_or_value dv = dv_from_value (val);
1855 if (dump_file && (dump_flags & TDF_DETAILS))
1858 fprintf (dump_file, "%i: ", INSN_UID (insn));
1860 fprintf (dump_file, "head: ");
1861 print_inline_rtx (dump_file, val, 0);
1862 fputs (" is at ", dump_file);
1863 print_inline_rtx (dump_file, loc, 0);
1864 fputc ('\n', dump_file);
1867 val_reset (set, dv);
1871 attrs node, found = NULL;
1873 for (node = set->regs[REGNO (loc)]; node; node = node->next)
1874 if (dv_is_value_p (node->dv)
1875 && GET_MODE (dv_as_value (node->dv)) == GET_MODE (loc))
1879 /* Map incoming equivalences. ??? Wouldn't it be nice if
1880 we just started sharing the location lists? Maybe a
1881 circular list ending at the value itself or some
1883 set_variable_part (set, dv_as_value (node->dv),
1884 dv_from_value (val), node->offset,
1885 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
1886 set_variable_part (set, val, node->dv, node->offset,
1887 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
1890 /* If we didn't find any equivalence, we need to remember that
1891 this value is held in the named register. */
1893 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
1894 dv_from_value (val), 0, NULL_RTX, INSERT);
1896 else if (MEM_P (loc))
1897 /* ??? Merge equivalent MEMs. */
1898 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
1899 dv_from_value (val), 0, NULL_RTX, INSERT);
1901 /* ??? Merge equivalent expressions. */
1902 set_variable_part (set, loc, dv_from_value (val), 0,
1903 VAR_INIT_STATUS_INITIALIZED, NULL_RTX, INSERT);
1906 /* Initialize dataflow set SET to be empty.
1907 VARS_SIZE is the initial size of hash table VARS. */
1910 dataflow_set_init (dataflow_set *set)
1912 init_attrs_list_set (set->regs);
1913 set->vars = shared_hash_copy (empty_shared_hash);
1914 set->stack_adjust = 0;
1915 set->traversed_vars = NULL;
1918 /* Delete the contents of dataflow set SET. */
1921 dataflow_set_clear (dataflow_set *set)
1925 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1926 attrs_list_clear (&set->regs[i]);
1928 shared_hash_destroy (set->vars);
1929 set->vars = shared_hash_copy (empty_shared_hash);
1932 /* Copy the contents of dataflow set SRC to DST. */
1935 dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
1939 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1940 attrs_list_copy (&dst->regs[i], src->regs[i]);
1942 shared_hash_destroy (dst->vars);
1943 dst->vars = shared_hash_copy (src->vars);
1944 dst->stack_adjust = src->stack_adjust;
1947 /* Information for merging lists of locations for a given offset of variable.
1949 struct variable_union_info
1951 /* Node of the location chain. */
1954 /* The sum of positions in the input chains. */
1957 /* The position in the chain of DST dataflow set. */
1961 /* Buffer for location list sorting and its allocated size. */
1962 static struct variable_union_info *vui_vec;
1963 static int vui_allocated;
1965 /* Compare function for qsort, order the structures by POS element. */
1968 variable_union_info_cmp_pos (const void *n1, const void *n2)
1970 const struct variable_union_info *const i1 =
1971 (const struct variable_union_info *) n1;
1972 const struct variable_union_info *const i2 =
1973 ( const struct variable_union_info *) n2;
1975 if (i1->pos != i2->pos)
1976 return i1->pos - i2->pos;
1978 return (i1->pos_dst - i2->pos_dst);
1981 /* Compute union of location parts of variable *SLOT and the same variable
1982 from hash table DATA. Compute "sorted" union of the location chains
1983 for common offsets, i.e. the locations of a variable part are sorted by
1984 a priority where the priority is the sum of the positions in the 2 chains
1985 (if a location is only in one list the position in the second list is
1986 defined to be larger than the length of the chains).
1987 When we are updating the location parts the newest location is in the
1988 beginning of the chain, so when we do the described "sorted" union
1989 we keep the newest locations in the beginning. */
1992 variable_union (void **slot, void *data)
1996 dataflow_set *set = (dataflow_set *) data;
1999 src = (variable) *slot;
2000 dstp = shared_hash_find_slot (set->vars, src->dv);
2001 if (!dstp || !*dstp)
2005 dst_can_be_shared = false;
2007 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2011 /* Continue traversing the hash table. */
2015 dst = (variable) *dstp;
2017 gcc_assert (src->n_var_parts);
2019 /* We can combine one-part variables very efficiently, because their
2020 entries are in canonical order. */
2021 if (dv_onepart_p (src->dv))
2023 location_chain *nodep, dnode, snode;
2025 gcc_assert (src->n_var_parts == 1);
2026 gcc_assert (dst->n_var_parts == 1);
2028 snode = src->var_part[0].loc_chain;
2031 restart_onepart_unshared:
2032 nodep = &dst->var_part[0].loc_chain;
2038 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2042 location_chain nnode;
2044 if (shared_var_p (dst, set->vars))
2046 dstp = unshare_variable (set, dstp, dst,
2047 VAR_INIT_STATUS_INITIALIZED);
2048 dst = (variable)*dstp;
2049 goto restart_onepart_unshared;
2052 *nodep = nnode = (location_chain) pool_alloc (loc_chain_pool);
2053 nnode->loc = snode->loc;
2054 nnode->init = snode->init;
2055 if (!snode->set_src || MEM_P (snode->set_src))
2056 nnode->set_src = NULL;
2058 nnode->set_src = snode->set_src;
2059 nnode->next = dnode;
2062 #ifdef ENABLE_CHECKING
2064 gcc_assert (rtx_equal_p (dnode->loc, snode->loc));
2068 snode = snode->next;
2070 nodep = &dnode->next;
2077 /* Count the number of location parts, result is K. */
2078 for (i = 0, j = 0, k = 0;
2079 i < src->n_var_parts && j < dst->n_var_parts; k++)
2081 if (src->var_part[i].offset == dst->var_part[j].offset)
2086 else if (src->var_part[i].offset < dst->var_part[j].offset)
2091 k += src->n_var_parts - i;
2092 k += dst->n_var_parts - j;
2094 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2095 thus there are at most MAX_VAR_PARTS different offsets. */
2096 gcc_assert (dv_onepart_p (dst->dv) ? k == 1 : k <= MAX_VAR_PARTS);
2098 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2100 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2101 dst = (variable)*dstp;
2104 i = src->n_var_parts - 1;
2105 j = dst->n_var_parts - 1;
2106 dst->n_var_parts = k;
2108 for (k--; k >= 0; k--)
2110 location_chain node, node2;
2112 if (i >= 0 && j >= 0
2113 && src->var_part[i].offset == dst->var_part[j].offset)
2115 /* Compute the "sorted" union of the chains, i.e. the locations which
2116 are in both chains go first, they are sorted by the sum of
2117 positions in the chains. */
2120 struct variable_union_info *vui;
2122 /* If DST is shared compare the location chains.
2123 If they are different we will modify the chain in DST with
2124 high probability so make a copy of DST. */
2125 if (shared_var_p (dst, set->vars))
2127 for (node = src->var_part[i].loc_chain,
2128 node2 = dst->var_part[j].loc_chain; node && node2;
2129 node = node->next, node2 = node2->next)
2131 if (!((REG_P (node2->loc)
2132 && REG_P (node->loc)
2133 && REGNO (node2->loc) == REGNO (node->loc))
2134 || rtx_equal_p (node2->loc, node->loc)))
2136 if (node2->init < node->init)
2137 node2->init = node->init;
2143 dstp = unshare_variable (set, dstp, dst,
2144 VAR_INIT_STATUS_UNKNOWN);
2145 dst = (variable)*dstp;
2150 for (node = src->var_part[i].loc_chain; node; node = node->next)
2153 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2158 /* The most common case, much simpler, no qsort is needed. */
2159 location_chain dstnode = dst->var_part[j].loc_chain;
2160 dst->var_part[k].loc_chain = dstnode;
2161 dst->var_part[k].offset = dst->var_part[j].offset;
2163 for (node = src->var_part[i].loc_chain; node; node = node->next)
2164 if (!((REG_P (dstnode->loc)
2165 && REG_P (node->loc)
2166 && REGNO (dstnode->loc) == REGNO (node->loc))
2167 || rtx_equal_p (dstnode->loc, node->loc)))
2169 location_chain new_node;
2171 /* Copy the location from SRC. */
2172 new_node = (location_chain) pool_alloc (loc_chain_pool);
2173 new_node->loc = node->loc;
2174 new_node->init = node->init;
2175 if (!node->set_src || MEM_P (node->set_src))
2176 new_node->set_src = NULL;
2178 new_node->set_src = node->set_src;
2179 node2->next = new_node;
2186 if (src_l + dst_l > vui_allocated)
2188 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l);
2189 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,
2194 /* Fill in the locations from DST. */
2195 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2196 node = node->next, jj++)
2199 vui[jj].pos_dst = jj;
2201 /* Pos plus value larger than a sum of 2 valid positions. */
2202 vui[jj].pos = jj + src_l + dst_l;
2205 /* Fill in the locations from SRC. */
2207 for (node = src->var_part[i].loc_chain, ii = 0; node;
2208 node = node->next, ii++)
2210 /* Find location from NODE. */
2211 for (jj = 0; jj < dst_l; jj++)
2213 if ((REG_P (vui[jj].lc->loc)
2214 && REG_P (node->loc)
2215 && REGNO (vui[jj].lc->loc) == REGNO (node->loc))
2216 || rtx_equal_p (vui[jj].lc->loc, node->loc))
2218 vui[jj].pos = jj + ii;
2222 if (jj >= dst_l) /* The location has not been found. */
2224 location_chain new_node;
2226 /* Copy the location from SRC. */
2227 new_node = (location_chain) pool_alloc (loc_chain_pool);
2228 new_node->loc = node->loc;
2229 new_node->init = node->init;
2230 if (!node->set_src || MEM_P (node->set_src))
2231 new_node->set_src = NULL;
2233 new_node->set_src = node->set_src;
2234 vui[n].lc = new_node;
2235 vui[n].pos_dst = src_l + dst_l;
2236 vui[n].pos = ii + src_l + dst_l;
2243 /* Special case still very common case. For dst_l == 2
2244 all entries dst_l ... n-1 are sorted, with for i >= dst_l
2245 vui[i].pos == i + src_l + dst_l. */
2246 if (vui[0].pos > vui[1].pos)
2248 /* Order should be 1, 0, 2... */
2249 dst->var_part[k].loc_chain = vui[1].lc;
2250 vui[1].lc->next = vui[0].lc;
2253 vui[0].lc->next = vui[2].lc;
2254 vui[n - 1].lc->next = NULL;
2257 vui[0].lc->next = NULL;
2262 dst->var_part[k].loc_chain = vui[0].lc;
2263 if (n >= 3 && vui[2].pos < vui[1].pos)
2265 /* Order should be 0, 2, 1, 3... */
2266 vui[0].lc->next = vui[2].lc;
2267 vui[2].lc->next = vui[1].lc;
2270 vui[1].lc->next = vui[3].lc;
2271 vui[n - 1].lc->next = NULL;
2274 vui[1].lc->next = NULL;
2279 /* Order should be 0, 1, 2... */
2281 vui[n - 1].lc->next = NULL;
2284 for (; ii < n; ii++)
2285 vui[ii - 1].lc->next = vui[ii].lc;
2289 qsort (vui, n, sizeof (struct variable_union_info),
2290 variable_union_info_cmp_pos);
2292 /* Reconnect the nodes in sorted order. */
2293 for (ii = 1; ii < n; ii++)
2294 vui[ii - 1].lc->next = vui[ii].lc;
2295 vui[n - 1].lc->next = NULL;
2296 dst->var_part[k].loc_chain = vui[0].lc;
2299 dst->var_part[k].offset = dst->var_part[j].offset;
2304 else if ((i >= 0 && j >= 0
2305 && src->var_part[i].offset < dst->var_part[j].offset)
2308 dst->var_part[k] = dst->var_part[j];
2311 else if ((i >= 0 && j >= 0
2312 && src->var_part[i].offset > dst->var_part[j].offset)
2315 location_chain *nextp;
2317 /* Copy the chain from SRC. */
2318 nextp = &dst->var_part[k].loc_chain;
2319 for (node = src->var_part[i].loc_chain; node; node = node->next)
2321 location_chain new_lc;
2323 new_lc = (location_chain) pool_alloc (loc_chain_pool);
2324 new_lc->next = NULL;
2325 new_lc->init = node->init;
2326 if (!node->set_src || MEM_P (node->set_src))
2327 new_lc->set_src = NULL;
2329 new_lc->set_src = node->set_src;
2330 new_lc->loc = node->loc;
2333 nextp = &new_lc->next;
2336 dst->var_part[k].offset = src->var_part[i].offset;
2339 dst->var_part[k].cur_loc = NULL;
2342 if (flag_var_tracking_uninit)
2343 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
2345 location_chain node, node2;
2346 for (node = src->var_part[i].loc_chain; node; node = node->next)
2347 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
2348 if (rtx_equal_p (node->loc, node2->loc))
2350 if (node->init > node2->init)
2351 node2->init = node->init;
2355 /* Continue traversing the hash table. */
2359 /* Compute union of dataflow sets SRC and DST and store it to DST. */
2362 dataflow_set_union (dataflow_set *dst, dataflow_set *src)
2366 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2367 attrs_list_union (&dst->regs[i], src->regs[i]);
2369 if (dst->vars == empty_shared_hash)
2371 shared_hash_destroy (dst->vars);
2372 dst->vars = shared_hash_copy (src->vars);
2375 htab_traverse (shared_hash_htab (src->vars), variable_union, dst);
2378 /* Whether the value is currently being expanded. */
2379 #define VALUE_RECURSED_INTO(x) \
2380 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)->used)
2381 /* Whether the value is in changed_variables hash table. */
2382 #define VALUE_CHANGED(x) \
2383 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)->frame_related)
2384 /* Whether the decl is in changed_variables hash table. */
2385 #define DECL_CHANGED(x) TREE_VISITED (x)
2387 /* Record that DV has been added into resp. removed from changed_variables
2391 set_dv_changed (decl_or_value dv, bool newv)
2393 if (dv_is_value_p (dv))
2394 VALUE_CHANGED (dv_as_value (dv)) = newv;
2396 DECL_CHANGED (dv_as_decl (dv)) = newv;
2399 /* Return true if DV is present in changed_variables hash table. */
2402 dv_changed_p (decl_or_value dv)
2404 return (dv_is_value_p (dv)
2405 ? VALUE_CHANGED (dv_as_value (dv))
2406 : DECL_CHANGED (dv_as_decl (dv)));
2409 /* Return a location list node whose loc is rtx_equal to LOC, in the
2410 location list of a one-part variable or value VAR, or in that of
2411 any values recursively mentioned in the location lists. */
2413 static location_chain
2414 find_loc_in_1pdv (rtx loc, variable var, htab_t vars)
2416 location_chain node;
2421 gcc_assert (dv_onepart_p (var->dv));
2423 if (!var->n_var_parts)
2426 gcc_assert (var->var_part[0].offset == 0);
2428 for (node = var->var_part[0].loc_chain; node; node = node->next)
2429 if (rtx_equal_p (loc, node->loc))
2431 else if (GET_CODE (node->loc) == VALUE
2432 && !VALUE_RECURSED_INTO (node->loc))
2434 decl_or_value dv = dv_from_value (node->loc);
2435 variable var = (variable)
2436 htab_find_with_hash (vars, dv, dv_htab_hash (dv));
2440 location_chain where;
2441 VALUE_RECURSED_INTO (node->loc) = true;
2442 if ((where = find_loc_in_1pdv (loc, var, vars)))
2444 VALUE_RECURSED_INTO (node->loc) = false;
2447 VALUE_RECURSED_INTO (node->loc) = false;
2454 /* Hash table iteration argument passed to variable_merge. */
2457 /* The set in which the merge is to be inserted. */
2459 /* The set that we're iterating in. */
2461 /* The set that may contain the other dv we are to merge with. */
2463 /* Number of onepart dvs in src. */
2464 int src_onepart_cnt;
2467 /* Insert LOC in *DNODE, if it's not there yet. The list must be in
2468 loc_cmp order, and it is maintained as such. */
2471 insert_into_intersection (location_chain *nodep, rtx loc,
2472 enum var_init_status status)
2474 location_chain node;
2477 for (node = *nodep; node; nodep = &node->next, node = *nodep)
2478 if ((r = loc_cmp (node->loc, loc)) == 0)
2480 node->init = MIN (node->init, status);
2486 node = (location_chain) pool_alloc (loc_chain_pool);
2489 node->set_src = NULL;
2490 node->init = status;
2491 node->next = *nodep;
2495 /* Insert in DEST the intersection the locations present in both
2496 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
2497 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
2501 intersect_loc_chains (rtx val, location_chain *dest, struct dfset_merge *dsm,
2502 location_chain s1node, variable s2var)
2504 dataflow_set *s1set = dsm->cur;
2505 dataflow_set *s2set = dsm->src;
2506 location_chain found;
2508 for (; s1node; s1node = s1node->next)
2510 if (s1node->loc == val)
2513 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
2514 shared_hash_htab (s2set->vars))))
2516 insert_into_intersection (dest, s1node->loc,
2517 MIN (s1node->init, found->init));
2521 if (GET_CODE (s1node->loc) == VALUE
2522 && !VALUE_RECURSED_INTO (s1node->loc))
2524 decl_or_value dv = dv_from_value (s1node->loc);
2525 variable svar = shared_hash_find (s1set->vars, dv);
2528 if (svar->n_var_parts == 1)
2530 VALUE_RECURSED_INTO (s1node->loc) = true;
2531 intersect_loc_chains (val, dest, dsm,
2532 svar->var_part[0].loc_chain,
2534 VALUE_RECURSED_INTO (s1node->loc) = false;
2539 /* ??? if the location is equivalent to any location in src,
2540 searched recursively
2542 add to dst the values needed to represent the equivalence
2544 telling whether locations S is equivalent to another dv's
2547 for each location D in the list
2549 if S and D satisfy rtx_equal_p, then it is present
2551 else if D is a value, recurse without cycles
2553 else if S and D have the same CODE and MODE
2555 for each operand oS and the corresponding oD
2557 if oS and oD are not equivalent, then S an D are not equivalent
2559 else if they are RTX vectors
2561 if any vector oS element is not equivalent to its respective oD,
2562 then S and D are not equivalent
2570 /* Return -1 if X should be before Y in a location list for a 1-part
2571 variable, 1 if Y should be before X, and 0 if they're equivalent
2572 and should not appear in the list. */
2575 loc_cmp (rtx x, rtx y)
2578 RTX_CODE code = GET_CODE (x);
2588 gcc_assert (GET_MODE (x) == GET_MODE (y));
2589 if (REGNO (x) == REGNO (y))
2591 else if (REGNO (x) < REGNO (y))
2604 gcc_assert (GET_MODE (x) == GET_MODE (y));
2605 return loc_cmp (XEXP (x, 0), XEXP (y, 0));
2611 if (GET_CODE (x) == VALUE)
2613 if (GET_CODE (y) != VALUE)
2615 /* Don't assert the modes are the same, that is true only
2616 when not recursing. (subreg:QI (value:SI 1:1) 0)
2617 and (subreg:QI (value:DI 2:2) 0) can be compared,
2618 even when the modes are different. */
2619 if (canon_value_cmp (x, y))
2625 if (GET_CODE (y) == VALUE)
2628 if (GET_CODE (x) == GET_CODE (y))
2629 /* Compare operands below. */;
2630 else if (GET_CODE (x) < GET_CODE (y))
2635 gcc_assert (GET_MODE (x) == GET_MODE (y));
2637 if (GET_CODE (x) == DEBUG_EXPR)
2639 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
2640 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))
2642 #ifdef ENABLE_CHECKING
2643 gcc_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))
2644 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)));
2649 fmt = GET_RTX_FORMAT (code);
2650 for (i = 0; i < GET_RTX_LENGTH (code); i++)
2654 if (XWINT (x, i) == XWINT (y, i))
2656 else if (XWINT (x, i) < XWINT (y, i))
2663 if (XINT (x, i) == XINT (y, i))
2665 else if (XINT (x, i) < XINT (y, i))
2672 /* Compare the vector length first. */
2673 if (XVECLEN (x, i) == XVECLEN (y, i))
2674 /* Compare the vectors elements. */;
2675 else if (XVECLEN (x, i) < XVECLEN (y, i))
2680 for (j = 0; j < XVECLEN (x, i); j++)
2681 if ((r = loc_cmp (XVECEXP (x, i, j),
2682 XVECEXP (y, i, j))))
2687 if ((r = loc_cmp (XEXP (x, i), XEXP (y, i))))
2693 if (XSTR (x, i) == XSTR (y, i))
2699 if ((r = strcmp (XSTR (x, i), XSTR (y, i))) == 0)
2707 /* These are just backpointers, so they don't matter. */
2714 /* It is believed that rtx's at this level will never
2715 contain anything but integers and other rtx's,
2716 except for within LABEL_REFs and SYMBOL_REFs. */
2724 /* If decl or value DVP refers to VALUE from *LOC, add backlinks
2725 from VALUE to DVP. */
2728 add_value_chain (rtx *loc, void *dvp)
2730 decl_or_value dv, ldv;
2731 value_chain vc, nvc;
2734 if (GET_CODE (*loc) == VALUE)
2735 ldv = dv_from_value (*loc);
2736 else if (GET_CODE (*loc) == DEBUG_EXPR)
2737 ldv = dv_from_decl (DEBUG_EXPR_TREE_DECL (*loc));
2741 if (dv_as_opaque (ldv) == dvp)
2744 dv = (decl_or_value) dvp;
2745 slot = htab_find_slot_with_hash (value_chains, ldv, dv_htab_hash (ldv),
2749 vc = (value_chain) pool_alloc (value_chain_pool);
2753 *slot = (void *) vc;
2757 for (vc = ((value_chain) *slot)->next; vc; vc = vc->next)
2758 if (dv_as_opaque (vc->dv) == dv_as_opaque (dv))
2766 vc = (value_chain) *slot;
2767 nvc = (value_chain) pool_alloc (value_chain_pool);
2769 nvc->next = vc->next;
2775 /* If decl or value DVP refers to VALUEs from within LOC, add backlinks
2776 from those VALUEs to DVP. */
2779 add_value_chains (decl_or_value dv, rtx loc)
2781 if (GET_CODE (loc) == VALUE || GET_CODE (loc) == DEBUG_EXPR)
2783 add_value_chain (&loc, dv_as_opaque (dv));
2789 loc = XEXP (loc, 0);
2790 for_each_rtx (&loc, add_value_chain, dv_as_opaque (dv));
2793 /* If CSELIB_VAL_PTR of value DV refer to VALUEs, add backlinks from those
2797 add_cselib_value_chains (decl_or_value dv)
2799 struct elt_loc_list *l;
2801 for (l = CSELIB_VAL_PTR (dv_as_value (dv))->locs; l; l = l->next)
2802 for_each_rtx (&l->loc, add_value_chain, dv_as_opaque (dv));
2805 /* If decl or value DVP refers to VALUE from *LOC, remove backlinks
2806 from VALUE to DVP. */
2809 remove_value_chain (rtx *loc, void *dvp)
2811 decl_or_value dv, ldv;
2815 if (GET_CODE (*loc) == VALUE)
2816 ldv = dv_from_value (*loc);
2817 else if (GET_CODE (*loc) == DEBUG_EXPR)
2818 ldv = dv_from_decl (DEBUG_EXPR_TREE_DECL (*loc));
2822 if (dv_as_opaque (ldv) == dvp)
2825 dv = (decl_or_value) dvp;
2826 slot = htab_find_slot_with_hash (value_chains, ldv, dv_htab_hash (ldv),
2828 for (vc = (value_chain) *slot; vc->next; vc = vc->next)
2829 if (dv_as_opaque (vc->next->dv) == dv_as_opaque (dv))
2831 value_chain dvc = vc->next;
2832 gcc_assert (dvc->refcount > 0);
2833 if (--dvc->refcount == 0)
2835 vc->next = dvc->next;
2836 pool_free (value_chain_pool, dvc);
2837 if (vc->next == NULL && vc == (value_chain) *slot)
2839 pool_free (value_chain_pool, vc);
2840 htab_clear_slot (value_chains, slot);
2848 /* If decl or value DVP refers to VALUEs from within LOC, remove backlinks
2849 from those VALUEs to DVP. */
2852 remove_value_chains (decl_or_value dv, rtx loc)
2854 if (GET_CODE (loc) == VALUE || GET_CODE (loc) == DEBUG_EXPR)
2856 remove_value_chain (&loc, dv_as_opaque (dv));
2862 loc = XEXP (loc, 0);
2863 for_each_rtx (&loc, remove_value_chain, dv_as_opaque (dv));
2867 /* If CSELIB_VAL_PTR of value DV refer to VALUEs, remove backlinks from those
2871 remove_cselib_value_chains (decl_or_value dv)
2873 struct elt_loc_list *l;
2875 for (l = CSELIB_VAL_PTR (dv_as_value (dv))->locs; l; l = l->next)
2876 for_each_rtx (&l->loc, remove_value_chain, dv_as_opaque (dv));
2879 /* Check the order of entries in one-part variables. */
2882 canonicalize_loc_order_check (void **slot, void *data ATTRIBUTE_UNUSED)
2884 variable var = (variable) *slot;
2885 decl_or_value dv = var->dv;
2886 location_chain node, next;
2888 #ifdef ENABLE_RTL_CHECKING
2890 for (i = 0; i < var->n_var_parts; i++)
2891 gcc_assert (var->var_part[0].cur_loc == NULL);
2892 gcc_assert (!var->cur_loc_changed && !var->in_changed_variables);
2895 if (!dv_onepart_p (dv))
2898 gcc_assert (var->n_var_parts == 1);
2899 node = var->var_part[0].loc_chain;
2902 while ((next = node->next))
2904 gcc_assert (loc_cmp (node->loc, next->loc) < 0);
2912 /* Mark with VALUE_RECURSED_INTO values that have neighbors that are
2913 more likely to be chosen as canonical for an equivalence set.
2914 Ensure less likely values can reach more likely neighbors, making
2915 the connections bidirectional. */
2918 canonicalize_values_mark (void **slot, void *data)
2920 dataflow_set *set = (dataflow_set *)data;
2921 variable var = (variable) *slot;
2922 decl_or_value dv = var->dv;
2924 location_chain node;
2926 if (!dv_is_value_p (dv))
2929 gcc_assert (var->n_var_parts == 1);
2931 val = dv_as_value (dv);
2933 for (node = var->var_part[0].loc_chain; node; node = node->next)
2934 if (GET_CODE (node->loc) == VALUE)
2936 if (canon_value_cmp (node->loc, val))
2937 VALUE_RECURSED_INTO (val) = true;
2940 decl_or_value odv = dv_from_value (node->loc);
2941 void **oslot = shared_hash_find_slot_noinsert (set->vars, odv);
2943 oslot = set_slot_part (set, val, oslot, odv, 0,
2944 node->init, NULL_RTX);
2946 VALUE_RECURSED_INTO (node->loc) = true;
2953 /* Remove redundant entries from equivalence lists in onepart
2954 variables, canonicalizing equivalence sets into star shapes. */
2957 canonicalize_values_star (void **slot, void *data)
2959 dataflow_set *set = (dataflow_set *)data;
2960 variable var = (variable) *slot;
2961 decl_or_value dv = var->dv;
2962 location_chain node;
2969 if (!dv_onepart_p (dv))
2972 gcc_assert (var->n_var_parts == 1);
2974 if (dv_is_value_p (dv))
2976 cval = dv_as_value (dv);
2977 if (!VALUE_RECURSED_INTO (cval))
2979 VALUE_RECURSED_INTO (cval) = false;
2989 gcc_assert (var->n_var_parts == 1);
2991 for (node = var->var_part[0].loc_chain; node; node = node->next)
2992 if (GET_CODE (node->loc) == VALUE)
2995 if (VALUE_RECURSED_INTO (node->loc))
2997 if (canon_value_cmp (node->loc, cval))
3006 if (!has_marks || dv_is_decl_p (dv))
3009 /* Keep it marked so that we revisit it, either after visiting a
3010 child node, or after visiting a new parent that might be
3012 VALUE_RECURSED_INTO (val) = true;
3014 for (node = var->var_part[0].loc_chain; node; node = node->next)
3015 if (GET_CODE (node->loc) == VALUE
3016 && VALUE_RECURSED_INTO (node->loc))
3020 VALUE_RECURSED_INTO (cval) = false;
3021 dv = dv_from_value (cval);
3022 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3025 gcc_assert (dv_is_decl_p (var->dv));
3026 /* The canonical value was reset and dropped.
3028 clobber_variable_part (set, NULL, var->dv, 0, NULL);
3031 var = (variable)*slot;
3032 gcc_assert (dv_is_value_p (var->dv));
3033 if (var->n_var_parts == 0)
3035 gcc_assert (var->n_var_parts == 1);
3039 VALUE_RECURSED_INTO (val) = false;
3044 /* Push values to the canonical one. */
3045 cdv = dv_from_value (cval);
3046 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3048 for (node = var->var_part[0].loc_chain; node; node = node->next)
3049 if (node->loc != cval)
3051 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3052 node->init, NULL_RTX);
3053 if (GET_CODE (node->loc) == VALUE)
3055 decl_or_value ndv = dv_from_value (node->loc);
3057 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX,
3060 if (canon_value_cmp (node->loc, val))
3062 /* If it could have been a local minimum, it's not any more,
3063 since it's now neighbor to cval, so it may have to push
3064 to it. Conversely, if it wouldn't have prevailed over
3065 val, then whatever mark it has is fine: if it was to
3066 push, it will now push to a more canonical node, but if
3067 it wasn't, then it has already pushed any values it might
3069 VALUE_RECURSED_INTO (node->loc) = true;
3070 /* Make sure we visit node->loc by ensuring we cval is
3072 VALUE_RECURSED_INTO (cval) = true;
3074 else if (!VALUE_RECURSED_INTO (node->loc))
3075 /* If we have no need to "recurse" into this node, it's
3076 already "canonicalized", so drop the link to the old
3078 clobber_variable_part (set, cval, ndv, 0, NULL);
3080 else if (GET_CODE (node->loc) == REG)
3082 attrs list = set->regs[REGNO (node->loc)], *listp;
3084 /* Change an existing attribute referring to dv so that it
3085 refers to cdv, removing any duplicate this might
3086 introduce, and checking that no previous duplicates
3087 existed, all in a single pass. */
3091 if (list->offset == 0
3092 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3093 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3100 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3103 for (listp = &list->next; (list = *listp); listp = &list->next)
3108 if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3110 *listp = list->next;
3111 pool_free (attrs_pool, list);
3116 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (dv));
3119 else if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3121 for (listp = &list->next; (list = *listp); listp = &list->next)
3126 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3128 *listp = list->next;
3129 pool_free (attrs_pool, list);
3134 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (cdv));
3143 if (list->offset == 0
3144 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3145 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3155 cslot = set_slot_part (set, val, cslot, cdv, 0,
3156 VAR_INIT_STATUS_INITIALIZED, NULL_RTX);
3158 slot = clobber_slot_part (set, cval, slot, 0, NULL);
3160 /* Variable may have been unshared. */
3161 var = (variable)*slot;
3162 gcc_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval
3163 && var->var_part[0].loc_chain->next == NULL);
3165 if (VALUE_RECURSED_INTO (cval))
3166 goto restart_with_cval;
3171 /* Combine variable or value in *S1SLOT (in DSM->cur) with the
3172 corresponding entry in DSM->src. Multi-part variables are combined
3173 with variable_union, whereas onepart dvs are combined with
3177 variable_merge_over_cur (void **s1slot, void *data)
3179 struct dfset_merge *dsm = (struct dfset_merge *)data;
3180 dataflow_set *dst = dsm->dst;
3182 variable s1var = (variable) *s1slot;
3183 variable s2var, dvar = NULL;
3184 decl_or_value dv = s1var->dv;
3185 bool onepart = dv_onepart_p (dv);
3188 location_chain node, *nodep;
3190 /* If the incoming onepart variable has an empty location list, then
3191 the intersection will be just as empty. For other variables,
3192 it's always union. */
3193 gcc_assert (s1var->n_var_parts);
3194 gcc_assert (s1var->var_part[0].loc_chain);
3197 return variable_union (s1slot, dst);
3199 gcc_assert (s1var->n_var_parts == 1);
3200 gcc_assert (s1var->var_part[0].offset == 0);
3202 dvhash = dv_htab_hash (dv);
3203 if (dv_is_value_p (dv))
3204 val = dv_as_value (dv);
3208 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
3211 dst_can_be_shared = false;
3215 dsm->src_onepart_cnt--;
3216 gcc_assert (s2var->var_part[0].loc_chain);
3217 gcc_assert (s2var->n_var_parts == 1);
3218 gcc_assert (s2var->var_part[0].offset == 0);
3220 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3223 dvar = (variable)*dstslot;
3224 gcc_assert (dvar->refcount == 1);
3225 gcc_assert (dvar->n_var_parts == 1);
3226 gcc_assert (dvar->var_part[0].offset == 0);
3227 nodep = &dvar->var_part[0].loc_chain;
3235 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
3237 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
3239 *dstslot = dvar = s2var;
3244 dst_can_be_shared = false;
3246 intersect_loc_chains (val, nodep, dsm,
3247 s1var->var_part[0].loc_chain, s2var);
3253 dvar = (variable) pool_alloc (dv_pool (dv));
3256 dvar->n_var_parts = 1;
3257 dvar->cur_loc_changed = false;
3258 dvar->in_changed_variables = false;
3259 dvar->var_part[0].offset = 0;
3260 dvar->var_part[0].loc_chain = node;
3261 dvar->var_part[0].cur_loc = NULL;
3264 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
3266 gcc_assert (!*dstslot);
3274 nodep = &dvar->var_part[0].loc_chain;
3275 while ((node = *nodep))
3277 location_chain *nextp = &node->next;
3279 if (GET_CODE (node->loc) == REG)
3283 for (list = dst->regs[REGNO (node->loc)]; list; list = list->next)
3284 if (GET_MODE (node->loc) == GET_MODE (list->loc)
3285 && dv_is_value_p (list->dv))
3289 attrs_list_insert (&dst->regs[REGNO (node->loc)],
3291 /* If this value became canonical for another value that had
3292 this register, we want to leave it alone. */
3293 else if (dv_as_value (list->dv) != val)
3295 dstslot = set_slot_part (dst, dv_as_value (list->dv),
3297 node->init, NULL_RTX);
3298 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
3300 /* Since nextp points into the removed node, we can't
3301 use it. The pointer to the next node moved to nodep.
3302 However, if the variable we're walking is unshared
3303 during our walk, we'll keep walking the location list
3304 of the previously-shared variable, in which case the
3305 node won't have been removed, and we'll want to skip
3306 it. That's why we test *nodep here. */
3312 /* Canonicalization puts registers first, so we don't have to
3318 if (dvar != (variable)*dstslot)
3319 dvar = (variable)*dstslot;
3320 nodep = &dvar->var_part[0].loc_chain;
3324 /* Mark all referenced nodes for canonicalization, and make sure
3325 we have mutual equivalence links. */
3326 VALUE_RECURSED_INTO (val) = true;
3327 for (node = *nodep; node; node = node->next)
3328 if (GET_CODE (node->loc) == VALUE)
3330 VALUE_RECURSED_INTO (node->loc) = true;
3331 set_variable_part (dst, val, dv_from_value (node->loc), 0,
3332 node->init, NULL, INSERT);
3335 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3336 gcc_assert (*dstslot == dvar);
3337 canonicalize_values_star (dstslot, dst);
3338 #ifdef ENABLE_CHECKING
3340 == shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash));
3342 dvar = (variable)*dstslot;
3346 bool has_value = false, has_other = false;
3348 /* If we have one value and anything else, we're going to
3349 canonicalize this, so make sure all values have an entry in
3350 the table and are marked for canonicalization. */
3351 for (node = *nodep; node; node = node->next)
3353 if (GET_CODE (node->loc) == VALUE)
3355 /* If this was marked during register canonicalization,
3356 we know we have to canonicalize values. */
3371 if (has_value && has_other)
3373 for (node = *nodep; node; node = node->next)
3375 if (GET_CODE (node->loc) == VALUE)
3377 decl_or_value dv = dv_from_value (node->loc);
3380 if (shared_hash_shared (dst->vars))
3381 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
3383 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
3387 variable var = (variable) pool_alloc (dv_pool (dv));
3390 var->n_var_parts = 1;
3391 var->cur_loc_changed = false;
3392 var->in_changed_variables = false;
3393 var->var_part[0].offset = 0;
3394 var->var_part[0].loc_chain = NULL;
3395 var->var_part[0].cur_loc = NULL;
3399 VALUE_RECURSED_INTO (node->loc) = true;
3403 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
3404 gcc_assert (*dstslot == dvar);
3405 canonicalize_values_star (dstslot, dst);
3406 #ifdef ENABLE_CHECKING
3408 == shared_hash_find_slot_noinsert_1 (dst->vars,
3411 dvar = (variable)*dstslot;
3415 if (!onepart_variable_different_p (dvar, s2var))
3417 variable_htab_free (dvar);
3418 *dstslot = dvar = s2var;
3421 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
3423 variable_htab_free (dvar);
3424 *dstslot = dvar = s1var;
3426 dst_can_be_shared = false;
3429 dst_can_be_shared = false;
3434 /* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
3435 multi-part variable. Unions of multi-part variables and
3436 intersections of one-part ones will be handled in
3437 variable_merge_over_cur(). */
3440 variable_merge_over_src (void **s2slot, void *data)
3442 struct dfset_merge *dsm = (struct dfset_merge *)data;
3443 dataflow_set *dst = dsm->dst;
3444 variable s2var = (variable) *s2slot;
3445 decl_or_value dv = s2var->dv;
3446 bool onepart = dv_onepart_p (dv);
3450 void **dstp = shared_hash_find_slot (dst->vars, dv);
3456 dsm->src_onepart_cnt++;
3460 /* Combine dataflow set information from SRC2 into DST, using PDST
3461 to carry over information across passes. */
3464 dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
3466 dataflow_set cur = *dst;
3467 dataflow_set *src1 = &cur;
3468 struct dfset_merge dsm;
3470 size_t src1_elems, src2_elems;
3472 src1_elems = htab_elements (shared_hash_htab (src1->vars));
3473 src2_elems = htab_elements (shared_hash_htab (src2->vars));
3474 dataflow_set_init (dst);
3475 dst->stack_adjust = cur.stack_adjust;
3476 shared_hash_destroy (dst->vars);
3477 dst->vars = (shared_hash) pool_alloc (shared_hash_pool);
3478 dst->vars->refcount = 1;
3480 = htab_create (MAX (src1_elems, src2_elems), variable_htab_hash,
3481 variable_htab_eq, variable_htab_free);
3483 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3484 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
3489 dsm.src_onepart_cnt = 0;
3491 htab_traverse (shared_hash_htab (dsm.src->vars), variable_merge_over_src,
3493 htab_traverse (shared_hash_htab (dsm.cur->vars), variable_merge_over_cur,
3496 if (dsm.src_onepart_cnt)
3497 dst_can_be_shared = false;
3499 dataflow_set_destroy (src1);
3502 /* Mark register equivalences. */
3505 dataflow_set_equiv_regs (dataflow_set *set)
3510 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3512 rtx canon[NUM_MACHINE_MODES];
3514 memset (canon, 0, sizeof (canon));
3516 for (list = set->regs[i]; list; list = list->next)
3517 if (list->offset == 0 && dv_is_value_p (list->dv))
3519 rtx val = dv_as_value (list->dv);
3520 rtx *cvalp = &canon[(int)GET_MODE (val)];
3523 if (canon_value_cmp (val, cval))
3527 for (list = set->regs[i]; list; list = list->next)
3528 if (list->offset == 0 && dv_onepart_p (list->dv))
3530 rtx cval = canon[(int)GET_MODE (list->loc)];
3535 if (dv_is_value_p (list->dv))
3537 rtx val = dv_as_value (list->dv);
3542 VALUE_RECURSED_INTO (val) = true;
3543 set_variable_part (set, val, dv_from_value (cval), 0,
3544 VAR_INIT_STATUS_INITIALIZED,
3548 VALUE_RECURSED_INTO (cval) = true;
3549 set_variable_part (set, cval, list->dv, 0,
3550 VAR_INIT_STATUS_INITIALIZED, NULL, NO_INSERT);
3553 for (listp = &set->regs[i]; (list = *listp);
3554 listp = list ? &list->next : listp)
3555 if (list->offset == 0 && dv_onepart_p (list->dv))
3557 rtx cval = canon[(int)GET_MODE (list->loc)];
3563 if (dv_is_value_p (list->dv))
3565 rtx val = dv_as_value (list->dv);
3566 if (!VALUE_RECURSED_INTO (val))
3570 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
3571 canonicalize_values_star (slot, set);
3578 /* Remove any redundant values in the location list of VAR, which must
3579 be unshared and 1-part. */
3582 remove_duplicate_values (variable var)
3584 location_chain node, *nodep;
3586 gcc_assert (dv_onepart_p (var->dv));
3587 gcc_assert (var->n_var_parts == 1);
3588 gcc_assert (var->refcount == 1);
3590 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
3592 if (GET_CODE (node->loc) == VALUE)
3594 if (VALUE_RECURSED_INTO (node->loc))
3596 /* Remove duplicate value node. */
3597 *nodep = node->next;
3598 pool_free (loc_chain_pool, node);
3602 VALUE_RECURSED_INTO (node->loc) = true;
3604 nodep = &node->next;
3607 for (node = var->var_part[0].loc_chain; node; node = node->next)
3608 if (GET_CODE (node->loc) == VALUE)
3610 gcc_assert (VALUE_RECURSED_INTO (node->loc));
3611 VALUE_RECURSED_INTO (node->loc) = false;
3616 /* Hash table iteration argument passed to variable_post_merge. */
3617 struct dfset_post_merge
3619 /* The new input set for the current block. */
3621 /* Pointer to the permanent input set for the current block, or
3623 dataflow_set **permp;
3626 /* Create values for incoming expressions associated with one-part
3627 variables that don't have value numbers for them. */
3630 variable_post_merge_new_vals (void **slot, void *info)
3632 struct dfset_post_merge *dfpm = (struct dfset_post_merge *)info;
3633 dataflow_set *set = dfpm->set;
3634 variable var = (variable)*slot;
3635 location_chain node;
3637 if (!dv_onepart_p (var->dv) || !var->n_var_parts)
3640 gcc_assert (var->n_var_parts == 1);
3642 if (dv_is_decl_p (var->dv))
3644 bool check_dupes = false;
3647 for (node = var->var_part[0].loc_chain; node; node = node->next)
3649 if (GET_CODE (node->loc) == VALUE)
3650 gcc_assert (!VALUE_RECURSED_INTO (node->loc));
3651 else if (GET_CODE (node->loc) == REG)
3653 attrs att, *attp, *curp = NULL;
3655 if (var->refcount != 1)
3657 slot = unshare_variable (set, slot, var,
3658 VAR_INIT_STATUS_INITIALIZED);
3659 var = (variable)*slot;
3663 for (attp = &set->regs[REGNO (node->loc)]; (att = *attp);
3665 if (att->offset == 0
3666 && GET_MODE (att->loc) == GET_MODE (node->loc))
3668 if (dv_is_value_p (att->dv))
3670 rtx cval = dv_as_value (att->dv);
3675 else if (dv_as_opaque (att->dv) == dv_as_opaque (var->dv))
3683 if ((*curp)->offset == 0
3684 && GET_MODE ((*curp)->loc) == GET_MODE (node->loc)
3685 && dv_as_opaque ((*curp)->dv) == dv_as_opaque (var->dv))
3688 curp = &(*curp)->next;
3699 *dfpm->permp = XNEW (dataflow_set);
3700 dataflow_set_init (*dfpm->permp);
3703 for (att = (*dfpm->permp)->regs[REGNO (node->loc)];
3704 att; att = att->next)
3705 if (GET_MODE (att->loc) == GET_MODE (node->loc))
3707 gcc_assert (att->offset == 0);
3708 gcc_assert (dv_is_value_p (att->dv));
3709 val_reset (set, att->dv);
3716 cval = dv_as_value (cdv);
3720 /* Create a unique value to hold this register,
3721 that ought to be found and reused in
3722 subsequent rounds. */
3724 gcc_assert (!cselib_lookup (node->loc,
3725 GET_MODE (node->loc), 0));
3726 v = cselib_lookup (node->loc, GET_MODE (node->loc), 1);
3727 cselib_preserve_value (v);
3728 cselib_invalidate_rtx (node->loc);
3730 cdv = dv_from_value (cval);
3733 "Created new value %u:%u for reg %i\n",
3734 v->uid, v->hash, REGNO (node->loc));
3737 var_reg_decl_set (*dfpm->permp, node->loc,
3738 VAR_INIT_STATUS_INITIALIZED,
3739 cdv, 0, NULL, INSERT);
3745 /* Remove attribute referring to the decl, which now
3746 uses the value for the register, already existing or
3747 to be added when we bring perm in. */
3750 pool_free (attrs_pool, att);
3755 remove_duplicate_values (var);
3761 /* Reset values in the permanent set that are not associated with the
3762 chosen expression. */
3765 variable_post_merge_perm_vals (void **pslot, void *info)
3767 struct dfset_post_merge *dfpm = (struct dfset_post_merge *)info;
3768 dataflow_set *set = dfpm->set;
3769 variable pvar = (variable)*pslot, var;
3770 location_chain pnode;
3774 gcc_assert (dv_is_value_p (pvar->dv));
3775 gcc_assert (pvar->n_var_parts == 1);
3776 pnode = pvar->var_part[0].loc_chain;
3778 gcc_assert (!pnode->next);
3779 gcc_assert (REG_P (pnode->loc));
3783 var = shared_hash_find (set->vars, dv);
3786 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
3788 val_reset (set, dv);
3791 for (att = set->regs[REGNO (pnode->loc)]; att; att = att->next)
3792 if (att->offset == 0
3793 && GET_MODE (att->loc) == GET_MODE (pnode->loc)
3794 && dv_is_value_p (att->dv))
3797 /* If there is a value associated with this register already, create
3799 if (att && dv_as_value (att->dv) != dv_as_value (dv))
3801 rtx cval = dv_as_value (att->dv);
3802 set_variable_part (set, cval, dv, 0, pnode->init, NULL, INSERT);
3803 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
3808 attrs_list_insert (&set->regs[REGNO (pnode->loc)],
3810 variable_union (pslot, set);
3816 /* Just checking stuff and registering register attributes for
3820 dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
3822 struct dfset_post_merge dfpm;
3827 htab_traverse (shared_hash_htab (set->vars), variable_post_merge_new_vals,
3830 htab_traverse (shared_hash_htab ((*permp)->vars),
3831 variable_post_merge_perm_vals, &dfpm);
3832 htab_traverse (shared_hash_htab (set->vars), canonicalize_values_star, set);
3835 /* Return a node whose loc is a MEM that refers to EXPR in the
3836 location list of a one-part variable or value VAR, or in that of
3837 any values recursively mentioned in the location lists. */
3839 static location_chain
3840 find_mem_expr_in_1pdv (tree expr, rtx val, htab_t vars)
3842 location_chain node;
3845 location_chain where = NULL;
3850 gcc_assert (GET_CODE (val) == VALUE);
3852 gcc_assert (!VALUE_RECURSED_INTO (val));
3854 dv = dv_from_value (val);
3855 var = (variable) htab_find_with_hash (vars, dv, dv_htab_hash (dv));
3860 gcc_assert (dv_onepart_p (var->dv));
3862 if (!var->n_var_parts)
3865 gcc_assert (var->var_part[0].offset == 0);
3867 VALUE_RECURSED_INTO (val) = true;
3869 for (node = var->var_part[0].loc_chain; node; node = node->next)
3870 if (MEM_P (node->loc) && MEM_EXPR (node->loc) == expr
3871 && MEM_OFFSET (node->loc) == 0)
3876 else if (GET_CODE (node->loc) == VALUE
3877 && !VALUE_RECURSED_INTO (node->loc)
3878 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
3881 VALUE_RECURSED_INTO (val) = false;
3886 /* Return TRUE if the value of MEM may vary across a call. */
3889 mem_dies_at_call (rtx mem)
3891 tree expr = MEM_EXPR (mem);
3897 decl = get_base_address (expr);
3905 return (may_be_aliased (decl)
3906 || (!TREE_READONLY (decl) && is_global_var (decl)));
3909 /* Remove all MEMs from the location list of a hash table entry for a
3910 one-part variable, except those whose MEM attributes map back to
3911 the variable itself, directly or within a VALUE. */
3914 dataflow_set_preserve_mem_locs (void **slot, void *data)
3916 dataflow_set *set = (dataflow_set *) data;
3917 variable var = (variable) *slot;
3919 if (dv_is_decl_p (var->dv) && dv_onepart_p (var->dv))
3921 tree decl = dv_as_decl (var->dv);
3922 location_chain loc, *locp;
3923 bool changed = false;
3925 if (!var->n_var_parts)
3928 gcc_assert (var->n_var_parts == 1);
3930 if (shared_var_p (var, set->vars))
3932 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
3934 /* We want to remove dying MEMs that doesn't refer to
3936 if (GET_CODE (loc->loc) == MEM
3937 && (MEM_EXPR (loc->loc) != decl
3938 || MEM_OFFSET (loc->loc))
3939 && !mem_dies_at_call (loc->loc))
3941 /* We want to move here MEMs that do refer to DECL. */
3942 else if (GET_CODE (loc->loc) == VALUE
3943 && find_mem_expr_in_1pdv (decl, loc->loc,
3944 shared_hash_htab (set->vars)))
3951 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
3952 var = (variable)*slot;
3953 gcc_assert (var->n_var_parts == 1);
3956 for (locp = &var->var_part[0].loc_chain, loc = *locp;
3959 rtx old_loc = loc->loc;
3960 if (GET_CODE (old_loc) == VALUE)
3962 location_chain mem_node
3963 = find_mem_expr_in_1pdv (decl, loc->loc,
3964 shared_hash_htab (set->vars));
3966 /* ??? This picks up only one out of multiple MEMs that
3967 refer to the same variable. Do we ever need to be
3968 concerned about dealing with more than one, or, given
3969 that they should all map to the same variable
3970 location, their addresses will have been merged and
3971 they will be regarded as equivalent? */
3974 loc->loc = mem_node->loc;
3975 loc->set_src = mem_node->set_src;
3976 loc->init = MIN (loc->init, mem_node->init);
3980 if (GET_CODE (loc->loc) != MEM
3981 || (MEM_EXPR (loc->loc) == decl
3982 && MEM_OFFSET (loc->loc) == 0)
3983 || !mem_dies_at_call (loc->loc))
3985 if (old_loc != loc->loc && emit_notes)
3987 if (old_loc == var->var_part[0].cur_loc)
3990 var->var_part[0].cur_loc = NULL;
3991 var->cur_loc_changed = true;
3993 add_value_chains (var->dv, loc->loc);
3994 remove_value_chains (var->dv, old_loc);
4002 remove_value_chains (var->dv, old_loc);
4003 if (old_loc == var->var_part[0].cur_loc)
4006 var->var_part[0].cur_loc = NULL;
4007 var->cur_loc_changed = true;
4011 pool_free (loc_chain_pool, loc);
4014 if (!var->var_part[0].loc_chain)
4020 variable_was_changed (var, set);
4026 /* Remove all MEMs from the location list of a hash table entry for a
4030 dataflow_set_remove_mem_locs (void **slot, void *data)
4032 dataflow_set *set = (dataflow_set *) data;
4033 variable var = (variable) *slot;
4035 if (dv_is_value_p (var->dv))
4037 location_chain loc, *locp;
4038 bool changed = false;
4040 gcc_assert (var->n_var_parts == 1);
4042 if (shared_var_p (var, set->vars))
4044 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4045 if (GET_CODE (loc->loc) == MEM
4046 && mem_dies_at_call (loc->loc))
4052 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4053 var = (variable)*slot;
4054 gcc_assert (var->n_var_parts == 1);
4057 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4060 if (GET_CODE (loc->loc) != MEM
4061 || !mem_dies_at_call (loc->loc))
4068 remove_value_chains (var->dv, loc->loc);
4070 /* If we have deleted the location which was last emitted
4071 we have to emit new location so add the variable to set
4072 of changed variables. */
4073 if (var->var_part[0].cur_loc == loc->loc)
4076 var->var_part[0].cur_loc = NULL;
4077 var->cur_loc_changed = true;
4079 pool_free (loc_chain_pool, loc);
4082 if (!var->var_part[0].loc_chain)
4088 variable_was_changed (var, set);
4094 /* Remove all variable-location information about call-clobbered
4095 registers, as well as associations between MEMs and VALUEs. */
4098 dataflow_set_clear_at_call (dataflow_set *set)
4102 for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
4103 if (TEST_HARD_REG_BIT (call_used_reg_set, r))
4104 var_regno_delete (set, r);
4106 if (MAY_HAVE_DEBUG_INSNS)
4108 set->traversed_vars = set->vars;
4109 htab_traverse (shared_hash_htab (set->vars),
4110 dataflow_set_preserve_mem_locs, set);
4111 set->traversed_vars = set->vars;
4112 htab_traverse (shared_hash_htab (set->vars), dataflow_set_remove_mem_locs,
4114 set->traversed_vars = NULL;
4118 /* Flag whether two dataflow sets being compared contain different data. */
4120 dataflow_set_different_value;
4123 variable_part_different_p (variable_part *vp1, variable_part *vp2)
4125 location_chain lc1, lc2;
4127 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4129 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4131 if (REG_P (lc1->loc) && REG_P (lc2->loc))
4133 if (REGNO (lc1->loc) == REGNO (lc2->loc))
4136 if (rtx_equal_p (lc1->loc, lc2->loc))
4145 /* Return true if one-part variables VAR1 and VAR2 are different.
4146 They must be in canonical order. */
4149 onepart_variable_different_p (variable var1, variable var2)
4151 location_chain lc1, lc2;
4156 gcc_assert (var1->n_var_parts == 1);
4157 gcc_assert (var2->n_var_parts == 1);
4159 lc1 = var1->var_part[0].loc_chain;
4160 lc2 = var2->var_part[0].loc_chain;
4167 if (loc_cmp (lc1->loc, lc2->loc))
4176 /* Return true if variables VAR1 and VAR2 are different. */
4179 variable_different_p (variable var1, variable var2)
4186 if (var1->n_var_parts != var2->n_var_parts)
4189 for (i = 0; i < var1->n_var_parts; i++)
4191 if (var1->var_part[i].offset != var2->var_part[i].offset)
4193 /* One-part values have locations in a canonical order. */
4194 if (i == 0 && var1->var_part[i].offset == 0 && dv_onepart_p (var1->dv))
4196 gcc_assert (var1->n_var_parts == 1);
4197 gcc_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv));
4198 return onepart_variable_different_p (var1, var2);
4200 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
4202 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
4208 /* Compare variable *SLOT with the same variable in hash table DATA
4209 and set DATAFLOW_SET_DIFFERENT_VALUE if they are different. */
4212 dataflow_set_different_1 (void **slot, void *data)
4214 htab_t htab = (htab_t) data;
4215 variable var1, var2;
4217 var1 = (variable) *slot;
4218 var2 = (variable) htab_find_with_hash (htab, var1->dv,
4219 dv_htab_hash (var1->dv));
4222 dataflow_set_different_value = true;
4224 if (dump_file && (dump_flags & TDF_DETAILS))
4226 fprintf (dump_file, "dataflow difference found: removal of:\n");
4230 /* Stop traversing the hash table. */
4234 if (variable_different_p (var1, var2))
4236 dataflow_set_different_value = true;
4238 if (dump_file && (dump_flags & TDF_DETAILS))
4240 fprintf (dump_file, "dataflow difference found: old and new follow:\n");
4245 /* Stop traversing the hash table. */
4249 /* Continue traversing the hash table. */
4253 /* Return true if dataflow sets OLD_SET and NEW_SET differ. */
4256 dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
4258 if (old_set->vars == new_set->vars)
4261 if (htab_elements (shared_hash_htab (old_set->vars))
4262 != htab_elements (shared_hash_htab (new_set->vars)))
4265 dataflow_set_different_value = false;
4267 htab_traverse (shared_hash_htab (old_set->vars), dataflow_set_different_1,
4268 shared_hash_htab (new_set->vars));
4269 /* No need to traverse the second hashtab, if both have the same number
4270 of elements and the second one had all entries found in the first one,
4271 then it can't have any extra entries. */
4272 return dataflow_set_different_value;
4275 /* Free the contents of dataflow set SET. */
4278 dataflow_set_destroy (dataflow_set *set)
4282 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4283 attrs_list_clear (&set->regs[i]);
4285 shared_hash_destroy (set->vars);
4289 /* Return true if RTL X contains a SYMBOL_REF. */
4292 contains_symbol_ref (rtx x)
4301 code = GET_CODE (x);
4302 if (code == SYMBOL_REF)
4305 fmt = GET_RTX_FORMAT (code);
4306 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4310 if (contains_symbol_ref (XEXP (x, i)))
4313 else if (fmt[i] == 'E')
4316 for (j = 0; j < XVECLEN (x, i); j++)
4317 if (contains_symbol_ref (XVECEXP (x, i, j)))
4325 /* Shall EXPR be tracked? */
4328 track_expr_p (tree expr, bool need_rtl)
4333 if (TREE_CODE (expr) == DEBUG_EXPR_DECL)
4334 return DECL_RTL_SET_P (expr);
4336 /* If EXPR is not a parameter or a variable do not track it. */
4337 if (TREE_CODE (expr) != VAR_DECL && TREE_CODE (expr) != PARM_DECL)
4340 /* It also must have a name... */
4341 if (!DECL_NAME (expr) && need_rtl)
4344 /* ... and a RTL assigned to it. */
4345 decl_rtl = DECL_RTL_IF_SET (expr);
4346 if (!decl_rtl && need_rtl)
4349 /* If this expression is really a debug alias of some other declaration, we
4350 don't need to track this expression if the ultimate declaration is
4353 if (DECL_DEBUG_EXPR_IS_FROM (realdecl) && DECL_DEBUG_EXPR (realdecl))
4355 realdecl = DECL_DEBUG_EXPR (realdecl);
4356 /* ??? We don't yet know how to emit DW_OP_piece for variable
4357 that has been SRA'ed. */
4358 if (!DECL_P (realdecl))
4362 /* Do not track EXPR if REALDECL it should be ignored for debugging
4364 if (DECL_IGNORED_P (realdecl))
4367 /* Do not track global variables until we are able to emit correct location
4369 if (TREE_STATIC (realdecl))
4372 /* When the EXPR is a DECL for alias of some variable (see example)
4373 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
4374 DECL_RTL contains SYMBOL_REF.
4377 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
4380 if (decl_rtl && MEM_P (decl_rtl)
4381 && contains_symbol_ref (XEXP (decl_rtl, 0)))
4384 /* If RTX is a memory it should not be very large (because it would be
4385 an array or struct). */
4386 if (decl_rtl && MEM_P (decl_rtl))
4388 /* Do not track structures and arrays. */
4389 if (GET_MODE (decl_rtl) == BLKmode
4390 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
4392 if (MEM_SIZE (decl_rtl)
4393 && INTVAL (MEM_SIZE (decl_rtl)) > MAX_VAR_PARTS)
4397 DECL_CHANGED (expr) = 0;
4398 DECL_CHANGED (realdecl) = 0;
4402 /* Determine whether a given LOC refers to the same variable part as
4406 same_variable_part_p (rtx loc, tree expr, HOST_WIDE_INT offset)
4409 HOST_WIDE_INT offset2;
4411 if (! DECL_P (expr))
4416 expr2 = REG_EXPR (loc);
4417 offset2 = REG_OFFSET (loc);
4419 else if (MEM_P (loc))
4421 expr2 = MEM_EXPR (loc);
4422 offset2 = INT_MEM_OFFSET (loc);
4427 if (! expr2 || ! DECL_P (expr2))
4430 expr = var_debug_decl (expr);
4431 expr2 = var_debug_decl (expr2);
4433 return (expr == expr2 && offset == offset2);
4436 /* LOC is a REG or MEM that we would like to track if possible.
4437 If EXPR is null, we don't know what expression LOC refers to,
4438 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
4439 LOC is an lvalue register.
4441 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
4442 is something we can track. When returning true, store the mode of
4443 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
4444 from EXPR in *OFFSET_OUT (if nonnull). */
4447 track_loc_p (rtx loc, tree expr, HOST_WIDE_INT offset, bool store_reg_p,
4448 enum machine_mode *mode_out, HOST_WIDE_INT *offset_out)
4450 enum machine_mode mode;
4452 if (expr == NULL || !track_expr_p (expr, true))
4455 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
4456 whole subreg, but only the old inner part is really relevant. */
4457 mode = GET_MODE (loc);
4458 if (REG_P (loc) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc)))
4460 enum machine_mode pseudo_mode;
4462 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc));
4463 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (pseudo_mode))
4465 offset += byte_lowpart_offset (pseudo_mode, mode);
4470 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
4471 Do the same if we are storing to a register and EXPR occupies
4472 the whole of register LOC; in that case, the whole of EXPR is
4473 being changed. We exclude complex modes from the second case
4474 because the real and imaginary parts are represented as separate
4475 pseudo registers, even if the whole complex value fits into one
4477 if ((GET_MODE_SIZE (mode) > GET_MODE_SIZE (DECL_MODE (expr))
4479 && !COMPLEX_MODE_P (DECL_MODE (expr))
4480 && hard_regno_nregs[REGNO (loc)][DECL_MODE (expr)] == 1))
4481 && offset + byte_lowpart_offset (DECL_MODE (expr), mode) == 0)
4483 mode = DECL_MODE (expr);
4487 if (offset < 0 || offset >= MAX_VAR_PARTS)
4493 *offset_out = offset;
4497 /* Return the MODE lowpart of LOC, or null if LOC is not something we
4498 want to track. When returning nonnull, make sure that the attributes
4499 on the returned value are updated. */
4502 var_lowpart (enum machine_mode mode, rtx loc)
4504 unsigned int offset, reg_offset, regno;
4506 if (!REG_P (loc) && !MEM_P (loc))
4509 if (GET_MODE (loc) == mode)
4512 offset = byte_lowpart_offset (mode, GET_MODE (loc));
4515 return adjust_address_nv (loc, mode, offset);
4517 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc));
4518 regno = REGNO (loc) + subreg_regno_offset (REGNO (loc), GET_MODE (loc),
4520 return gen_rtx_REG_offset (loc, mode, regno, offset);
4523 /* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
4524 hard_frame_pointer_rtx is being mapped to it. */
4525 static rtx cfa_base_rtx;
4527 /* Carry information about uses and stores while walking rtx. */
4529 struct count_use_info
4531 /* The insn where the RTX is. */
4534 /* The basic block where insn is. */
4537 /* The array of n_sets sets in the insn, as determined by cselib. */
4538 struct cselib_set *sets;
4541 /* True if we're counting stores, false otherwise. */
4545 /* Find a VALUE corresponding to X. */
4547 static inline cselib_val *
4548 find_use_val (rtx x, enum machine_mode mode, struct count_use_info *cui)
4554 /* This is called after uses are set up and before stores are
4555 processed bycselib, so it's safe to look up srcs, but not
4556 dsts. So we look up expressions that appear in srcs or in
4557 dest expressions, but we search the sets array for dests of
4561 for (i = 0; i < cui->n_sets; i++)
4562 if (cui->sets[i].dest == x)
4563 return cui->sets[i].src_elt;
4566 return cselib_lookup (x, mode, 0);
4572 /* Helper function to get mode of MEM's address. */
4574 static inline enum machine_mode
4575 get_address_mode (rtx mem)
4577 enum machine_mode mode = GET_MODE (XEXP (mem, 0));
4578 if (mode != VOIDmode)
4580 return targetm.addr_space.address_mode (MEM_ADDR_SPACE (mem));
4583 /* Replace all registers and addresses in an expression with VALUE
4584 expressions that map back to them, unless the expression is a
4585 register. If no mapping is or can be performed, returns NULL. */
4588 replace_expr_with_values (rtx loc)
4592 else if (MEM_P (loc))
4594 cselib_val *addr = cselib_lookup (XEXP (loc, 0),
4595 get_address_mode (loc), 0);
4597 return replace_equiv_address_nv (loc, addr->val_rtx);
4602 return cselib_subst_to_values (loc);
4605 /* Determine what kind of micro operation to choose for a USE. Return
4606 MO_CLOBBER if no micro operation is to be generated. */
4608 static enum micro_operation_type
4609 use_type (rtx loc, struct count_use_info *cui, enum machine_mode *modep)
4613 if (cui && cui->sets)
4615 if (GET_CODE (loc) == VAR_LOCATION)
4617 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc), false))
4619 rtx ploc = PAT_VAR_LOCATION_LOC (loc);
4620 if (! VAR_LOC_UNKNOWN_P (ploc))
4622 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc), 1);
4624 /* ??? flag_float_store and volatile mems are never
4625 given values, but we could in theory use them for
4627 gcc_assert (val || 1);
4635 if (REG_P (loc) || MEM_P (loc))
4638 *modep = GET_MODE (loc);
4642 || (find_use_val (loc, GET_MODE (loc), cui)
4643 && cselib_lookup (XEXP (loc, 0),
4644 get_address_mode (loc), 0)))
4649 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
4651 if (val && !cselib_preserved_value_p (val))
4659 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER);
4661 if (loc == cfa_base_rtx)
4663 expr = REG_EXPR (loc);
4666 return MO_USE_NO_VAR;
4667 else if (target_for_debug_bind (var_debug_decl (expr)))
4669 else if (track_loc_p (loc, expr, REG_OFFSET (loc),
4670 false, modep, NULL))
4673 return MO_USE_NO_VAR;
4675 else if (MEM_P (loc))
4677 expr = MEM_EXPR (loc);
4681 else if (target_for_debug_bind (var_debug_decl (expr)))
4683 else if (track_loc_p (loc, expr, INT_MEM_OFFSET (loc),
4684 false, modep, NULL))
4693 /* Log to OUT information about micro-operation MOPT involving X in
4697 log_op_type (rtx x, basic_block bb, rtx insn,
4698 enum micro_operation_type mopt, FILE *out)
4700 fprintf (out, "bb %i op %i insn %i %s ",
4701 bb->index, VEC_length (micro_operation, VTI (bb)->mos),
4702 INSN_UID (insn), micro_operation_type_name[mopt]);
4703 print_inline_rtx (out, x, 2);
4707 /* Tell whether the CONCAT used to holds a VALUE and its location
4708 needs value resolution, i.e., an attempt of mapping the location
4709 back to other incoming values. */
4710 #define VAL_NEEDS_RESOLUTION(x) \
4711 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)->volatil)
4712 /* Whether the location in the CONCAT is a tracked expression, that
4713 should also be handled like a MO_USE. */
4714 #define VAL_HOLDS_TRACK_EXPR(x) \
4715 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)->used)
4716 /* Whether the location in the CONCAT should be handled like a MO_COPY
4718 #define VAL_EXPR_IS_COPIED(x) \
4719 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)->jump)
4720 /* Whether the location in the CONCAT should be handled like a
4721 MO_CLOBBER as well. */
4722 #define VAL_EXPR_IS_CLOBBERED(x) \
4723 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)->unchanging)
4724 /* Whether the location is a CONCAT of the MO_VAL_SET expression and
4725 a reverse operation that should be handled afterwards. */
4726 #define VAL_EXPR_HAS_REVERSE(x) \
4727 (RTL_FLAG_CHECK1 ("VAL_EXPR_HAS_REVERSE", (x), CONCAT)->return_val)
4729 /* All preserved VALUEs. */
4730 static VEC (rtx, heap) *preserved_values;
4732 /* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
4735 preserve_value (cselib_val *val)
4737 cselib_preserve_value (val);
4738 VEC_safe_push (rtx, heap, preserved_values, val->val_rtx);
4741 /* Add uses (register and memory references) LOC which will be tracked
4742 to VTI (bb)->mos. INSN is instruction which the LOC is part of. */
4745 add_uses (rtx *ploc, void *data)
4748 enum machine_mode mode = VOIDmode;
4749 struct count_use_info *cui = (struct count_use_info *)data;
4750 enum micro_operation_type type = use_type (loc, cui, &mode);
4752 if (type != MO_CLOBBER)
4754 basic_block bb = cui->bb;
4758 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
4759 mo.insn = cui->insn;
4761 if (type == MO_VAL_LOC)
4764 rtx vloc = PAT_VAR_LOCATION_LOC (oloc);
4767 gcc_assert (cui->sets);
4770 && !REG_P (XEXP (vloc, 0))
4771 && !MEM_P (XEXP (vloc, 0))
4772 && (GET_CODE (XEXP (vloc, 0)) != PLUS
4773 || XEXP (XEXP (vloc, 0), 0) != cfa_base_rtx
4774 || !CONST_INT_P (XEXP (XEXP (vloc, 0), 1))))
4777 enum machine_mode address_mode = get_address_mode (mloc);
4779 = cselib_lookup (XEXP (mloc, 0), address_mode, 0);
4781 if (val && !cselib_preserved_value_p (val))
4783 micro_operation moa;
4784 preserve_value (val);
4785 mloc = cselib_subst_to_values (XEXP (mloc, 0));
4786 moa.type = MO_VAL_USE;
4787 moa.insn = cui->insn;
4788 moa.u.loc = gen_rtx_CONCAT (address_mode,
4789 val->val_rtx, mloc);
4790 if (dump_file && (dump_flags & TDF_DETAILS))
4791 log_op_type (moa.u.loc, cui->bb, cui->insn,
4792 moa.type, dump_file);
4793 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &moa);
4797 if (!VAR_LOC_UNKNOWN_P (vloc)
4798 && (val = find_use_val (vloc, GET_MODE (oloc), cui)))
4800 enum machine_mode mode2;
4801 enum micro_operation_type type2;
4802 rtx nloc = replace_expr_with_values (vloc);
4806 oloc = shallow_copy_rtx (oloc);
4807 PAT_VAR_LOCATION_LOC (oloc) = nloc;
4810 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc);
4812 type2 = use_type (vloc, 0, &mode2);
4814 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
4815 || type2 == MO_CLOBBER);
4817 if (type2 == MO_CLOBBER
4818 && !cselib_preserved_value_p (val))
4820 VAL_NEEDS_RESOLUTION (oloc) = 1;
4821 preserve_value (val);
4824 else if (!VAR_LOC_UNKNOWN_P (vloc))
4826 oloc = shallow_copy_rtx (oloc);
4827 PAT_VAR_LOCATION_LOC (oloc) = gen_rtx_UNKNOWN_VAR_LOC ();
4832 else if (type == MO_VAL_USE)
4834 enum machine_mode mode2 = VOIDmode;
4835 enum micro_operation_type type2;
4836 cselib_val *val = find_use_val (loc, GET_MODE (loc), cui);
4837 rtx vloc, oloc = loc, nloc;
4839 gcc_assert (cui->sets);
4842 && !REG_P (XEXP (oloc, 0))
4843 && !MEM_P (XEXP (oloc, 0))
4844 && (GET_CODE (XEXP (oloc, 0)) != PLUS
4845 || XEXP (XEXP (oloc, 0), 0) != cfa_base_rtx
4846 || !CONST_INT_P (XEXP (XEXP (oloc, 0), 1))))
4849 enum machine_mode address_mode = get_address_mode (mloc);
4851 = cselib_lookup (XEXP (mloc, 0), address_mode, 0);
4853 if (val && !cselib_preserved_value_p (val))
4855 micro_operation moa;
4856 preserve_value (val);
4857 mloc = cselib_subst_to_values (XEXP (mloc, 0));
4858 moa.type = MO_VAL_USE;
4859 moa.insn = cui->insn;
4860 moa.u.loc = gen_rtx_CONCAT (address_mode,
4861 val->val_rtx, mloc);
4862 if (dump_file && (dump_flags & TDF_DETAILS))
4863 log_op_type (moa.u.loc, cui->bb, cui->insn,
4864 moa.type, dump_file);
4865 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &moa);
4869 type2 = use_type (loc, 0, &mode2);
4871 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR
4872 || type2 == MO_CLOBBER);
4874 if (type2 == MO_USE)
4875 vloc = var_lowpart (mode2, loc);
4879 /* The loc of a MO_VAL_USE may have two forms:
4881 (concat val src): val is at src, a value-based
4884 (concat (concat val use) src): same as above, with use as
4885 the MO_USE tracked value, if it differs from src.
4889 nloc = replace_expr_with_values (loc);
4894 oloc = gen_rtx_CONCAT (mode2, val->val_rtx, vloc);
4896 oloc = val->val_rtx;
4898 mo.u.loc = gen_rtx_CONCAT (mode, oloc, nloc);
4900 if (type2 == MO_USE)
4901 VAL_HOLDS_TRACK_EXPR (mo.u.loc) = 1;
4902 if (!cselib_preserved_value_p (val))
4904 VAL_NEEDS_RESOLUTION (mo.u.loc) = 1;
4905 preserve_value (val);
4909 gcc_assert (type == MO_USE || type == MO_USE_NO_VAR);
4911 if (dump_file && (dump_flags & TDF_DETAILS))
4912 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
4913 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
4919 /* Helper function for finding all uses of REG/MEM in X in insn INSN. */
4922 add_uses_1 (rtx *x, void *cui)
4924 for_each_rtx (x, add_uses, cui);
4927 /* Attempt to reverse the EXPR operation in the debug info. Say for
4928 reg1 = reg2 + 6 even when reg2 is no longer live we
4929 can express its value as VAL - 6. */
4932 reverse_op (rtx val, const_rtx expr)
4938 if (GET_CODE (expr) != SET)
4941 if (!REG_P (SET_DEST (expr)) || GET_MODE (val) != GET_MODE (SET_DEST (expr)))
4944 src = SET_SRC (expr);
4945 switch (GET_CODE (src))
4959 if (!REG_P (XEXP (src, 0)) || !SCALAR_INT_MODE_P (GET_MODE (src)))
4962 v = cselib_lookup (XEXP (src, 0), GET_MODE (XEXP (src, 0)), 0);
4963 if (!v || !cselib_preserved_value_p (v))
4966 switch (GET_CODE (src))
4970 if (GET_MODE (v->val_rtx) != GET_MODE (val))
4972 ret = gen_rtx_fmt_e (GET_CODE (src), GET_MODE (val), val);
4976 ret = gen_lowpart_SUBREG (GET_MODE (v->val_rtx), val);
4988 if (GET_MODE (v->val_rtx) != GET_MODE (val))
4990 arg = XEXP (src, 1);
4991 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
4993 arg = cselib_expand_value_rtx (arg, scratch_regs, 5);
4994 if (arg == NULL_RTX)
4996 if (!CONST_INT_P (arg) && GET_CODE (arg) != SYMBOL_REF)
4999 ret = simplify_gen_binary (code, GET_MODE (val), val, arg);
5001 /* Ensure ret isn't VALUE itself (which can happen e.g. for
5002 (plus (reg1) (reg2)) when reg2 is known to be 0), as that
5003 breaks a lot of routines during var-tracking. */
5004 ret = gen_rtx_fmt_ee (PLUS, GET_MODE (val), val, const0_rtx);
5010 return gen_rtx_CONCAT (GET_MODE (v->val_rtx), v->val_rtx, ret);
5013 /* Add stores (register and memory references) LOC which will be tracked
5014 to VTI (bb)->mos. EXPR is the RTL expression containing the store.
5015 CUIP->insn is instruction which the LOC is part of. */
5018 add_stores (rtx loc, const_rtx expr, void *cuip)
5020 enum machine_mode mode = VOIDmode, mode2;
5021 struct count_use_info *cui = (struct count_use_info *)cuip;
5022 basic_block bb = cui->bb;
5024 rtx oloc = loc, nloc, src = NULL;
5025 enum micro_operation_type type = use_type (loc, cui, &mode);
5026 bool track_p = false;
5028 bool resolve, preserve;
5031 if (type == MO_CLOBBER)
5038 gcc_assert (loc != cfa_base_rtx);
5039 if ((GET_CODE (expr) == CLOBBER && type != MO_VAL_SET)
5040 || !(track_p = use_type (loc, NULL, &mode2) == MO_USE)
5041 || GET_CODE (expr) == CLOBBER)
5043 mo.type = MO_CLOBBER;
5048 if (GET_CODE (expr) == SET && SET_DEST (expr) == loc)
5049 src = var_lowpart (mode2, SET_SRC (expr));
5050 loc = var_lowpart (mode2, loc);
5059 rtx xexpr = gen_rtx_SET (VOIDmode, loc, src);
5060 if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
5067 mo.insn = cui->insn;
5069 else if (MEM_P (loc)
5070 && ((track_p = use_type (loc, NULL, &mode2) == MO_USE)
5073 if (MEM_P (loc) && type == MO_VAL_SET
5074 && !REG_P (XEXP (loc, 0))
5075 && !MEM_P (XEXP (loc, 0))
5076 && (GET_CODE (XEXP (loc, 0)) != PLUS
5077 || XEXP (XEXP (loc, 0), 0) != cfa_base_rtx
5078 || !CONST_INT_P (XEXP (XEXP (loc, 0), 1))))
5081 enum machine_mode address_mode = get_address_mode (mloc);
5082 cselib_val *val = cselib_lookup (XEXP (mloc, 0),
5085 if (val && !cselib_preserved_value_p (val))
5087 preserve_value (val);
5088 mo.type = MO_VAL_USE;
5089 mloc = cselib_subst_to_values (XEXP (mloc, 0));
5090 mo.u.loc = gen_rtx_CONCAT (address_mode, val->val_rtx, mloc);
5091 mo.insn = cui->insn;
5092 if (dump_file && (dump_flags & TDF_DETAILS))
5093 log_op_type (mo.u.loc, cui->bb, cui->insn,
5094 mo.type, dump_file);
5095 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
5099 if (GET_CODE (expr) == CLOBBER || !track_p)
5101 mo.type = MO_CLOBBER;
5102 mo.u.loc = track_p ? var_lowpart (mode2, loc) : loc;
5106 if (GET_CODE (expr) == SET && SET_DEST (expr) == loc)
5107 src = var_lowpart (mode2, SET_SRC (expr));
5108 loc = var_lowpart (mode2, loc);
5117 rtx xexpr = gen_rtx_SET (VOIDmode, loc, src);
5118 if (same_variable_part_p (SET_SRC (xexpr),
5120 INT_MEM_OFFSET (loc)))
5127 mo.insn = cui->insn;
5132 if (type != MO_VAL_SET)
5133 goto log_and_return;
5135 v = find_use_val (oloc, mode, cui);
5138 goto log_and_return;
5140 resolve = preserve = !cselib_preserved_value_p (v);
5142 nloc = replace_expr_with_values (oloc);
5146 if (GET_CODE (PATTERN (cui->insn)) == COND_EXEC)
5148 cselib_val *oval = cselib_lookup (oloc, GET_MODE (oloc), 0);
5150 gcc_assert (oval != v);
5151 gcc_assert (REG_P (oloc) || MEM_P (oloc));
5153 if (!cselib_preserved_value_p (oval))
5155 micro_operation moa;
5157 preserve_value (oval);
5159 moa.type = MO_VAL_USE;
5160 moa.u.loc = gen_rtx_CONCAT (mode, oval->val_rtx, oloc);
5161 VAL_NEEDS_RESOLUTION (moa.u.loc) = 1;
5162 moa.insn = cui->insn;
5164 if (dump_file && (dump_flags & TDF_DETAILS))
5165 log_op_type (moa.u.loc, cui->bb, cui->insn,
5166 moa.type, dump_file);
5167 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &moa);
5172 else if (resolve && GET_CODE (mo.u.loc) == SET)
5174 nloc = replace_expr_with_values (SET_SRC (expr));
5176 /* Avoid the mode mismatch between oexpr and expr. */
5177 if (!nloc && mode != mode2)
5179 nloc = SET_SRC (expr);
5180 gcc_assert (oloc == SET_DEST (expr));
5184 oloc = gen_rtx_SET (GET_MODE (mo.u.loc), oloc, nloc);
5187 if (oloc == SET_DEST (mo.u.loc))
5188 /* No point in duplicating. */
5190 if (!REG_P (SET_SRC (mo.u.loc)))
5196 if (GET_CODE (mo.u.loc) == SET
5197 && oloc == SET_DEST (mo.u.loc))
5198 /* No point in duplicating. */
5204 loc = gen_rtx_CONCAT (mode, v->val_rtx, oloc);
5206 if (mo.u.loc != oloc)
5207 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, mo.u.loc);
5209 /* The loc of a MO_VAL_SET may have various forms:
5211 (concat val dst): dst now holds val
5213 (concat val (set dst src)): dst now holds val, copied from src
5215 (concat (concat val dstv) dst): dst now holds val; dstv is dst
5216 after replacing mems and non-top-level regs with values.
5218 (concat (concat val dstv) (set dst src)): dst now holds val,
5219 copied from src. dstv is a value-based representation of dst, if
5220 it differs from dst. If resolution is needed, src is a REG, and
5221 its mode is the same as that of val.
5223 (concat (concat val (set dstv srcv)) (set dst src)): src
5224 copied to dst, holding val. dstv and srcv are value-based
5225 representations of dst and src, respectively.
5229 if (GET_CODE (PATTERN (cui->insn)) != COND_EXEC)
5231 reverse = reverse_op (v->val_rtx, expr);
5234 loc = gen_rtx_CONCAT (GET_MODE (mo.u.loc), loc, reverse);
5235 VAL_EXPR_HAS_REVERSE (loc) = 1;
5242 VAL_HOLDS_TRACK_EXPR (loc) = 1;
5245 VAL_NEEDS_RESOLUTION (loc) = resolve;
5248 if (mo.type == MO_CLOBBER)
5249 VAL_EXPR_IS_CLOBBERED (loc) = 1;
5250 if (mo.type == MO_COPY)
5251 VAL_EXPR_IS_COPIED (loc) = 1;
5253 mo.type = MO_VAL_SET;
5256 if (dump_file && (dump_flags & TDF_DETAILS))
5257 log_op_type (mo.u.loc, cui->bb, cui->insn, mo.type, dump_file);
5258 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
5261 /* Callback for cselib_record_sets_hook, that records as micro
5262 operations uses and stores in an insn after cselib_record_sets has
5263 analyzed the sets in an insn, but before it modifies the stored
5264 values in the internal tables, unless cselib_record_sets doesn't
5265 call it directly (perhaps because we're not doing cselib in the
5266 first place, in which case sets and n_sets will be 0). */
5269 add_with_sets (rtx insn, struct cselib_set *sets, int n_sets)
5271 basic_block bb = BLOCK_FOR_INSN (insn);
5273 struct count_use_info cui;
5274 micro_operation *mos;
5276 cselib_hook_called = true;
5281 cui.n_sets = n_sets;
5283 n1 = VEC_length (micro_operation, VTI (bb)->mos);
5284 cui.store_p = false;
5285 note_uses (&PATTERN (insn), add_uses_1, &cui);
5286 n2 = VEC_length (micro_operation, VTI (bb)->mos) - 1;
5287 mos = VEC_address (micro_operation, VTI (bb)->mos);
5289 /* Order the MO_USEs to be before MO_USE_NO_VARs and MO_VAL_USE, and
5293 while (n1 < n2 && mos[n1].type == MO_USE)
5295 while (n1 < n2 && mos[n2].type != MO_USE)
5307 n2 = VEC_length (micro_operation, VTI (bb)->mos) - 1;
5310 while (n1 < n2 && mos[n1].type != MO_VAL_LOC)
5312 while (n1 < n2 && mos[n2].type == MO_VAL_LOC)
5330 mo.u.loc = NULL_RTX;
5332 if (dump_file && (dump_flags & TDF_DETAILS))
5333 log_op_type (PATTERN (insn), bb, insn, mo.type, dump_file);
5334 VEC_safe_push (micro_operation, heap, VTI (bb)->mos, &mo);
5337 n1 = VEC_length (micro_operation, VTI (bb)->mos);
5338 /* This will record NEXT_INSN (insn), such that we can
5339 insert notes before it without worrying about any
5340 notes that MO_USEs might emit after the insn. */
5342 note_stores (PATTERN (insn), add_stores, &cui);
5343 n2 = VEC_length (micro_operation, VTI (bb)->mos) - 1;
5344 mos = VEC_address (micro_operation, VTI (bb)->mos);
5346 /* Order the MO_VAL_USEs first (note_stores does nothing
5347 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
5348 insn), then MO_CLOBBERs, then MO_SET/MO_COPY/MO_VAL_SET. */
5351 while (n1 < n2 && mos[n1].type == MO_VAL_USE)
5353 while (n1 < n2 && mos[n2].type != MO_VAL_USE)
5365 n2 = VEC_length (micro_operation, VTI (bb)->mos) - 1;
5368 while (n1 < n2 && mos[n1].type == MO_CLOBBER)
5370 while (n1 < n2 && mos[n2].type != MO_CLOBBER)
5383 static enum var_init_status
5384 find_src_status (dataflow_set *in, rtx src)
5386 tree decl = NULL_TREE;
5387 enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED;
5389 if (! flag_var_tracking_uninit)
5390 status = VAR_INIT_STATUS_INITIALIZED;
5392 if (src && REG_P (src))
5393 decl = var_debug_decl (REG_EXPR (src));
5394 else if (src && MEM_P (src))
5395 decl = var_debug_decl (MEM_EXPR (src));
5398 status = get_init_value (in, src, dv_from_decl (decl));
5403 /* SRC is the source of an assignment. Use SET to try to find what
5404 was ultimately assigned to SRC. Return that value if known,
5405 otherwise return SRC itself. */
5408 find_src_set_src (dataflow_set *set, rtx src)
5410 tree decl = NULL_TREE; /* The variable being copied around. */
5411 rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */
5413 location_chain nextp;
5417 if (src && REG_P (src))
5418 decl = var_debug_decl (REG_EXPR (src));
5419 else if (src && MEM_P (src))
5420 decl = var_debug_decl (MEM_EXPR (src));
5424 decl_or_value dv = dv_from_decl (decl);
5426 var = shared_hash_find (set->vars, dv);
5430 for (i = 0; i < var->n_var_parts && !found; i++)
5431 for (nextp = var->var_part[i].loc_chain; nextp && !found;
5432 nextp = nextp->next)
5433 if (rtx_equal_p (nextp->loc, src))
5435 set_src = nextp->set_src;
5445 /* Compute the changes of variable locations in the basic block BB. */
5448 compute_bb_dataflow (basic_block bb)
5451 micro_operation *mo;
5453 dataflow_set old_out;
5454 dataflow_set *in = &VTI (bb)->in;
5455 dataflow_set *out = &VTI (bb)->out;
5457 dataflow_set_init (&old_out);
5458 dataflow_set_copy (&old_out, out);
5459 dataflow_set_copy (out, in);
5461 for (i = 0; VEC_iterate (micro_operation, VTI (bb)->mos, i, mo); i++)
5463 rtx insn = mo->insn;
5468 dataflow_set_clear_at_call (out);
5473 rtx loc = mo->u.loc;
5476 var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
5477 else if (MEM_P (loc))
5478 var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
5484 rtx loc = mo->u.loc;
5488 if (GET_CODE (loc) == CONCAT)
5490 val = XEXP (loc, 0);
5491 vloc = XEXP (loc, 1);
5499 var = PAT_VAR_LOCATION_DECL (vloc);
5501 clobber_variable_part (out, NULL_RTX,
5502 dv_from_decl (var), 0, NULL_RTX);
5505 if (VAL_NEEDS_RESOLUTION (loc))
5506 val_resolve (out, val, PAT_VAR_LOCATION_LOC (vloc), insn);
5507 set_variable_part (out, val, dv_from_decl (var), 0,
5508 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
5516 rtx loc = mo->u.loc;
5517 rtx val, vloc, uloc;
5519 vloc = uloc = XEXP (loc, 1);
5520 val = XEXP (loc, 0);
5522 if (GET_CODE (val) == CONCAT)
5524 uloc = XEXP (val, 1);
5525 val = XEXP (val, 0);
5528 if (VAL_NEEDS_RESOLUTION (loc))
5529 val_resolve (out, val, vloc, insn);
5531 val_store (out, val, uloc, insn, false);
5533 if (VAL_HOLDS_TRACK_EXPR (loc))
5535 if (GET_CODE (uloc) == REG)
5536 var_reg_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
5538 else if (GET_CODE (uloc) == MEM)
5539 var_mem_set (out, uloc, VAR_INIT_STATUS_UNINITIALIZED,
5547 rtx loc = mo->u.loc;
5548 rtx val, vloc, uloc, reverse = NULL_RTX;
5551 if (VAL_EXPR_HAS_REVERSE (loc))
5553 reverse = XEXP (loc, 1);
5554 vloc = XEXP (loc, 0);
5556 uloc = XEXP (vloc, 1);
5557 val = XEXP (vloc, 0);
5560 if (GET_CODE (val) == CONCAT)
5562 vloc = XEXP (val, 1);
5563 val = XEXP (val, 0);
5566 if (GET_CODE (vloc) == SET)
5568 rtx vsrc = SET_SRC (vloc);
5570 gcc_assert (val != vsrc);
5571 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
5573 vloc = SET_DEST (vloc);
5575 if (VAL_NEEDS_RESOLUTION (loc))
5576 val_resolve (out, val, vsrc, insn);
5578 else if (VAL_NEEDS_RESOLUTION (loc))
5580 gcc_assert (GET_CODE (uloc) == SET
5581 && GET_CODE (SET_SRC (uloc)) == REG);
5582 val_resolve (out, val, SET_SRC (uloc), insn);
5585 if (VAL_HOLDS_TRACK_EXPR (loc))
5587 if (VAL_EXPR_IS_CLOBBERED (loc))
5590 var_reg_delete (out, uloc, true);
5591 else if (MEM_P (uloc))
5592 var_mem_delete (out, uloc, true);
5596 bool copied_p = VAL_EXPR_IS_COPIED (loc);
5598 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
5600 if (GET_CODE (uloc) == SET)
5602 set_src = SET_SRC (uloc);
5603 uloc = SET_DEST (uloc);
5608 if (flag_var_tracking_uninit)
5610 status = find_src_status (in, set_src);
5612 if (status == VAR_INIT_STATUS_UNKNOWN)
5613 status = find_src_status (out, set_src);
5616 set_src = find_src_set_src (in, set_src);
5620 var_reg_delete_and_set (out, uloc, !copied_p,
5622 else if (MEM_P (uloc))
5623 var_mem_delete_and_set (out, uloc, !copied_p,
5627 else if (REG_P (uloc))
5628 var_regno_delete (out, REGNO (uloc));
5630 val_store (out, val, vloc, insn, true);
5633 val_store (out, XEXP (reverse, 0), XEXP (reverse, 1),
5640 rtx loc = mo->u.loc;
5643 if (GET_CODE (loc) == SET)
5645 set_src = SET_SRC (loc);
5646 loc = SET_DEST (loc);
5650 var_reg_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
5652 else if (MEM_P (loc))
5653 var_mem_delete_and_set (out, loc, true, VAR_INIT_STATUS_INITIALIZED,
5660 rtx loc = mo->u.loc;
5661 enum var_init_status src_status;
5664 if (GET_CODE (loc) == SET)
5666 set_src = SET_SRC (loc);
5667 loc = SET_DEST (loc);
5670 if (! flag_var_tracking_uninit)
5671 src_status = VAR_INIT_STATUS_INITIALIZED;
5674 src_status = find_src_status (in, set_src);
5676 if (src_status == VAR_INIT_STATUS_UNKNOWN)
5677 src_status = find_src_status (out, set_src);
5680 set_src = find_src_set_src (in, set_src);
5683 var_reg_delete_and_set (out, loc, false, src_status, set_src);
5684 else if (MEM_P (loc))
5685 var_mem_delete_and_set (out, loc, false, src_status, set_src);
5691 rtx loc = mo->u.loc;
5694 var_reg_delete (out, loc, false);
5695 else if (MEM_P (loc))
5696 var_mem_delete (out, loc, false);
5702 rtx loc = mo->u.loc;
5705 var_reg_delete (out, loc, true);
5706 else if (MEM_P (loc))
5707 var_mem_delete (out, loc, true);
5712 out->stack_adjust += mo->u.adjust;
5717 if (MAY_HAVE_DEBUG_INSNS)
5719 dataflow_set_equiv_regs (out);
5720 htab_traverse (shared_hash_htab (out->vars), canonicalize_values_mark,
5722 htab_traverse (shared_hash_htab (out->vars), canonicalize_values_star,
5725 htab_traverse (shared_hash_htab (out->vars),
5726 canonicalize_loc_order_check, out);
5729 changed = dataflow_set_different (&old_out, out);
5730 dataflow_set_destroy (&old_out);
5734 /* Find the locations of variables in the whole function. */
5737 vt_find_locations (void)
5739 fibheap_t worklist, pending, fibheap_swap;
5740 sbitmap visited, in_worklist, in_pending, sbitmap_swap;
5747 int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
5748 bool success = true;
5750 /* Compute reverse completion order of depth first search of the CFG
5751 so that the data-flow runs faster. */
5752 rc_order = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
5753 bb_order = XNEWVEC (int, last_basic_block);
5754 pre_and_rev_post_order_compute (NULL, rc_order, false);
5755 for (i = 0; i < n_basic_blocks - NUM_FIXED_BLOCKS; i++)
5756 bb_order[rc_order[i]] = i;
5759 worklist = fibheap_new ();
5760 pending = fibheap_new ();
5761 visited = sbitmap_alloc (last_basic_block);
5762 in_worklist = sbitmap_alloc (last_basic_block);
5763 in_pending = sbitmap_alloc (last_basic_block);
5764 sbitmap_zero (in_worklist);
5767 fibheap_insert (pending, bb_order[bb->index], bb);
5768 sbitmap_ones (in_pending);
5770 while (success && !fibheap_empty (pending))
5772 fibheap_swap = pending;
5774 worklist = fibheap_swap;
5775 sbitmap_swap = in_pending;
5776 in_pending = in_worklist;
5777 in_worklist = sbitmap_swap;
5779 sbitmap_zero (visited);
5781 while (!fibheap_empty (worklist))
5783 bb = (basic_block) fibheap_extract_min (worklist);
5784 RESET_BIT (in_worklist, bb->index);
5785 if (!TEST_BIT (visited, bb->index))
5789 int oldinsz, oldoutsz;
5791 SET_BIT (visited, bb->index);
5793 if (VTI (bb)->in.vars)
5796 -= (htab_size (shared_hash_htab (VTI (bb)->in.vars))
5797 + htab_size (shared_hash_htab (VTI (bb)->out.vars)));
5799 = htab_elements (shared_hash_htab (VTI (bb)->in.vars));
5801 = htab_elements (shared_hash_htab (VTI (bb)->out.vars));
5804 oldinsz = oldoutsz = 0;
5806 if (MAY_HAVE_DEBUG_INSNS)
5808 dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
5809 bool first = true, adjust = false;
5811 /* Calculate the IN set as the intersection of
5812 predecessor OUT sets. */
5814 dataflow_set_clear (in);
5815 dst_can_be_shared = true;
5817 FOR_EACH_EDGE (e, ei, bb->preds)
5818 if (!VTI (e->src)->flooded)
5819 gcc_assert (bb_order[bb->index]
5820 <= bb_order[e->src->index]);
5823 dataflow_set_copy (in, &VTI (e->src)->out);
5824 first_out = &VTI (e->src)->out;
5829 dataflow_set_merge (in, &VTI (e->src)->out);
5835 dataflow_post_merge_adjust (in, &VTI (bb)->permp);
5837 /* Merge and merge_adjust should keep entries in
5839 htab_traverse (shared_hash_htab (in->vars),
5840 canonicalize_loc_order_check,
5843 if (dst_can_be_shared)
5845 shared_hash_destroy (in->vars);
5846 in->vars = shared_hash_copy (first_out->vars);
5850 VTI (bb)->flooded = true;
5854 /* Calculate the IN set as union of predecessor OUT sets. */
5855 dataflow_set_clear (&VTI (bb)->in);
5856 FOR_EACH_EDGE (e, ei, bb->preds)
5857 dataflow_set_union (&VTI (bb)->in, &VTI (e->src)->out);
5860 changed = compute_bb_dataflow (bb);
5861 htabsz += (htab_size (shared_hash_htab (VTI (bb)->in.vars))
5862 + htab_size (shared_hash_htab (VTI (bb)->out.vars)));
5864 if (htabmax && htabsz > htabmax)
5866 if (MAY_HAVE_DEBUG_INSNS)
5867 inform (DECL_SOURCE_LOCATION (cfun->decl),
5868 "variable tracking size limit exceeded with "
5869 "-fvar-tracking-assignments, retrying without");
5871 inform (DECL_SOURCE_LOCATION (cfun->decl),
5872 "variable tracking size limit exceeded");
5879 FOR_EACH_EDGE (e, ei, bb->succs)
5881 if (e->dest == EXIT_BLOCK_PTR)
5884 if (TEST_BIT (visited, e->dest->index))
5886 if (!TEST_BIT (in_pending, e->dest->index))
5888 /* Send E->DEST to next round. */
5889 SET_BIT (in_pending, e->dest->index);
5890 fibheap_insert (pending,
5891 bb_order[e->dest->index],
5895 else if (!TEST_BIT (in_worklist, e->dest->index))
5897 /* Add E->DEST to current round. */
5898 SET_BIT (in_worklist, e->dest->index);
5899 fibheap_insert (worklist, bb_order[e->dest->index],
5907 "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
5909 (int)htab_elements (shared_hash_htab (VTI (bb)->in.vars)),
5911 (int)htab_elements (shared_hash_htab (VTI (bb)->out.vars)),
5913 (int)worklist->nodes, (int)pending->nodes, htabsz);
5915 if (dump_file && (dump_flags & TDF_DETAILS))
5917 fprintf (dump_file, "BB %i IN:\n", bb->index);
5918 dump_dataflow_set (&VTI (bb)->in);
5919 fprintf (dump_file, "BB %i OUT:\n", bb->index);
5920 dump_dataflow_set (&VTI (bb)->out);
5926 if (success && MAY_HAVE_DEBUG_INSNS)
5928 gcc_assert (VTI (bb)->flooded);
5931 fibheap_delete (worklist);
5932 fibheap_delete (pending);
5933 sbitmap_free (visited);
5934 sbitmap_free (in_worklist);
5935 sbitmap_free (in_pending);
5940 /* Print the content of the LIST to dump file. */
5943 dump_attrs_list (attrs list)
5945 for (; list; list = list->next)
5947 if (dv_is_decl_p (list->dv))
5948 print_mem_expr (dump_file, dv_as_decl (list->dv));
5950 print_rtl_single (dump_file, dv_as_value (list->dv));
5951 fprintf (dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset);
5953 fprintf (dump_file, "\n");
5956 /* Print the information about variable *SLOT to dump file. */
5959 dump_var_slot (void **slot, void *data ATTRIBUTE_UNUSED)
5961 variable var = (variable) *slot;
5965 /* Continue traversing the hash table. */
5969 /* Print the information about variable VAR to dump file. */
5972 dump_var (variable var)
5975 location_chain node;
5977 if (dv_is_decl_p (var->dv))
5979 const_tree decl = dv_as_decl (var->dv);
5981 if (DECL_NAME (decl))
5983 fprintf (dump_file, " name: %s",
5984 IDENTIFIER_POINTER (DECL_NAME (decl)));
5985 if (dump_flags & TDF_UID)
5986 fprintf (dump_file, "D.%u", DECL_UID (decl));
5988 else if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
5989 fprintf (dump_file, " name: D#%u", DEBUG_TEMP_UID (decl));
5991 fprintf (dump_file, " name: D.%u", DECL_UID (decl));
5992 fprintf (dump_file, "\n");
5996 fputc (' ', dump_file);
5997 print_rtl_single (dump_file, dv_as_value (var->dv));
6000 for (i = 0; i < var->n_var_parts; i++)
6002 fprintf (dump_file, " offset %ld\n",
6003 (long) var->var_part[i].offset);
6004 for (node = var->var_part[i].loc_chain; node; node = node->next)
6006 fprintf (dump_file, " ");
6007 if (node->init == VAR_INIT_STATUS_UNINITIALIZED)
6008 fprintf (dump_file, "[uninit]");
6009 print_rtl_single (dump_file, node->loc);
6014 /* Print the information about variables from hash table VARS to dump file. */
6017 dump_vars (htab_t vars)
6019 if (htab_elements (vars) > 0)
6021 fprintf (dump_file, "Variables:\n");
6022 htab_traverse (vars, dump_var_slot, NULL);
6026 /* Print the dataflow set SET to dump file. */
6029 dump_dataflow_set (dataflow_set *set)
6033 fprintf (dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n",
6035 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
6039 fprintf (dump_file, "Reg %d:", i);
6040 dump_attrs_list (set->regs[i]);
6043 dump_vars (shared_hash_htab (set->vars));
6044 fprintf (dump_file, "\n");
6047 /* Print the IN and OUT sets for each basic block to dump file. */
6050 dump_dataflow_sets (void)
6056 fprintf (dump_file, "\nBasic block %d:\n", bb->index);
6057 fprintf (dump_file, "IN:\n");
6058 dump_dataflow_set (&VTI (bb)->in);
6059 fprintf (dump_file, "OUT:\n");
6060 dump_dataflow_set (&VTI (bb)->out);
6064 /* Add variable VAR to the hash table of changed variables and
6065 if it has no locations delete it from SET's hash table. */
6068 variable_was_changed (variable var, dataflow_set *set)
6070 hashval_t hash = dv_htab_hash (var->dv);
6075 bool old_cur_loc_changed = false;
6077 /* Remember this decl or VALUE has been added to changed_variables. */
6078 set_dv_changed (var->dv, true);
6080 slot = htab_find_slot_with_hash (changed_variables,
6086 variable old_var = (variable) *slot;
6087 gcc_assert (old_var->in_changed_variables);
6088 old_var->in_changed_variables = false;
6089 old_cur_loc_changed = old_var->cur_loc_changed;
6090 variable_htab_free (*slot);
6092 if (set && var->n_var_parts == 0)
6096 empty_var = (variable) pool_alloc (dv_pool (var->dv));
6097 empty_var->dv = var->dv;
6098 empty_var->refcount = 1;
6099 empty_var->n_var_parts = 0;
6100 empty_var->cur_loc_changed = true;
6101 empty_var->in_changed_variables = true;
6108 var->in_changed_variables = true;
6109 /* If within processing one uop a variable is deleted
6110 and then readded, we need to assume it has changed. */
6111 if (old_cur_loc_changed)
6112 var->cur_loc_changed = true;
6119 if (var->n_var_parts == 0)
6124 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
6127 if (shared_hash_shared (set->vars))
6128 slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
6130 htab_clear_slot (shared_hash_htab (set->vars), slot);
6136 /* Look for the index in VAR->var_part corresponding to OFFSET.
6137 Return -1 if not found. If INSERTION_POINT is non-NULL, the
6138 referenced int will be set to the index that the part has or should
6139 have, if it should be inserted. */
6142 find_variable_location_part (variable var, HOST_WIDE_INT offset,
6143 int *insertion_point)
6147 /* Find the location part. */
6149 high = var->n_var_parts;
6152 pos = (low + high) / 2;
6153 if (var->var_part[pos].offset < offset)
6160 if (insertion_point)
6161 *insertion_point = pos;
6163 if (pos < var->n_var_parts && var->var_part[pos].offset == offset)
6170 set_slot_part (dataflow_set *set, rtx loc, void **slot,
6171 decl_or_value dv, HOST_WIDE_INT offset,
6172 enum var_init_status initialized, rtx set_src)
6175 location_chain node, next;
6176 location_chain *nextp;
6178 bool onepart = dv_onepart_p (dv);
6180 gcc_assert (offset == 0 || !onepart);
6181 gcc_assert (loc != dv_as_opaque (dv));
6183 var = (variable) *slot;
6185 if (! flag_var_tracking_uninit)
6186 initialized = VAR_INIT_STATUS_INITIALIZED;
6190 /* Create new variable information. */
6191 var = (variable) pool_alloc (dv_pool (dv));
6194 var->n_var_parts = 1;
6195 var->cur_loc_changed = false;
6196 var->in_changed_variables = false;
6197 var->var_part[0].offset = offset;
6198 var->var_part[0].loc_chain = NULL;
6199 var->var_part[0].cur_loc = NULL;
6202 nextp = &var->var_part[0].loc_chain;
6208 gcc_assert (dv_as_opaque (var->dv) == dv_as_opaque (dv));
6212 if (GET_CODE (loc) == VALUE)
6214 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
6215 nextp = &node->next)
6216 if (GET_CODE (node->loc) == VALUE)
6218 if (node->loc == loc)
6223 if (canon_value_cmp (node->loc, loc))
6231 else if (REG_P (node->loc) || MEM_P (node->loc))
6239 else if (REG_P (loc))
6241 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
6242 nextp = &node->next)
6243 if (REG_P (node->loc))
6245 if (REGNO (node->loc) < REGNO (loc))
6249 if (REGNO (node->loc) == REGNO (loc))
6262 else if (MEM_P (loc))
6264 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
6265 nextp = &node->next)
6266 if (REG_P (node->loc))
6268 else if (MEM_P (node->loc))
6270 if ((r = loc_cmp (XEXP (node->loc, 0), XEXP (loc, 0))) >= 0)
6282 for (nextp = &var->var_part[0].loc_chain; (node = *nextp);
6283 nextp = &node->next)
6284 if ((r = loc_cmp (node->loc, loc)) >= 0)
6292 if (shared_var_p (var, set->vars))
6294 slot = unshare_variable (set, slot, var, initialized);
6295 var = (variable)*slot;
6296 for (nextp = &var->var_part[0].loc_chain; c;
6297 nextp = &(*nextp)->next)
6299 gcc_assert ((!node && !*nextp) || node->loc == (*nextp)->loc);
6306 gcc_assert (dv_as_decl (var->dv) == dv_as_decl (dv));
6308 pos = find_variable_location_part (var, offset, &inspos);
6312 node = var->var_part[pos].loc_chain;
6315 && ((REG_P (node->loc) && REG_P (loc)
6316 && REGNO (node->loc) == REGNO (loc))
6317 || rtx_equal_p (node->loc, loc)))
6319 /* LOC is in the beginning of the chain so we have nothing
6321 if (node->init < initialized)
6322 node->init = initialized;
6323 if (set_src != NULL)
6324 node->set_src = set_src;
6330 /* We have to make a copy of a shared variable. */
6331 if (shared_var_p (var, set->vars))
6333 slot = unshare_variable (set, slot, var, initialized);
6334 var = (variable)*slot;
6340 /* We have not found the location part, new one will be created. */
6342 /* We have to make a copy of the shared variable. */
6343 if (shared_var_p (var, set->vars))
6345 slot = unshare_variable (set, slot, var, initialized);
6346 var = (variable)*slot;
6349 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
6350 thus there are at most MAX_VAR_PARTS different offsets. */
6351 gcc_assert (var->n_var_parts < MAX_VAR_PARTS
6352 && (!var->n_var_parts || !dv_onepart_p (var->dv)));
6354 /* We have to move the elements of array starting at index
6355 inspos to the next position. */
6356 for (pos = var->n_var_parts; pos > inspos; pos--)
6357 var->var_part[pos] = var->var_part[pos - 1];
6360 var->var_part[pos].offset = offset;
6361 var->var_part[pos].loc_chain = NULL;
6362 var->var_part[pos].cur_loc = NULL;
6365 /* Delete the location from the list. */
6366 nextp = &var->var_part[pos].loc_chain;
6367 for (node = var->var_part[pos].loc_chain; node; node = next)
6370 if ((REG_P (node->loc) && REG_P (loc)
6371 && REGNO (node->loc) == REGNO (loc))
6372 || rtx_equal_p (node->loc, loc))
6374 /* Save these values, to assign to the new node, before
6375 deleting this one. */
6376 if (node->init > initialized)
6377 initialized = node->init;
6378 if (node->set_src != NULL && set_src == NULL)
6379 set_src = node->set_src;
6380 if (var->var_part[pos].cur_loc == node->loc)
6382 var->var_part[pos].cur_loc = NULL;
6383 var->cur_loc_changed = true;
6385 pool_free (loc_chain_pool, node);
6390 nextp = &node->next;
6393 nextp = &var->var_part[pos].loc_chain;
6396 /* Add the location to the beginning. */
6397 node = (location_chain) pool_alloc (loc_chain_pool);
6399 node->init = initialized;
6400 node->set_src = set_src;
6401 node->next = *nextp;
6404 if (onepart && emit_notes)
6405 add_value_chains (var->dv, loc);
6407 /* If no location was emitted do so. */
6408 if (var->var_part[pos].cur_loc == NULL)
6409 variable_was_changed (var, set);
6414 /* Set the part of variable's location in the dataflow set SET. The
6415 variable part is specified by variable's declaration in DV and
6416 offset OFFSET and the part's location by LOC. IOPT should be
6417 NO_INSERT if the variable is known to be in SET already and the
6418 variable hash table must not be resized, and INSERT otherwise. */
6421 set_variable_part (dataflow_set *set, rtx loc,
6422 decl_or_value dv, HOST_WIDE_INT offset,
6423 enum var_init_status initialized, rtx set_src,
6424 enum insert_option iopt)
6428 if (iopt == NO_INSERT)
6429 slot = shared_hash_find_slot_noinsert (set->vars, dv);
6432 slot = shared_hash_find_slot (set->vars, dv);
6434 slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
6436 slot = set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
6439 /* Remove all recorded register locations for the given variable part
6440 from dataflow set SET, except for those that are identical to loc.
6441 The variable part is specified by variable's declaration or value
6442 DV and offset OFFSET. */
6445 clobber_slot_part (dataflow_set *set, rtx loc, void **slot,
6446 HOST_WIDE_INT offset, rtx set_src)
6448 variable var = (variable) *slot;
6449 int pos = find_variable_location_part (var, offset, NULL);
6453 location_chain node, next;
6455 /* Remove the register locations from the dataflow set. */
6456 next = var->var_part[pos].loc_chain;
6457 for (node = next; node; node = next)
6460 if (node->loc != loc
6461 && (!flag_var_tracking_uninit
6464 || !rtx_equal_p (set_src, node->set_src)))
6466 if (REG_P (node->loc))
6471 /* Remove the variable part from the register's
6472 list, but preserve any other variable parts
6473 that might be regarded as live in that same
6475 anextp = &set->regs[REGNO (node->loc)];
6476 for (anode = *anextp; anode; anode = anext)
6478 anext = anode->next;
6479 if (dv_as_opaque (anode->dv) == dv_as_opaque (var->dv)
6480 && anode->offset == offset)
6482 pool_free (attrs_pool, anode);
6486 anextp = &anode->next;
6490 slot = delete_slot_part (set, node->loc, slot, offset);
6498 /* Remove all recorded register locations for the given variable part
6499 from dataflow set SET, except for those that are identical to loc.
6500 The variable part is specified by variable's declaration or value
6501 DV and offset OFFSET. */
6504 clobber_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
6505 HOST_WIDE_INT offset, rtx set_src)
6509 if (!dv_as_opaque (dv)
6510 || (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
6513 slot = shared_hash_find_slot_noinsert (set->vars, dv);
6517 slot = clobber_slot_part (set, loc, slot, offset, set_src);
6520 /* Delete the part of variable's location from dataflow set SET. The
6521 variable part is specified by its SET->vars slot SLOT and offset
6522 OFFSET and the part's location by LOC. */
6525 delete_slot_part (dataflow_set *set, rtx loc, void **slot,
6526 HOST_WIDE_INT offset)
6528 variable var = (variable) *slot;
6529 int pos = find_variable_location_part (var, offset, NULL);
6533 location_chain node, next;
6534 location_chain *nextp;
6537 if (shared_var_p (var, set->vars))
6539 /* If the variable contains the location part we have to
6540 make a copy of the variable. */
6541 for (node = var->var_part[pos].loc_chain; node;
6544 if ((REG_P (node->loc) && REG_P (loc)
6545 && REGNO (node->loc) == REGNO (loc))
6546 || rtx_equal_p (node->loc, loc))
6548 slot = unshare_variable (set, slot, var,
6549 VAR_INIT_STATUS_UNKNOWN);
6550 var = (variable)*slot;
6556 /* Delete the location part. */
6558 nextp = &var->var_part[pos].loc_chain;
6559 for (node = *nextp; node; node = next)
6562 if ((REG_P (node->loc) && REG_P (loc)
6563 && REGNO (node->loc) == REGNO (loc))
6564 || rtx_equal_p (node->loc, loc))
6566 if (emit_notes && pos == 0 && dv_onepart_p (var->dv))
6567 remove_value_chains (var->dv, node->loc);
6568 /* If we have deleted the location which was last emitted
6569 we have to emit new location so add the variable to set
6570 of changed variables. */
6571 if (var->var_part[pos].cur_loc == node->loc)
6574 var->var_part[pos].cur_loc = NULL;
6575 var->cur_loc_changed = true;
6577 pool_free (loc_chain_pool, node);
6582 nextp = &node->next;
6585 if (var->var_part[pos].loc_chain == NULL)
6590 var->cur_loc_changed = true;
6591 while (pos < var->n_var_parts)
6593 var->var_part[pos] = var->var_part[pos + 1];
6598 variable_was_changed (var, set);
6604 /* Delete the part of variable's location from dataflow set SET. The
6605 variable part is specified by variable's declaration or value DV
6606 and offset OFFSET and the part's location by LOC. */
6609 delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
6610 HOST_WIDE_INT offset)
6612 void **slot = shared_hash_find_slot_noinsert (set->vars, dv);
6616 slot = delete_slot_part (set, loc, slot, offset);
6619 /* Structure for passing some other parameters to function
6620 vt_expand_loc_callback. */
6621 struct expand_loc_callback_data
6623 /* The variables and values active at this point. */
6626 /* True in vt_expand_loc_dummy calls, no rtl should be allocated.
6627 Non-NULL should be returned if vt_expand_loc would return
6628 non-NULL in that case, NULL otherwise. cur_loc_changed should be
6629 computed and cur_loc recomputed when possible (but just once
6630 per emit_notes_for_changes call). */
6633 /* True if expansion of subexpressions had to recompute some
6634 VALUE/DEBUG_EXPR_DECL's cur_loc or used a VALUE/DEBUG_EXPR_DECL
6635 whose cur_loc has been already recomputed during current
6636 emit_notes_for_changes call. */
6637 bool cur_loc_changed;
6640 /* Callback for cselib_expand_value, that looks for expressions
6641 holding the value in the var-tracking hash tables. Return X for
6642 standard processing, anything else is to be used as-is. */
6645 vt_expand_loc_callback (rtx x, bitmap regs, int max_depth, void *data)
6647 struct expand_loc_callback_data *elcd
6648 = (struct expand_loc_callback_data *) data;
6649 bool dummy = elcd->dummy;
6650 bool cur_loc_changed = elcd->cur_loc_changed;
6654 rtx result, subreg, xret;
6656 switch (GET_CODE (x))
6661 if (cselib_dummy_expand_value_rtx_cb (SUBREG_REG (x), regs,
6663 vt_expand_loc_callback, data))
6669 subreg = cselib_expand_value_rtx_cb (SUBREG_REG (x), regs,
6671 vt_expand_loc_callback, data);
6676 result = simplify_gen_subreg (GET_MODE (x), subreg,
6677 GET_MODE (SUBREG_REG (x)),
6680 /* Invalid SUBREGs are ok in debug info. ??? We could try
6681 alternate expansions for the VALUE as well. */
6683 result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
6688 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x));
6693 dv = dv_from_value (x);
6701 if (VALUE_RECURSED_INTO (x))
6704 var = (variable) htab_find_with_hash (elcd->vars, dv, dv_htab_hash (dv));
6708 if (dummy && dv_changed_p (dv))
6709 elcd->cur_loc_changed = true;
6713 if (var->n_var_parts == 0)
6716 elcd->cur_loc_changed = true;
6720 gcc_assert (var->n_var_parts == 1);
6722 VALUE_RECURSED_INTO (x) = true;
6725 if (var->var_part[0].cur_loc)
6729 if (cselib_dummy_expand_value_rtx_cb (var->var_part[0].cur_loc, regs,
6731 vt_expand_loc_callback, data))
6735 result = cselib_expand_value_rtx_cb (var->var_part[0].cur_loc, regs,
6737 vt_expand_loc_callback, data);
6739 set_dv_changed (dv, false);
6741 if (!result && dv_changed_p (dv))
6743 set_dv_changed (dv, false);
6744 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
6745 if (loc->loc == var->var_part[0].cur_loc)
6749 elcd->cur_loc_changed = cur_loc_changed;
6750 if (cselib_dummy_expand_value_rtx_cb (loc->loc, regs, max_depth,
6751 vt_expand_loc_callback,
6759 result = cselib_expand_value_rtx_cb (loc->loc, regs, max_depth,
6760 vt_expand_loc_callback,
6766 if (dummy && (result || var->var_part[0].cur_loc))
6767 var->cur_loc_changed = true;
6768 var->var_part[0].cur_loc = loc ? loc->loc : NULL_RTX;
6772 if (var->cur_loc_changed)
6773 elcd->cur_loc_changed = true;
6774 else if (!result && var->var_part[0].cur_loc == NULL_RTX)
6775 elcd->cur_loc_changed = cur_loc_changed;
6778 VALUE_RECURSED_INTO (x) = false;
6785 /* Expand VALUEs in LOC, using VARS as well as cselib's equivalence
6789 vt_expand_loc (rtx loc, htab_t vars)
6791 struct expand_loc_callback_data data;
6793 if (!MAY_HAVE_DEBUG_INSNS)
6798 data.cur_loc_changed = false;
6799 loc = cselib_expand_value_rtx_cb (loc, scratch_regs, 5,
6800 vt_expand_loc_callback, &data);
6802 if (loc && MEM_P (loc))
6803 loc = targetm.delegitimize_address (loc);
6807 /* Like vt_expand_loc, but only return true/false (whether vt_expand_loc
6808 would succeed or not, without actually allocating new rtxes. */
6811 vt_expand_loc_dummy (rtx loc, htab_t vars, bool *pcur_loc_changed)
6813 struct expand_loc_callback_data data;
6816 gcc_assert (MAY_HAVE_DEBUG_INSNS);
6819 data.cur_loc_changed = false;
6820 ret = cselib_dummy_expand_value_rtx_cb (loc, scratch_regs, 5,
6821 vt_expand_loc_callback, &data);
6822 *pcur_loc_changed = data.cur_loc_changed;
6826 #ifdef ENABLE_RTL_CHECKING
6827 /* Used to verify that cur_loc_changed updating is safe. */
6828 static struct pointer_map_t *emitted_notes;
6831 /* Emit the NOTE_INSN_VAR_LOCATION for variable *VARP. DATA contains
6832 additional parameters: WHERE specifies whether the note shall be emitted
6833 before or after instruction INSN. */
6836 emit_note_insn_var_location (void **varp, void *data)
6838 variable var = (variable) *varp;
6839 rtx insn = ((emit_note_data *)data)->insn;
6840 enum emit_note_where where = ((emit_note_data *)data)->where;
6841 htab_t vars = ((emit_note_data *)data)->vars;
6843 int i, j, n_var_parts;
6845 enum var_init_status initialized = VAR_INIT_STATUS_UNINITIALIZED;
6846 HOST_WIDE_INT last_limit;
6847 tree type_size_unit;
6848 HOST_WIDE_INT offsets[MAX_VAR_PARTS];
6849 rtx loc[MAX_VAR_PARTS];
6853 if (dv_is_value_p (var->dv))
6854 goto value_or_debug_decl;
6856 decl = dv_as_decl (var->dv);
6858 if (TREE_CODE (decl) == DEBUG_EXPR_DECL)
6859 goto value_or_debug_decl;
6864 if (!MAY_HAVE_DEBUG_INSNS)
6866 for (i = 0; i < var->n_var_parts; i++)
6867 if (var->var_part[i].cur_loc == NULL && var->var_part[i].loc_chain)
6869 var->var_part[i].cur_loc = var->var_part[i].loc_chain->loc;
6870 var->cur_loc_changed = true;
6872 if (var->n_var_parts == 0)
6873 var->cur_loc_changed = true;
6875 #ifndef ENABLE_RTL_CHECKING
6876 if (!var->cur_loc_changed)
6879 for (i = 0; i < var->n_var_parts; i++)
6881 enum machine_mode mode, wider_mode;
6884 if (last_limit < var->var_part[i].offset)
6889 else if (last_limit > var->var_part[i].offset)
6891 offsets[n_var_parts] = var->var_part[i].offset;
6892 if (!var->var_part[i].cur_loc)
6897 loc2 = vt_expand_loc (var->var_part[i].cur_loc, vars);
6903 loc[n_var_parts] = loc2;
6904 mode = GET_MODE (var->var_part[i].cur_loc);
6905 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
6906 if (var->var_part[i].cur_loc == lc->loc)
6908 initialized = lc->init;
6912 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
6914 /* Attempt to merge adjacent registers or memory. */
6915 wider_mode = GET_MODE_WIDER_MODE (mode);
6916 for (j = i + 1; j < var->n_var_parts; j++)
6917 if (last_limit <= var->var_part[j].offset)
6919 if (j < var->n_var_parts
6920 && wider_mode != VOIDmode
6921 && var->var_part[j].cur_loc
6922 && mode == GET_MODE (var->var_part[j].cur_loc)
6923 && (REG_P (loc[n_var_parts]) || MEM_P (loc[n_var_parts]))
6924 && last_limit == var->var_part[j].offset
6925 && (loc2 = vt_expand_loc (var->var_part[j].cur_loc, vars))
6926 && GET_CODE (loc[n_var_parts]) == GET_CODE (loc2))
6930 if (REG_P (loc[n_var_parts])
6931 && hard_regno_nregs[REGNO (loc[n_var_parts])][mode] * 2
6932 == hard_regno_nregs[REGNO (loc[n_var_parts])][wider_mode]
6933 && end_hard_regno (mode, REGNO (loc[n_var_parts]))
6936 if (! WORDS_BIG_ENDIAN && ! BYTES_BIG_ENDIAN)
6937 new_loc = simplify_subreg (wider_mode, loc[n_var_parts],
6939 else if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
6940 new_loc = simplify_subreg (wider_mode, loc2, mode, 0);
6943 if (!REG_P (new_loc)
6944 || REGNO (new_loc) != REGNO (loc[n_var_parts]))
6947 REG_ATTRS (new_loc) = REG_ATTRS (loc[n_var_parts]);
6950 else if (MEM_P (loc[n_var_parts])
6951 && GET_CODE (XEXP (loc2, 0)) == PLUS
6952 && REG_P (XEXP (XEXP (loc2, 0), 0))
6953 && CONST_INT_P (XEXP (XEXP (loc2, 0), 1)))
6955 if ((REG_P (XEXP (loc[n_var_parts], 0))
6956 && rtx_equal_p (XEXP (loc[n_var_parts], 0),
6957 XEXP (XEXP (loc2, 0), 0))
6958 && INTVAL (XEXP (XEXP (loc2, 0), 1))
6959 == GET_MODE_SIZE (mode))
6960 || (GET_CODE (XEXP (loc[n_var_parts], 0)) == PLUS
6961 && CONST_INT_P (XEXP (XEXP (loc[n_var_parts], 0), 1))
6962 && rtx_equal_p (XEXP (XEXP (loc[n_var_parts], 0), 0),
6963 XEXP (XEXP (loc2, 0), 0))
6964 && INTVAL (XEXP (XEXP (loc[n_var_parts], 0), 1))
6965 + GET_MODE_SIZE (mode)
6966 == INTVAL (XEXP (XEXP (loc2, 0), 1))))
6967 new_loc = adjust_address_nv (loc[n_var_parts],
6973 loc[n_var_parts] = new_loc;
6975 last_limit = offsets[n_var_parts] + GET_MODE_SIZE (mode);
6981 type_size_unit = TYPE_SIZE_UNIT (TREE_TYPE (decl));
6982 if ((unsigned HOST_WIDE_INT) last_limit < TREE_INT_CST_LOW (type_size_unit))
6985 if (! flag_var_tracking_uninit)
6986 initialized = VAR_INIT_STATUS_INITIALIZED;
6990 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, NULL_RTX,
6992 else if (n_var_parts == 1)
6995 = gen_rtx_EXPR_LIST (VOIDmode, loc[0], GEN_INT (offsets[0]));
6997 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl, expr_list,
7000 else if (n_var_parts)
7004 for (i = 0; i < n_var_parts; i++)
7006 = gen_rtx_EXPR_LIST (VOIDmode, loc[i], GEN_INT (offsets[i]));
7008 parallel = gen_rtx_PARALLEL (VOIDmode,
7009 gen_rtvec_v (n_var_parts, loc));
7010 note_vl = gen_rtx_VAR_LOCATION (VOIDmode, decl,
7011 parallel, (int) initialized);
7014 #ifdef ENABLE_RTL_CHECKING
7017 void **note_slot = pointer_map_insert (emitted_notes, decl);
7018 rtx pnote = (rtx) *note_slot;
7019 if (!var->cur_loc_changed && (pnote || PAT_VAR_LOCATION_LOC (note_vl)))
7022 gcc_assert (rtx_equal_p (PAT_VAR_LOCATION_LOC (pnote),
7023 PAT_VAR_LOCATION_LOC (note_vl)));
7025 *note_slot = (void *) note_vl;
7027 if (!var->cur_loc_changed)
7031 if (where != EMIT_NOTE_BEFORE_INSN)
7033 note = emit_note_after (NOTE_INSN_VAR_LOCATION, insn);
7034 if (where == EMIT_NOTE_AFTER_CALL_INSN)
7035 NOTE_DURING_CALL_P (note) = true;
7038 note = emit_note_before (NOTE_INSN_VAR_LOCATION, insn);
7039 NOTE_VAR_LOCATION (note) = note_vl;
7042 set_dv_changed (var->dv, false);
7043 var->cur_loc_changed = false;
7044 gcc_assert (var->in_changed_variables);
7045 var->in_changed_variables = false;
7046 htab_clear_slot (changed_variables, varp);
7048 /* Continue traversing the hash table. */
7051 value_or_debug_decl:
7052 if (dv_changed_p (var->dv) && var->n_var_parts)
7055 bool cur_loc_changed;
7057 if (var->var_part[0].cur_loc
7058 && vt_expand_loc_dummy (var->var_part[0].cur_loc, vars,
7061 for (lc = var->var_part[0].loc_chain; lc; lc = lc->next)
7062 if (lc->loc != var->var_part[0].cur_loc
7063 && vt_expand_loc_dummy (lc->loc, vars, &cur_loc_changed))
7065 var->var_part[0].cur_loc = lc ? lc->loc : NULL_RTX;
7070 DEF_VEC_P (variable);
7071 DEF_VEC_ALLOC_P (variable, heap);
7073 /* Stack of variable_def pointers that need processing with
7074 check_changed_vars_2. */
7076 static VEC (variable, heap) *changed_variables_stack;
7078 /* VALUEs with no variables that need set_dv_changed (val, false)
7079 called before check_changed_vars_3. */
7081 static VEC (rtx, heap) *changed_values_stack;
7083 /* Helper function for check_changed_vars_1 and check_changed_vars_2. */
7086 check_changed_vars_0 (decl_or_value dv, htab_t htab)
7089 = (value_chain) htab_find_with_hash (value_chains, dv, dv_htab_hash (dv));
7093 for (vc = vc->next; vc; vc = vc->next)
7094 if (!dv_changed_p (vc->dv))
7097 = (variable) htab_find_with_hash (htab, vc->dv,
7098 dv_htab_hash (vc->dv));
7101 set_dv_changed (vc->dv, true);
7102 VEC_safe_push (variable, heap, changed_variables_stack, vcvar);
7104 else if (dv_is_value_p (vc->dv))
7106 set_dv_changed (vc->dv, true);
7107 VEC_safe_push (rtx, heap, changed_values_stack,
7108 dv_as_value (vc->dv));
7109 check_changed_vars_0 (vc->dv, htab);
7114 /* Populate changed_variables_stack with variable_def pointers
7115 that need variable_was_changed called on them. */
7118 check_changed_vars_1 (void **slot, void *data)
7120 variable var = (variable) *slot;
7121 htab_t htab = (htab_t) data;
7123 if (dv_is_value_p (var->dv)
7124 || TREE_CODE (dv_as_decl (var->dv)) == DEBUG_EXPR_DECL)
7125 check_changed_vars_0 (var->dv, htab);
7129 /* Add VAR to changed_variables and also for VALUEs add recursively
7130 all DVs that aren't in changed_variables yet but reference the
7131 VALUE from its loc_chain. */
7134 check_changed_vars_2 (variable var, htab_t htab)
7136 variable_was_changed (var, NULL);
7137 if (dv_is_value_p (var->dv)
7138 || TREE_CODE (dv_as_decl (var->dv)) == DEBUG_EXPR_DECL)
7139 check_changed_vars_0 (var->dv, htab);
7142 /* For each changed decl (except DEBUG_EXPR_DECLs) recompute
7143 cur_loc if needed (and cur_loc of all VALUEs and DEBUG_EXPR_DECLs
7144 it needs and are also in changed variables) and track whether
7145 cur_loc (or anything it uses to compute location) had to change
7146 during the current emit_notes_for_changes call. */
7149 check_changed_vars_3 (void **slot, void *data)
7151 variable var = (variable) *slot;
7152 htab_t vars = (htab_t) data;
7155 bool cur_loc_changed;
7157 if (dv_is_value_p (var->dv)
7158 || TREE_CODE (dv_as_decl (var->dv)) == DEBUG_EXPR_DECL)
7161 for (i = 0; i < var->n_var_parts; i++)
7163 if (var->var_part[i].cur_loc
7164 && vt_expand_loc_dummy (var->var_part[i].cur_loc, vars,
7167 if (cur_loc_changed)
7168 var->cur_loc_changed = true;
7171 for (lc = var->var_part[i].loc_chain; lc; lc = lc->next)
7172 if (lc->loc != var->var_part[i].cur_loc
7173 && vt_expand_loc_dummy (lc->loc, vars, &cur_loc_changed))
7175 if (lc || var->var_part[i].cur_loc)
7176 var->cur_loc_changed = true;
7177 var->var_part[i].cur_loc = lc ? lc->loc : NULL_RTX;
7179 if (var->n_var_parts == 0)
7180 var->cur_loc_changed = true;
7184 /* Emit NOTE_INSN_VAR_LOCATION note for each variable from a chain
7185 CHANGED_VARIABLES and delete this chain. WHERE specifies whether the notes
7186 shall be emitted before of after instruction INSN. */
7189 emit_notes_for_changes (rtx insn, enum emit_note_where where,
7192 emit_note_data data;
7193 htab_t htab = shared_hash_htab (vars);
7195 if (!htab_elements (changed_variables))
7198 if (MAY_HAVE_DEBUG_INSNS)
7200 /* Unfortunately this has to be done in two steps, because
7201 we can't traverse a hashtab into which we are inserting
7202 through variable_was_changed. */
7203 htab_traverse (changed_variables, check_changed_vars_1, htab);
7204 while (VEC_length (variable, changed_variables_stack) > 0)
7205 check_changed_vars_2 (VEC_pop (variable, changed_variables_stack),
7207 while (VEC_length (rtx, changed_values_stack) > 0)
7208 set_dv_changed (dv_from_value (VEC_pop (rtx, changed_values_stack)),
7210 htab_traverse (changed_variables, check_changed_vars_3, htab);
7217 htab_traverse (changed_variables, emit_note_insn_var_location, &data);
7220 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the
7221 same variable in hash table DATA or is not there at all. */
7224 emit_notes_for_differences_1 (void **slot, void *data)
7226 htab_t new_vars = (htab_t) data;
7227 variable old_var, new_var;
7229 old_var = (variable) *slot;
7230 new_var = (variable) htab_find_with_hash (new_vars, old_var->dv,
7231 dv_htab_hash (old_var->dv));
7235 /* Variable has disappeared. */
7238 empty_var = (variable) pool_alloc (dv_pool (old_var->dv));
7239 empty_var->dv = old_var->dv;
7240 empty_var->refcount = 0;
7241 empty_var->n_var_parts = 0;
7242 empty_var->cur_loc_changed = false;
7243 empty_var->in_changed_variables = false;
7244 if (dv_onepart_p (old_var->dv))
7248 gcc_assert (old_var->n_var_parts == 1);
7249 for (lc = old_var->var_part[0].loc_chain; lc; lc = lc->next)
7250 remove_value_chains (old_var->dv, lc->loc);
7252 variable_was_changed (empty_var, NULL);
7253 /* Continue traversing the hash table. */
7256 if (variable_different_p (old_var, new_var))
7258 if (dv_onepart_p (old_var->dv))
7260 location_chain lc1, lc2;
7262 gcc_assert (old_var->n_var_parts == 1);
7263 gcc_assert (new_var->n_var_parts == 1);
7264 lc1 = old_var->var_part[0].loc_chain;
7265 lc2 = new_var->var_part[0].loc_chain;
7268 && ((REG_P (lc1->loc) && REG_P (lc2->loc))
7269 || rtx_equal_p (lc1->loc, lc2->loc)))
7274 for (; lc2; lc2 = lc2->next)
7275 add_value_chains (old_var->dv, lc2->loc);
7276 for (; lc1; lc1 = lc1->next)
7277 remove_value_chains (old_var->dv, lc1->loc);
7279 variable_was_changed (new_var, NULL);
7281 /* Update cur_loc. */
7282 if (old_var != new_var)
7285 for (i = 0; i < new_var->n_var_parts; i++)
7287 new_var->var_part[i].cur_loc = NULL;
7288 if (old_var->n_var_parts != new_var->n_var_parts
7289 || old_var->var_part[i].offset != new_var->var_part[i].offset)
7290 new_var->cur_loc_changed = true;
7291 else if (old_var->var_part[i].cur_loc != NULL)
7294 rtx cur_loc = old_var->var_part[i].cur_loc;
7296 for (lc = new_var->var_part[i].loc_chain; lc; lc = lc->next)
7297 if (lc->loc == cur_loc
7298 || rtx_equal_p (cur_loc, lc->loc))
7300 new_var->var_part[i].cur_loc = lc->loc;
7304 new_var->cur_loc_changed = true;
7309 /* Continue traversing the hash table. */
7313 /* Add variable *SLOT to the chain CHANGED_VARIABLES if it is not in hash
7317 emit_notes_for_differences_2 (void **slot, void *data)
7319 htab_t old_vars = (htab_t) data;
7320 variable old_var, new_var;
7322 new_var = (variable) *slot;
7323 old_var = (variable) htab_find_with_hash (old_vars, new_var->dv,
7324 dv_htab_hash (new_var->dv));
7328 /* Variable has appeared. */
7329 if (dv_onepart_p (new_var->dv))
7333 gcc_assert (new_var->n_var_parts == 1);
7334 for (lc = new_var->var_part[0].loc_chain; lc; lc = lc->next)
7335 add_value_chains (new_var->dv, lc->loc);
7337 for (i = 0; i < new_var->n_var_parts; i++)
7338 new_var->var_part[i].cur_loc = NULL;
7339 variable_was_changed (new_var, NULL);
7342 /* Continue traversing the hash table. */
7346 /* Emit notes before INSN for differences between dataflow sets OLD_SET and
7350 emit_notes_for_differences (rtx insn, dataflow_set *old_set,
7351 dataflow_set *new_set)
7353 htab_traverse (shared_hash_htab (old_set->vars),
7354 emit_notes_for_differences_1,
7355 shared_hash_htab (new_set->vars));
7356 htab_traverse (shared_hash_htab (new_set->vars),
7357 emit_notes_for_differences_2,
7358 shared_hash_htab (old_set->vars));
7359 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
7362 /* Emit the notes for changes of location parts in the basic block BB. */
7365 emit_notes_in_bb (basic_block bb, dataflow_set *set)
7368 micro_operation *mo;
7370 dataflow_set_clear (set);
7371 dataflow_set_copy (set, &VTI (bb)->in);
7373 for (i = 0; VEC_iterate (micro_operation, VTI (bb)->mos, i, mo); i++)
7375 rtx insn = mo->insn;
7380 dataflow_set_clear_at_call (set);
7381 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_CALL_INSN, set->vars);
7386 rtx loc = mo->u.loc;
7389 var_reg_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
7391 var_mem_set (set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL);
7393 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
7399 rtx loc = mo->u.loc;
7403 if (GET_CODE (loc) == CONCAT)
7405 val = XEXP (loc, 0);
7406 vloc = XEXP (loc, 1);
7414 var = PAT_VAR_LOCATION_DECL (vloc);
7416 clobber_variable_part (set, NULL_RTX,
7417 dv_from_decl (var), 0, NULL_RTX);
7420 if (VAL_NEEDS_RESOLUTION (loc))
7421 val_resolve (set, val, PAT_VAR_LOCATION_LOC (vloc), insn);
7422 set_variable_part (set, val, dv_from_decl (var), 0,
7423 VAR_INIT_STATUS_INITIALIZED, NULL_RTX,
7427 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
7433 rtx loc = mo->u.loc;
7434 rtx val, vloc, uloc;
7436 vloc = uloc = XEXP (loc, 1);
7437 val = XEXP (loc, 0);
7439 if (GET_CODE (val) == CONCAT)
7441 uloc = XEXP (val, 1);
7442 val = XEXP (val, 0);
7445 if (VAL_NEEDS_RESOLUTION (loc))
7446 val_resolve (set, val, vloc, insn);
7448 val_store (set, val, uloc, insn, false);
7450 if (VAL_HOLDS_TRACK_EXPR (loc))
7452 if (GET_CODE (uloc) == REG)
7453 var_reg_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
7455 else if (GET_CODE (uloc) == MEM)
7456 var_mem_set (set, uloc, VAR_INIT_STATUS_UNINITIALIZED,
7460 emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, set->vars);
7466 rtx loc = mo->u.loc;
7467 rtx val, vloc, uloc, reverse = NULL_RTX;
7470 if (VAL_EXPR_HAS_REVERSE (loc))
7472 reverse = XEXP (loc, 1);
7473 vloc = XEXP (loc, 0);
7475 uloc = XEXP (vloc, 1);
7476 val = XEXP (vloc, 0);
7479 if (GET_CODE (val) == CONCAT)
7481 vloc = XEXP (val, 1);
7482 val = XEXP (val, 0);
7485 if (GET_CODE (vloc) == SET)
7487 rtx vsrc = SET_SRC (vloc);
7489 gcc_assert (val != vsrc);
7490 gcc_assert (vloc == uloc || VAL_NEEDS_RESOLUTION (loc));
7492 vloc = SET_DEST (vloc);
7494 if (VAL_NEEDS_RESOLUTION (loc))
7495 val_resolve (set, val, vsrc, insn);
7497 else if (VAL_NEEDS_RESOLUTION (loc))
7499 gcc_assert (GET_CODE (uloc) == SET
7500 && GET_CODE (SET_SRC (uloc)) == REG);
7501 val_resolve (set, val, SET_SRC (uloc), insn);
7504 if (VAL_HOLDS_TRACK_EXPR (loc))
7506 if (VAL_EXPR_IS_CLOBBERED (loc))
7509 var_reg_delete (set, uloc, true);
7510 else if (MEM_P (uloc))
7511 var_mem_delete (set, uloc, true);
7515 bool copied_p = VAL_EXPR_IS_COPIED (loc);
7517 enum var_init_status status = VAR_INIT_STATUS_INITIALIZED;
7519 if (GET_CODE (uloc) == SET)
7521 set_src = SET_SRC (uloc);
7522 uloc = SET_DEST (uloc);
7527 status = find_src_status (set, set_src);
7529 set_src = find_src_set_src (set, set_src);
7533 var_reg_delete_and_set (set, uloc, !copied_p,
7535 else if (MEM_P (uloc))
7536 var_mem_delete_and_set (set, uloc, !copied_p,
7540 else if (REG_P (uloc))
7541 var_regno_delete (set, REGNO (uloc));
7543 val_store (set, val, vloc, insn, true);
7546 val_store (set, XEXP (reverse, 0), XEXP (reverse, 1),
7549 emit_notes_for_changes (NEXT_INSN (insn), EMIT_NOTE_BEFORE_INSN,
7556 rtx loc = mo->u.loc;
7559 if (GET_CODE (loc) == SET)
7561 set_src = SET_SRC (loc);
7562 loc = SET_DEST (loc);
7566 var_reg_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
7569 var_mem_delete_and_set (set, loc, true, VAR_INIT_STATUS_INITIALIZED,
7572 emit_notes_for_changes (NEXT_INSN (insn), EMIT_NOTE_BEFORE_INSN,
7579 rtx loc = mo->u.loc;
7580 enum var_init_status src_status;
7583 if (GET_CODE (loc) == SET)
7585 set_src = SET_SRC (loc);
7586 loc = SET_DEST (loc);
7589 src_status = find_src_status (set, set_src);
7590 set_src = find_src_set_src (set, set_src);
7593 var_reg_delete_and_set (set, loc, false, src_status, set_src);
7595 var_mem_delete_and_set (set, loc, false, src_status, set_src);
7597 emit_notes_for_changes (NEXT_INSN (insn), EMIT_NOTE_BEFORE_INSN,
7604 rtx loc = mo->u.loc;
7607 var_reg_delete (set, loc, false);
7609 var_mem_delete (set, loc, false);
7611 emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN, set->vars);
7617 rtx loc = mo->u.loc;
7620 var_reg_delete (set, loc, true);
7622 var_mem_delete (set, loc, true);
7624 emit_notes_for_changes (NEXT_INSN (insn), EMIT_NOTE_BEFORE_INSN,
7630 set->stack_adjust += mo->u.adjust;
7636 /* Emit notes for the whole function. */
7639 vt_emit_notes (void)
7644 #ifdef ENABLE_RTL_CHECKING
7645 emitted_notes = pointer_map_create ();
7647 gcc_assert (!htab_elements (changed_variables));
7649 /* Free memory occupied by the out hash tables, as they aren't used
7652 dataflow_set_clear (&VTI (bb)->out);
7654 /* Enable emitting notes by functions (mainly by set_variable_part and
7655 delete_variable_part). */
7658 if (MAY_HAVE_DEBUG_INSNS)
7663 for (i = 0; VEC_iterate (rtx, preserved_values, i, val); i++)
7664 add_cselib_value_chains (dv_from_value (val));
7665 changed_variables_stack = VEC_alloc (variable, heap, 40);
7666 changed_values_stack = VEC_alloc (rtx, heap, 40);
7669 dataflow_set_init (&cur);
7673 /* Emit the notes for changes of variable locations between two
7674 subsequent basic blocks. */
7675 emit_notes_for_differences (BB_HEAD (bb), &cur, &VTI (bb)->in);
7677 /* Emit the notes for the changes in the basic block itself. */
7678 emit_notes_in_bb (bb, &cur);
7680 /* Free memory occupied by the in hash table, we won't need it
7682 dataflow_set_clear (&VTI (bb)->in);
7684 #ifdef ENABLE_CHECKING
7685 htab_traverse (shared_hash_htab (cur.vars),
7686 emit_notes_for_differences_1,
7687 shared_hash_htab (empty_shared_hash));
7688 if (MAY_HAVE_DEBUG_INSNS)
7693 for (i = 0; VEC_iterate (rtx, preserved_values, i, val); i++)
7694 remove_cselib_value_chains (dv_from_value (val));
7695 gcc_assert (htab_elements (value_chains) == 0);
7698 dataflow_set_destroy (&cur);
7700 if (MAY_HAVE_DEBUG_INSNS)
7702 VEC_free (variable, heap, changed_variables_stack);
7703 VEC_free (rtx, heap, changed_values_stack);
7706 #ifdef ENABLE_RTL_CHECKING
7707 pointer_map_destroy (emitted_notes);
7712 /* If there is a declaration and offset associated with register/memory RTL
7713 assign declaration to *DECLP and offset to *OFFSETP, and return true. */
7716 vt_get_decl_and_offset (rtx rtl, tree *declp, HOST_WIDE_INT *offsetp)
7720 if (REG_ATTRS (rtl))
7722 *declp = REG_EXPR (rtl);
7723 *offsetp = REG_OFFSET (rtl);
7727 else if (MEM_P (rtl))
7729 if (MEM_ATTRS (rtl))
7731 *declp = MEM_EXPR (rtl);
7732 *offsetp = INT_MEM_OFFSET (rtl);
7739 /* Insert function parameters to IN and OUT sets of ENTRY_BLOCK. */
7742 vt_add_function_parameters (void)
7746 for (parm = DECL_ARGUMENTS (current_function_decl);
7747 parm; parm = TREE_CHAIN (parm))
7749 rtx decl_rtl = DECL_RTL_IF_SET (parm);
7750 rtx incoming = DECL_INCOMING_RTL (parm);
7752 enum machine_mode mode;
7753 HOST_WIDE_INT offset;
7757 if (TREE_CODE (parm) != PARM_DECL)
7760 if (!DECL_NAME (parm))
7763 if (!decl_rtl || !incoming)
7766 if (GET_MODE (decl_rtl) == BLKmode || GET_MODE (incoming) == BLKmode)
7769 if (!vt_get_decl_and_offset (incoming, &decl, &offset))
7771 if (REG_P (incoming) || MEM_P (incoming))
7773 /* This means argument is passed by invisible reference. */
7776 incoming = gen_rtx_MEM (GET_MODE (decl_rtl), incoming);
7780 if (!vt_get_decl_and_offset (decl_rtl, &decl, &offset))
7782 offset += byte_lowpart_offset (GET_MODE (incoming),
7783 GET_MODE (decl_rtl));
7792 /* Assume that DECL_RTL was a pseudo that got spilled to
7793 memory. The spill slot sharing code will force the
7794 memory to reference spill_slot_decl (%sfp), so we don't
7795 match above. That's ok, the pseudo must have referenced
7796 the entire parameter, so just reset OFFSET. */
7797 gcc_assert (decl == get_spill_slot_decl (false));
7801 if (!track_loc_p (incoming, parm, offset, false, &mode, &offset))
7804 out = &VTI (ENTRY_BLOCK_PTR)->out;
7806 dv = dv_from_decl (parm);
7808 if (target_for_debug_bind (parm)
7809 /* We can't deal with these right now, because this kind of
7810 variable is single-part. ??? We could handle parallels
7811 that describe multiple locations for the same single
7812 value, but ATM we don't. */
7813 && GET_CODE (incoming) != PARALLEL)
7817 /* ??? We shouldn't ever hit this, but it may happen because
7818 arguments passed by invisible reference aren't dealt with
7819 above: incoming-rtl will have Pmode rather than the
7820 expected mode for the type. */
7824 val = cselib_lookup (var_lowpart (mode, incoming), mode, true);
7826 /* ??? Float-typed values in memory are not handled by
7830 preserve_value (val);
7831 set_variable_part (out, val->val_rtx, dv, offset,
7832 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
7833 dv = dv_from_value (val->val_rtx);
7837 if (REG_P (incoming))
7839 incoming = var_lowpart (mode, incoming);
7840 gcc_assert (REGNO (incoming) < FIRST_PSEUDO_REGISTER);
7841 attrs_list_insert (&out->regs[REGNO (incoming)], dv, offset,
7843 set_variable_part (out, incoming, dv, offset,
7844 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
7846 else if (MEM_P (incoming))
7848 incoming = var_lowpart (mode, incoming);
7849 set_variable_part (out, incoming, dv, offset,
7850 VAR_INIT_STATUS_INITIALIZED, NULL, INSERT);
7854 if (MAY_HAVE_DEBUG_INSNS)
7856 cselib_preserve_only_values ();
7857 cselib_reset_table (cselib_get_next_uid ());
7862 /* Return true if INSN in the prologue initializes hard_frame_pointer_rtx. */
7865 fp_setter (rtx insn)
7867 rtx pat = PATTERN (insn);
7868 if (RTX_FRAME_RELATED_P (insn))
7870 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
7872 pat = XEXP (expr, 0);
7874 if (GET_CODE (pat) == SET)
7875 return SET_DEST (pat) == hard_frame_pointer_rtx;
7876 else if (GET_CODE (pat) == PARALLEL)
7879 for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
7880 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
7881 && SET_DEST (XVECEXP (pat, 0, i)) == hard_frame_pointer_rtx)
7887 /* Initialize cfa_base_rtx, create a preserved VALUE for it and
7888 ensure it isn't flushed during cselib_reset_table.
7889 Can be called only if frame_pointer_rtx resp. arg_pointer_rtx
7890 has been eliminated. */
7893 vt_init_cfa_base (void)
7897 #ifdef FRAME_POINTER_CFA_OFFSET
7898 cfa_base_rtx = frame_pointer_rtx;
7900 cfa_base_rtx = arg_pointer_rtx;
7902 if (!MAY_HAVE_DEBUG_INSNS)
7905 val = cselib_lookup (cfa_base_rtx, GET_MODE (cfa_base_rtx), 1);
7906 preserve_value (val);
7907 cselib_preserve_cfa_base_value (val);
7908 val->locs->setting_insn = get_insns ();
7909 var_reg_decl_set (&VTI (ENTRY_BLOCK_PTR)->out, cfa_base_rtx,
7910 VAR_INIT_STATUS_INITIALIZED, dv_from_value (val->val_rtx),
7911 0, NULL_RTX, INSERT);
7914 /* Allocate and initialize the data structures for variable tracking
7915 and parse the RTL to get the micro operations. */
7918 vt_initialize (void)
7920 basic_block bb, prologue_bb = NULL;
7921 HOST_WIDE_INT fp_cfa_offset = -1;
7923 alloc_aux_for_blocks (sizeof (struct variable_tracking_info_def));
7925 attrs_pool = create_alloc_pool ("attrs_def pool",
7926 sizeof (struct attrs_def), 1024);
7927 var_pool = create_alloc_pool ("variable_def pool",
7928 sizeof (struct variable_def)
7929 + (MAX_VAR_PARTS - 1)
7930 * sizeof (((variable)NULL)->var_part[0]), 64);
7931 loc_chain_pool = create_alloc_pool ("location_chain_def pool",
7932 sizeof (struct location_chain_def),
7934 shared_hash_pool = create_alloc_pool ("shared_hash_def pool",
7935 sizeof (struct shared_hash_def), 256);
7936 empty_shared_hash = (shared_hash) pool_alloc (shared_hash_pool);
7937 empty_shared_hash->refcount = 1;
7938 empty_shared_hash->htab
7939 = htab_create (1, variable_htab_hash, variable_htab_eq,
7940 variable_htab_free);
7941 changed_variables = htab_create (10, variable_htab_hash, variable_htab_eq,
7942 variable_htab_free);
7943 if (MAY_HAVE_DEBUG_INSNS)
7945 value_chain_pool = create_alloc_pool ("value_chain_def pool",
7946 sizeof (struct value_chain_def),
7948 value_chains = htab_create (32, value_chain_htab_hash,
7949 value_chain_htab_eq, NULL);
7952 /* Init the IN and OUT sets. */
7955 VTI (bb)->visited = false;
7956 VTI (bb)->flooded = false;
7957 dataflow_set_init (&VTI (bb)->in);
7958 dataflow_set_init (&VTI (bb)->out);
7959 VTI (bb)->permp = NULL;
7962 if (MAY_HAVE_DEBUG_INSNS)
7964 cselib_init (CSELIB_RECORD_MEMORY | CSELIB_PRESERVE_CONSTANTS);
7965 scratch_regs = BITMAP_ALLOC (NULL);
7966 valvar_pool = create_alloc_pool ("small variable_def pool",
7967 sizeof (struct variable_def), 256);
7968 preserved_values = VEC_alloc (rtx, heap, 256);
7972 scratch_regs = NULL;
7976 if (!frame_pointer_needed)
7980 if (!vt_stack_adjustments ())
7983 #ifdef FRAME_POINTER_CFA_OFFSET
7984 reg = frame_pointer_rtx;
7986 reg = arg_pointer_rtx;
7988 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
7991 if (GET_CODE (elim) == PLUS)
7992 elim = XEXP (elim, 0);
7993 if (elim == stack_pointer_rtx)
7994 vt_init_cfa_base ();
7997 else if (!crtl->stack_realign_tried)
8001 #ifdef FRAME_POINTER_CFA_OFFSET
8002 reg = frame_pointer_rtx;
8003 fp_cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
8005 reg = arg_pointer_rtx;
8006 fp_cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
8008 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8011 if (GET_CODE (elim) == PLUS)
8013 fp_cfa_offset -= INTVAL (XEXP (elim, 1));
8014 elim = XEXP (elim, 0);
8016 if (elim != hard_frame_pointer_rtx)
8019 prologue_bb = single_succ (ENTRY_BLOCK_PTR);
8023 hard_frame_pointer_adjustment = -1;
8028 HOST_WIDE_INT pre, post = 0;
8029 basic_block first_bb, last_bb;
8031 if (MAY_HAVE_DEBUG_INSNS)
8033 cselib_record_sets_hook = add_with_sets;
8034 if (dump_file && (dump_flags & TDF_DETAILS))
8035 fprintf (dump_file, "first value: %i\n",
8036 cselib_get_next_uid ());
8043 if (bb->next_bb == EXIT_BLOCK_PTR
8044 || ! single_pred_p (bb->next_bb))
8046 e = find_edge (bb, bb->next_bb);
8047 if (! e || (e->flags & EDGE_FALLTHRU) == 0)
8053 /* Add the micro-operations to the vector. */
8054 FOR_BB_BETWEEN (bb, first_bb, last_bb->next_bb, next_bb)
8056 HOST_WIDE_INT offset = VTI (bb)->out.stack_adjust;
8057 VTI (bb)->out.stack_adjust = VTI (bb)->in.stack_adjust;
8058 for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb));
8059 insn = NEXT_INSN (insn))
8063 if (!frame_pointer_needed)
8065 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
8069 mo.type = MO_ADJUST;
8072 if (dump_file && (dump_flags & TDF_DETAILS))
8073 log_op_type (PATTERN (insn), bb, insn,
8074 MO_ADJUST, dump_file);
8075 VEC_safe_push (micro_operation, heap, VTI (bb)->mos,
8077 VTI (bb)->out.stack_adjust += pre;
8081 cselib_hook_called = false;
8082 adjust_insn (bb, insn);
8083 if (MAY_HAVE_DEBUG_INSNS)
8085 cselib_process_insn (insn);
8086 if (dump_file && (dump_flags & TDF_DETAILS))
8088 print_rtl_single (dump_file, insn);
8089 dump_cselib_table (dump_file);
8092 if (!cselib_hook_called)
8093 add_with_sets (insn, 0, 0);
8096 if (!frame_pointer_needed && post)
8099 mo.type = MO_ADJUST;
8102 if (dump_file && (dump_flags & TDF_DETAILS))
8103 log_op_type (PATTERN (insn), bb, insn,
8104 MO_ADJUST, dump_file);
8105 VEC_safe_push (micro_operation, heap, VTI (bb)->mos,
8107 VTI (bb)->out.stack_adjust += post;
8110 if (bb == prologue_bb
8111 && hard_frame_pointer_adjustment == -1
8112 && RTX_FRAME_RELATED_P (insn)
8113 && fp_setter (insn))
8115 vt_init_cfa_base ();
8116 hard_frame_pointer_adjustment = fp_cfa_offset;
8120 gcc_assert (offset == VTI (bb)->out.stack_adjust);
8125 if (MAY_HAVE_DEBUG_INSNS)
8127 cselib_preserve_only_values ();
8128 cselib_reset_table (cselib_get_next_uid ());
8129 cselib_record_sets_hook = NULL;
8133 hard_frame_pointer_adjustment = -1;
8134 VTI (ENTRY_BLOCK_PTR)->flooded = true;
8135 vt_add_function_parameters ();
8136 cfa_base_rtx = NULL_RTX;
8140 /* Get rid of all debug insns from the insn stream. */
8143 delete_debug_insns (void)
8148 if (!MAY_HAVE_DEBUG_INSNS)
8153 FOR_BB_INSNS_SAFE (bb, insn, next)
8154 if (DEBUG_INSN_P (insn))
8159 /* Run a fast, BB-local only version of var tracking, to take care of
8160 information that we don't do global analysis on, such that not all
8161 information is lost. If SKIPPED holds, we're skipping the global
8162 pass entirely, so we should try to use information it would have
8163 handled as well.. */
8166 vt_debug_insns_local (bool skipped ATTRIBUTE_UNUSED)
8168 /* ??? Just skip it all for now. */
8169 delete_debug_insns ();
8172 /* Free the data structures needed for variable tracking. */
8181 VEC_free (micro_operation, heap, VTI (bb)->mos);
8186 dataflow_set_destroy (&VTI (bb)->in);
8187 dataflow_set_destroy (&VTI (bb)->out);
8188 if (VTI (bb)->permp)
8190 dataflow_set_destroy (VTI (bb)->permp);
8191 XDELETE (VTI (bb)->permp);
8194 free_aux_for_blocks ();
8195 htab_delete (empty_shared_hash->htab);
8196 htab_delete (changed_variables);
8197 free_alloc_pool (attrs_pool);
8198 free_alloc_pool (var_pool);
8199 free_alloc_pool (loc_chain_pool);
8200 free_alloc_pool (shared_hash_pool);
8202 if (MAY_HAVE_DEBUG_INSNS)
8204 htab_delete (value_chains);
8205 free_alloc_pool (value_chain_pool);
8206 free_alloc_pool (valvar_pool);
8207 VEC_free (rtx, heap, preserved_values);
8209 BITMAP_FREE (scratch_regs);
8210 scratch_regs = NULL;
8214 XDELETEVEC (vui_vec);
8219 /* The entry point to variable tracking pass. */
8221 static inline unsigned int
8222 variable_tracking_main_1 (void)
8226 if (flag_var_tracking_assignments < 0)
8228 delete_debug_insns ();
8232 if (n_basic_blocks > 500 && n_edges / n_basic_blocks >= 20)
8234 vt_debug_insns_local (true);
8238 mark_dfs_back_edges ();
8239 if (!vt_initialize ())
8242 vt_debug_insns_local (true);
8246 success = vt_find_locations ();
8248 if (!success && flag_var_tracking_assignments > 0)
8252 delete_debug_insns ();
8254 /* This is later restored by our caller. */
8255 flag_var_tracking_assignments = 0;
8257 success = vt_initialize ();
8258 gcc_assert (success);
8260 success = vt_find_locations ();
8266 vt_debug_insns_local (false);
8270 if (dump_file && (dump_flags & TDF_DETAILS))
8272 dump_dataflow_sets ();
8273 dump_flow_info (dump_file, dump_flags);
8279 vt_debug_insns_local (false);
8284 variable_tracking_main (void)
8287 int save = flag_var_tracking_assignments;
8289 ret = variable_tracking_main_1 ();
8291 flag_var_tracking_assignments = save;
8297 gate_handle_var_tracking (void)
8299 return (flag_var_tracking);
8304 struct rtl_opt_pass pass_variable_tracking =
8308 "vartrack", /* name */
8309 gate_handle_var_tracking, /* gate */
8310 variable_tracking_main, /* execute */
8313 0, /* static_pass_number */
8314 TV_VAR_TRACKING, /* tv_id */
8315 0, /* properties_required */
8316 0, /* properties_provided */
8317 0, /* properties_destroyed */
8318 0, /* todo_flags_start */
8319 TODO_dump_func | TODO_verify_rtl_sharing/* todo_flags_finish */