2 Copyright (C) 2006-2021 Free Software Foundation, Inc.
3 Contributed by Georges-Andre Silber <Georges-Andre.Silber@ensmp.fr>
4 and Sebastian Pop <sebastian.pop@amd.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This pass performs loop distribution: for example, the loop
39 Loop distribution is the dual of loop fusion. It separates statements
40 of a loop (or loop nest) into multiple loops (or loop nests) with the
41 same loop header. The major goal is to separate statements which may
42 be vectorized from those that can't. This pass implements distribution
43 in the following steps:
45 1) Seed partitions with specific type statements. For now we support
46 two types seed statements: statement defining variable used outside
47 of loop; statement storing to memory.
48 2) Build reduced dependence graph (RDG) for loop to be distributed.
49 The vertices (RDG:V) model all statements in the loop and the edges
50 (RDG:E) model flow and control dependencies between statements.
51 3) Apart from RDG, compute data dependencies between memory references.
52 4) Starting from seed statement, build up partition by adding depended
53 statements according to RDG's dependence information. Partition is
54 classified as parallel type if it can be executed paralleled; or as
55 sequential type if it can't. Parallel type partition is further
56 classified as different builtin kinds if it can be implemented as
57 builtin function calls.
58 5) Build partition dependence graph (PG) based on data dependencies.
59 The vertices (PG:V) model all partitions and the edges (PG:E) model
60 all data dependencies between every partitions pair. In general,
61 data dependence is either compilation time known or unknown. In C
62 family languages, there exists quite amount compilation time unknown
63 dependencies because of possible alias relation of data references.
64 We categorize PG's edge to two types: "true" edge that represents
65 compilation time known data dependencies; "alias" edge for all other
67 6) Traverse subgraph of PG as if all "alias" edges don't exist. Merge
68 partitions in each strong connected component (SCC) correspondingly.
69 Build new PG for merged partitions.
70 7) Traverse PG again and this time with both "true" and "alias" edges
71 included. We try to break SCCs by removing some edges. Because
72 SCCs by "true" edges are all fused in step 6), we can break SCCs
73 by removing some "alias" edges. It's NP-hard to choose optimal
74 edge set, fortunately simple approximation is good enough for us
75 given the small problem scale.
76 8) Collect all data dependencies of the removed "alias" edges. Create
77 runtime alias checks for collected data dependencies.
78 9) Version loop under the condition of runtime alias checks. Given
79 loop distribution generally introduces additional overhead, it is
80 only useful if vectorization is achieved in distributed loop. We
81 version loop with internal function call IFN_LOOP_DIST_ALIAS. If
82 no distributed loop can be vectorized, we simply remove distributed
83 loops and recover to the original one.
86 1) We only distribute innermost two-level loop nest now. We should
87 extend it for arbitrary loop nests in the future.
88 2) We only fuse partitions in SCC now. A better fusion algorithm is
89 desired to minimize loop overhead, maximize parallelism and maximize
94 #include "coretypes.h"
99 #include "tree-pass.h"
101 #include "gimple-pretty-print.h"
102 #include "fold-const.h"
104 #include "gimple-iterator.h"
105 #include "gimplify-me.h"
106 #include "stor-layout.h"
107 #include "tree-cfg.h"
108 #include "tree-ssa-loop-manip.h"
109 #include "tree-ssa-loop-ivopts.h"
110 #include "tree-ssa-loop.h"
111 #include "tree-into-ssa.h"
112 #include "tree-ssa.h"
114 #include "tree-scalar-evolution.h"
115 #include "tree-vectorizer.h"
117 #include "gimple-fold.h"
118 #include "tree-affine.h"
121 #define MAX_DATAREFS_NUM \
122 ((unsigned) param_loop_max_datarefs_for_datadeps)
124 /* Threshold controlling number of distributed partitions. Given it may
125 be unnecessary if a memory stream cost model is invented in the future,
126 we define it as a temporary macro, rather than a parameter. */
127 #define NUM_PARTITION_THRESHOLD (4)
129 /* Hashtable helpers. */
131 struct ddr_hasher
: nofree_ptr_hash
<struct data_dependence_relation
>
133 static inline hashval_t
hash (const data_dependence_relation
*);
134 static inline bool equal (const data_dependence_relation
*,
135 const data_dependence_relation
*);
138 /* Hash function for data dependence. */
141 ddr_hasher::hash (const data_dependence_relation
*ddr
)
144 h
.add_ptr (DDR_A (ddr
));
145 h
.add_ptr (DDR_B (ddr
));
149 /* Hash table equality function for data dependence. */
152 ddr_hasher::equal (const data_dependence_relation
*ddr1
,
153 const data_dependence_relation
*ddr2
)
155 return (DDR_A (ddr1
) == DDR_A (ddr2
) && DDR_B (ddr1
) == DDR_B (ddr2
));
160 #define DR_INDEX(dr) ((uintptr_t) (dr)->aux)
162 /* A Reduced Dependence Graph (RDG) vertex representing a statement. */
165 /* The statement represented by this vertex. */
168 /* Vector of data-references in this statement. */
169 vec
<data_reference_p
> datarefs
;
171 /* True when the statement contains a write to memory. */
174 /* True when the statement contains a read from memory. */
178 #define RDGV_STMT(V) ((struct rdg_vertex *) ((V)->data))->stmt
179 #define RDGV_DATAREFS(V) ((struct rdg_vertex *) ((V)->data))->datarefs
180 #define RDGV_HAS_MEM_WRITE(V) ((struct rdg_vertex *) ((V)->data))->has_mem_write
181 #define RDGV_HAS_MEM_READS(V) ((struct rdg_vertex *) ((V)->data))->has_mem_reads
182 #define RDG_STMT(RDG, I) RDGV_STMT (&(RDG->vertices[I]))
183 #define RDG_DATAREFS(RDG, I) RDGV_DATAREFS (&(RDG->vertices[I]))
184 #define RDG_MEM_WRITE_STMT(RDG, I) RDGV_HAS_MEM_WRITE (&(RDG->vertices[I]))
185 #define RDG_MEM_READS_STMT(RDG, I) RDGV_HAS_MEM_READS (&(RDG->vertices[I]))
187 /* Data dependence type. */
191 /* Read After Write (RAW). */
194 /* Control dependence (execute conditional on). */
198 /* Dependence information attached to an edge of the RDG. */
202 /* Type of the dependence. */
203 enum rdg_dep_type type
;
206 #define RDGE_TYPE(E) ((struct rdg_edge *) ((E)->data))->type
208 /* Kind of distributed loop. */
209 enum partition_kind
{
211 /* Partial memset stands for a paritition can be distributed into a loop
212 of memset calls, rather than a single memset call. It's handled just
213 like a normal parition, i.e, distributed as separate loop, no memset
216 Note: This is a hacking fix trying to distribute ZERO-ing stmt in a
217 loop nest as deep as possible. As a result, parloop achieves better
218 parallelization by parallelizing deeper loop nest. This hack should
219 be unnecessary and removed once distributed memset can be understood
220 and analyzed in data reference analysis. See PR82604 for more. */
221 PKIND_PARTIAL_MEMSET
,
222 PKIND_MEMSET
, PKIND_MEMCPY
, PKIND_MEMMOVE
225 /* Type of distributed loop. */
226 enum partition_type
{
227 /* The distributed loop can be executed parallelly. */
229 /* The distributed loop has to be executed sequentially. */
233 /* Builtin info for loop distribution. */
236 /* data-references a kind != PKIND_NORMAL partition is about. */
237 data_reference_p dst_dr
;
238 data_reference_p src_dr
;
239 /* Base address and size of memory objects operated by the builtin. Note
240 both dest and source memory objects must have the same size. */
244 /* Base and offset part of dst_base after stripping constant offset. This
245 is only used in memset builtin distribution for now. */
247 unsigned HOST_WIDE_INT dst_base_offset
;
250 /* Partition for loop distribution. */
253 /* Statements of the partition. */
255 /* True if the partition defines variable which is used outside of loop. */
258 enum partition_kind kind
;
259 enum partition_type type
;
260 /* Data references in the partition. */
262 /* Information of builtin parition. */
263 struct builtin_info
*builtin
;
266 /* Partitions are fused because of different reasons. */
269 FUSE_NON_BUILTIN
= 0,
276 /* Description on different fusing reason. */
277 static const char *fuse_message
[] = {
278 "they are non-builtins",
279 "they have reductions",
280 "they have shared memory refs",
281 "they are in the same dependence scc",
282 "there is no point to distribute loop"};
285 /* Dump vertex I in RDG to FILE. */
288 dump_rdg_vertex (FILE *file
, struct graph
*rdg
, int i
)
290 struct vertex
*v
= &(rdg
->vertices
[i
]);
291 struct graph_edge
*e
;
293 fprintf (file
, "(vertex %d: (%s%s) (in:", i
,
294 RDG_MEM_WRITE_STMT (rdg
, i
) ? "w" : "",
295 RDG_MEM_READS_STMT (rdg
, i
) ? "r" : "");
298 for (e
= v
->pred
; e
; e
= e
->pred_next
)
299 fprintf (file
, " %d", e
->src
);
301 fprintf (file
, ") (out:");
304 for (e
= v
->succ
; e
; e
= e
->succ_next
)
305 fprintf (file
, " %d", e
->dest
);
307 fprintf (file
, ")\n");
308 print_gimple_stmt (file
, RDGV_STMT (v
), 0, TDF_VOPS
|TDF_MEMSYMS
);
309 fprintf (file
, ")\n");
312 /* Call dump_rdg_vertex on stderr. */
315 debug_rdg_vertex (struct graph
*rdg
, int i
)
317 dump_rdg_vertex (stderr
, rdg
, i
);
320 /* Dump the reduced dependence graph RDG to FILE. */
323 dump_rdg (FILE *file
, struct graph
*rdg
)
325 fprintf (file
, "(rdg\n");
326 for (int i
= 0; i
< rdg
->n_vertices
; i
++)
327 dump_rdg_vertex (file
, rdg
, i
);
328 fprintf (file
, ")\n");
331 /* Call dump_rdg on stderr. */
334 debug_rdg (struct graph
*rdg
)
336 dump_rdg (stderr
, rdg
);
340 dot_rdg_1 (FILE *file
, struct graph
*rdg
)
343 pretty_printer buffer
;
344 pp_needs_newline (&buffer
) = false;
345 buffer
.buffer
->stream
= file
;
347 fprintf (file
, "digraph RDG {\n");
349 for (i
= 0; i
< rdg
->n_vertices
; i
++)
351 struct vertex
*v
= &(rdg
->vertices
[i
]);
352 struct graph_edge
*e
;
354 fprintf (file
, "%d [label=\"[%d] ", i
, i
);
355 pp_gimple_stmt_1 (&buffer
, RDGV_STMT (v
), 0, TDF_SLIM
);
357 fprintf (file
, "\"]\n");
359 /* Highlight reads from memory. */
360 if (RDG_MEM_READS_STMT (rdg
, i
))
361 fprintf (file
, "%d [style=filled, fillcolor=green]\n", i
);
363 /* Highlight stores to memory. */
364 if (RDG_MEM_WRITE_STMT (rdg
, i
))
365 fprintf (file
, "%d [style=filled, fillcolor=red]\n", i
);
368 for (e
= v
->succ
; e
; e
= e
->succ_next
)
369 switch (RDGE_TYPE (e
))
372 /* These are the most common dependences: don't print these. */
373 fprintf (file
, "%d -> %d \n", i
, e
->dest
);
377 fprintf (file
, "%d -> %d [label=control] \n", i
, e
->dest
);
385 fprintf (file
, "}\n\n");
388 /* Display the Reduced Dependence Graph using dotty. */
391 dot_rdg (struct graph
*rdg
)
393 /* When debugging, you may want to enable the following code. */
395 FILE *file
= popen ("dot -Tx11", "w");
398 dot_rdg_1 (file
, rdg
);
400 close (fileno (file
));
403 dot_rdg_1 (stderr
, rdg
);
407 /* Returns the index of STMT in RDG. */
410 rdg_vertex_for_stmt (struct graph
*rdg ATTRIBUTE_UNUSED
, gimple
*stmt
)
412 int index
= gimple_uid (stmt
);
413 gcc_checking_assert (index
== -1 || RDG_STMT (rdg
, index
) == stmt
);
417 /* Creates dependence edges in RDG for all the uses of DEF. IDEF is
418 the index of DEF in RDG. */
421 create_rdg_edges_for_scalar (struct graph
*rdg
, tree def
, int idef
)
423 use_operand_p imm_use_p
;
424 imm_use_iterator iterator
;
426 FOR_EACH_IMM_USE_FAST (imm_use_p
, iterator
, def
)
428 struct graph_edge
*e
;
429 int use
= rdg_vertex_for_stmt (rdg
, USE_STMT (imm_use_p
));
434 e
= add_edge (rdg
, idef
, use
);
435 e
->data
= XNEW (struct rdg_edge
);
436 RDGE_TYPE (e
) = flow_dd
;
440 /* Creates an edge for the control dependences of BB to the vertex V. */
443 create_edge_for_control_dependence (struct graph
*rdg
, basic_block bb
,
444 int v
, control_dependences
*cd
)
448 EXECUTE_IF_SET_IN_BITMAP (cd
->get_edges_dependent_on (bb
->index
),
451 basic_block cond_bb
= cd
->get_edge_src (edge_n
);
452 gimple
*stmt
= last_stmt (cond_bb
);
453 if (stmt
&& is_ctrl_stmt (stmt
))
455 struct graph_edge
*e
;
456 int c
= rdg_vertex_for_stmt (rdg
, stmt
);
460 e
= add_edge (rdg
, c
, v
);
461 e
->data
= XNEW (struct rdg_edge
);
462 RDGE_TYPE (e
) = control_dd
;
467 /* Creates the edges of the reduced dependence graph RDG. */
470 create_rdg_flow_edges (struct graph
*rdg
)
476 for (i
= 0; i
< rdg
->n_vertices
; i
++)
477 FOR_EACH_PHI_OR_STMT_DEF (def_p
, RDG_STMT (rdg
, i
),
479 create_rdg_edges_for_scalar (rdg
, DEF_FROM_PTR (def_p
), i
);
482 /* Creates the edges of the reduced dependence graph RDG. */
485 create_rdg_cd_edges (struct graph
*rdg
, control_dependences
*cd
, loop_p loop
)
489 for (i
= 0; i
< rdg
->n_vertices
; i
++)
491 gimple
*stmt
= RDG_STMT (rdg
, i
);
492 if (gimple_code (stmt
) == GIMPLE_PHI
)
496 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->preds
)
497 if (flow_bb_inside_loop_p (loop
, e
->src
))
498 create_edge_for_control_dependence (rdg
, e
->src
, i
, cd
);
501 create_edge_for_control_dependence (rdg
, gimple_bb (stmt
), i
, cd
);
506 class loop_distribution
509 /* The loop (nest) to be distributed. */
510 vec
<loop_p
> loop_nest
;
512 /* Vector of data references in the loop to be distributed. */
513 vec
<data_reference_p
> datarefs_vec
;
515 /* If there is nonaddressable data reference in above vector. */
516 bool has_nonaddressable_dataref_p
;
518 /* Store index of data reference in aux field. */
520 /* Hash table for data dependence relation in the loop to be distributed. */
521 hash_table
<ddr_hasher
> *ddrs_table
;
523 /* Array mapping basic block's index to its topological order. */
524 int *bb_top_order_index
;
525 /* And size of the array. */
526 int bb_top_order_index_size
;
528 /* Build the vertices of the reduced dependence graph RDG. Return false
530 bool create_rdg_vertices (struct graph
*rdg
, vec
<gimple
*> stmts
, loop_p loop
);
532 /* Initialize STMTS with all the statements of LOOP. We use topological
533 order to discover all statements. The order is important because
534 generate_loops_for_partition is using the same traversal for identifying
535 statements in loop copies. */
536 void stmts_from_loop (class loop
*loop
, vec
<gimple
*> *stmts
);
539 /* Build the Reduced Dependence Graph (RDG) with one vertex per statement of
540 LOOP, and one edge per flow dependence or control dependence from control
541 dependence CD. During visiting each statement, data references are also
542 collected and recorded in global data DATAREFS_VEC. */
543 struct graph
* build_rdg (class loop
*loop
, control_dependences
*cd
);
545 /* Merge PARTITION into the partition DEST. RDG is the reduced dependence
546 graph and we update type for result partition if it is non-NULL. */
547 void partition_merge_into (struct graph
*rdg
,
548 partition
*dest
, partition
*partition
,
552 /* Return data dependence relation for data references A and B. The two
553 data references must be in lexicographic order wrto reduced dependence
554 graph RDG. We firstly try to find ddr from global ddr hash table. If
555 it doesn't exist, compute the ddr and cache it. */
556 data_dependence_relation
* get_data_dependence (struct graph
*rdg
,
561 /* In reduced dependence graph RDG for loop distribution, return true if
562 dependence between references DR1 and DR2 leads to a dependence cycle
563 and such dependence cycle can't be resolved by runtime alias check. */
564 bool data_dep_in_cycle_p (struct graph
*rdg
, data_reference_p dr1
,
565 data_reference_p dr2
);
568 /* Given reduced dependence graph RDG, PARTITION1 and PARTITION2, update
569 PARTITION1's type after merging PARTITION2 into PARTITION1. */
570 void update_type_for_merge (struct graph
*rdg
,
571 partition
*partition1
, partition
*partition2
);
574 /* Returns a partition with all the statements needed for computing
575 the vertex V of the RDG, also including the loop exit conditions. */
576 partition
*build_rdg_partition_for_vertex (struct graph
*rdg
, int v
);
578 /* Given data references DST_DR and SRC_DR in loop nest LOOP and RDG, classify
579 if it forms builtin memcpy or memmove call. */
580 void classify_builtin_ldst (loop_p loop
, struct graph
*rdg
, partition
*partition
,
581 data_reference_p dst_dr
, data_reference_p src_dr
);
583 /* Classifies the builtin kind we can generate for PARTITION of RDG and LOOP.
584 For the moment we detect memset, memcpy and memmove patterns. Bitmap
585 STMT_IN_ALL_PARTITIONS contains statements belonging to all partitions.
586 Returns true if there is a reduction in all partitions and we
587 possibly did not mark PARTITION as having one for this reason. */
590 classify_partition (loop_p loop
,
591 struct graph
*rdg
, partition
*partition
,
592 bitmap stmt_in_all_partitions
);
595 /* Returns true when PARTITION1 and PARTITION2 access the same memory
597 bool share_memory_accesses (struct graph
*rdg
,
598 partition
*partition1
, partition
*partition2
);
600 /* For each seed statement in STARTING_STMTS, this function builds
601 partition for it by adding depended statements according to RDG.
602 All partitions are recorded in PARTITIONS. */
603 void rdg_build_partitions (struct graph
*rdg
,
604 vec
<gimple
*> starting_stmts
,
605 vec
<partition
*> *partitions
);
607 /* Compute partition dependence created by the data references in DRS1
608 and DRS2, modify and return DIR according to that. IF ALIAS_DDR is
609 not NULL, we record dependence introduced by possible alias between
610 two data references in ALIAS_DDRS; otherwise, we simply ignore such
611 dependence as if it doesn't exist at all. */
612 int pg_add_dependence_edges (struct graph
*rdg
, int dir
, bitmap drs1
,
613 bitmap drs2
, vec
<ddr_p
> *alias_ddrs
);
616 /* Build and return partition dependence graph for PARTITIONS. RDG is
617 reduced dependence graph for the loop to be distributed. If IGNORE_ALIAS_P
618 is true, data dependence caused by possible alias between references
619 is ignored, as if it doesn't exist at all; otherwise all depdendences
621 struct graph
*build_partition_graph (struct graph
*rdg
,
622 vec
<struct partition
*> *partitions
,
623 bool ignore_alias_p
);
625 /* Given reduced dependence graph RDG merge strong connected components
626 of PARTITIONS. If IGNORE_ALIAS_P is true, data dependence caused by
627 possible alias between references is ignored, as if it doesn't exist
628 at all; otherwise all depdendences are considered. */
629 void merge_dep_scc_partitions (struct graph
*rdg
, vec
<struct partition
*>
630 *partitions
, bool ignore_alias_p
);
632 /* This is the main function breaking strong conected components in
633 PARTITIONS giving reduced depdendence graph RDG. Store data dependence
634 relations for runtime alias check in ALIAS_DDRS. */
635 void break_alias_scc_partitions (struct graph
*rdg
, vec
<struct partition
*>
636 *partitions
, vec
<ddr_p
> *alias_ddrs
);
639 /* Fuse PARTITIONS of LOOP if necessary before finalizing distribution.
640 ALIAS_DDRS contains ddrs which need runtime alias check. */
641 void finalize_partitions (class loop
*loop
, vec
<struct partition
*>
642 *partitions
, vec
<ddr_p
> *alias_ddrs
);
644 /* Distributes the code from LOOP in such a way that producer statements
645 are placed before consumer statements. Tries to separate only the
646 statements from STMTS into separate loops. Returns the number of
647 distributed loops. Set NB_CALLS to number of generated builtin calls.
648 Set *DESTROY_P to whether LOOP needs to be destroyed. */
649 int distribute_loop (class loop
*loop
, vec
<gimple
*> stmts
,
650 control_dependences
*cd
, int *nb_calls
, bool *destroy_p
,
651 bool only_patterns_p
);
653 /* Compute topological order for basic blocks. Topological order is
654 needed because data dependence is computed for data references in
655 lexicographical order. */
656 void bb_top_order_init (void);
658 void bb_top_order_destroy (void);
662 /* Getter for bb_top_order. */
664 inline int get_bb_top_order_index_size (void)
666 return bb_top_order_index_size
;
669 inline int get_bb_top_order_index (int i
)
671 return bb_top_order_index
[i
];
674 unsigned int execute (function
*fun
);
678 /* If X has a smaller topological sort number than Y, returns -1;
679 if greater, returns 1. */
681 bb_top_order_cmp_r (const void *x
, const void *y
, void *loop
)
683 loop_distribution
*_loop
=
684 (loop_distribution
*) loop
;
686 basic_block bb1
= *(const basic_block
*) x
;
687 basic_block bb2
= *(const basic_block
*) y
;
689 int bb_top_order_index_size
= _loop
->get_bb_top_order_index_size ();
691 gcc_assert (bb1
->index
< bb_top_order_index_size
692 && bb2
->index
< bb_top_order_index_size
);
693 gcc_assert (bb1
== bb2
694 || _loop
->get_bb_top_order_index(bb1
->index
)
695 != _loop
->get_bb_top_order_index(bb2
->index
));
697 return (_loop
->get_bb_top_order_index(bb1
->index
) -
698 _loop
->get_bb_top_order_index(bb2
->index
));
702 loop_distribution::create_rdg_vertices (struct graph
*rdg
, vec
<gimple
*> stmts
,
708 FOR_EACH_VEC_ELT (stmts
, i
, stmt
)
710 struct vertex
*v
= &(rdg
->vertices
[i
]);
712 /* Record statement to vertex mapping. */
713 gimple_set_uid (stmt
, i
);
715 v
->data
= XNEW (struct rdg_vertex
);
716 RDGV_STMT (v
) = stmt
;
717 RDGV_DATAREFS (v
).create (0);
718 RDGV_HAS_MEM_WRITE (v
) = false;
719 RDGV_HAS_MEM_READS (v
) = false;
720 if (gimple_code (stmt
) == GIMPLE_PHI
)
723 unsigned drp
= datarefs_vec
.length ();
724 if (!find_data_references_in_stmt (loop
, stmt
, &datarefs_vec
))
726 for (unsigned j
= drp
; j
< datarefs_vec
.length (); ++j
)
728 data_reference_p dr
= datarefs_vec
[j
];
730 RDGV_HAS_MEM_READS (v
) = true;
732 RDGV_HAS_MEM_WRITE (v
) = true;
733 RDGV_DATAREFS (v
).safe_push (dr
);
734 has_nonaddressable_dataref_p
|= may_be_nonaddressable_p (dr
->ref
);
741 loop_distribution::stmts_from_loop (class loop
*loop
, vec
<gimple
*> *stmts
)
744 basic_block
*bbs
= get_loop_body_in_custom_order (loop
, this, bb_top_order_cmp_r
);
746 for (i
= 0; i
< loop
->num_nodes
; i
++)
748 basic_block bb
= bbs
[i
];
750 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);
752 if (!virtual_operand_p (gimple_phi_result (bsi
.phi ())))
753 stmts
->safe_push (bsi
.phi ());
755 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);
758 gimple
*stmt
= gsi_stmt (bsi
);
759 if (gimple_code (stmt
) != GIMPLE_LABEL
&& !is_gimple_debug (stmt
))
760 stmts
->safe_push (stmt
);
767 /* Free the reduced dependence graph RDG. */
770 free_rdg (struct graph
*rdg
)
774 for (i
= 0; i
< rdg
->n_vertices
; i
++)
776 struct vertex
*v
= &(rdg
->vertices
[i
]);
777 struct graph_edge
*e
;
779 for (e
= v
->succ
; e
; e
= e
->succ_next
)
784 gimple_set_uid (RDGV_STMT (v
), -1);
785 (RDGV_DATAREFS (v
)).release ();
794 loop_distribution::build_rdg (class loop
*loop
, control_dependences
*cd
)
798 /* Create the RDG vertices from the stmts of the loop nest. */
799 auto_vec
<gimple
*, 10> stmts
;
800 stmts_from_loop (loop
, &stmts
);
801 rdg
= new_graph (stmts
.length ());
802 if (!create_rdg_vertices (rdg
, stmts
, loop
))
809 create_rdg_flow_edges (rdg
);
811 create_rdg_cd_edges (rdg
, cd
, loop
);
817 /* Allocate and initialize a partition from BITMAP. */
820 partition_alloc (void)
822 partition
*partition
= XCNEW (struct partition
);
823 partition
->stmts
= BITMAP_ALLOC (NULL
);
824 partition
->reduction_p
= false;
825 partition
->loc
= UNKNOWN_LOCATION
;
826 partition
->kind
= PKIND_NORMAL
;
827 partition
->type
= PTYPE_PARALLEL
;
828 partition
->datarefs
= BITMAP_ALLOC (NULL
);
832 /* Free PARTITION. */
835 partition_free (partition
*partition
)
837 BITMAP_FREE (partition
->stmts
);
838 BITMAP_FREE (partition
->datarefs
);
839 if (partition
->builtin
)
840 free (partition
->builtin
);
845 /* Returns true if the partition can be generated as a builtin. */
848 partition_builtin_p (partition
*partition
)
850 return partition
->kind
> PKIND_PARTIAL_MEMSET
;
853 /* Returns true if the partition contains a reduction. */
856 partition_reduction_p (partition
*partition
)
858 return partition
->reduction_p
;
862 loop_distribution::partition_merge_into (struct graph
*rdg
,
863 partition
*dest
, partition
*partition
, enum fuse_type ft
)
865 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
867 fprintf (dump_file
, "Fuse partitions because %s:\n", fuse_message
[ft
]);
868 fprintf (dump_file
, " Part 1: ");
869 dump_bitmap (dump_file
, dest
->stmts
);
870 fprintf (dump_file
, " Part 2: ");
871 dump_bitmap (dump_file
, partition
->stmts
);
874 dest
->kind
= PKIND_NORMAL
;
875 if (dest
->type
== PTYPE_PARALLEL
)
876 dest
->type
= partition
->type
;
878 bitmap_ior_into (dest
->stmts
, partition
->stmts
);
879 if (partition_reduction_p (partition
))
880 dest
->reduction_p
= true;
882 /* Further check if any data dependence prevents us from executing the
883 new partition parallelly. */
884 if (dest
->type
== PTYPE_PARALLEL
&& rdg
!= NULL
)
885 update_type_for_merge (rdg
, dest
, partition
);
887 bitmap_ior_into (dest
->datarefs
, partition
->datarefs
);
891 /* Returns true when DEF is an SSA_NAME defined in LOOP and used after
895 ssa_name_has_uses_outside_loop_p (tree def
, loop_p loop
)
897 imm_use_iterator imm_iter
;
900 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, def
)
902 if (is_gimple_debug (USE_STMT (use_p
)))
905 basic_block use_bb
= gimple_bb (USE_STMT (use_p
));
906 if (!flow_bb_inside_loop_p (loop
, use_bb
))
913 /* Returns true when STMT defines a scalar variable used after the
917 stmt_has_scalar_dependences_outside_loop (loop_p loop
, gimple
*stmt
)
922 if (gimple_code (stmt
) == GIMPLE_PHI
)
923 return ssa_name_has_uses_outside_loop_p (gimple_phi_result (stmt
), loop
);
925 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
926 if (ssa_name_has_uses_outside_loop_p (DEF_FROM_PTR (def_p
), loop
))
932 /* Return a copy of LOOP placed before LOOP. */
935 copy_loop_before (class loop
*loop
)
938 edge preheader
= loop_preheader_edge (loop
);
940 initialize_original_copy_tables ();
941 res
= slpeel_tree_duplicate_loop_to_edge_cfg (loop
, NULL
, preheader
);
942 gcc_assert (res
!= NULL
);
943 free_original_copy_tables ();
944 delete_update_ssa ();
949 /* Creates an empty basic block after LOOP. */
952 create_bb_after_loop (class loop
*loop
)
954 edge exit
= single_exit (loop
);
962 /* Generate code for PARTITION from the code in LOOP. The loop is
963 copied when COPY_P is true. All the statements not flagged in the
964 PARTITION bitmap are removed from the loop or from its copy. The
965 statements are indexed in sequence inside a basic block, and the
966 basic blocks of a loop are taken in dom order. */
969 generate_loops_for_partition (class loop
*loop
, partition
*partition
,
977 int orig_loop_num
= loop
->orig_loop_num
;
978 loop
= copy_loop_before (loop
);
979 gcc_assert (loop
!= NULL
);
980 loop
->orig_loop_num
= orig_loop_num
;
981 create_preheader (loop
, CP_SIMPLE_PREHEADERS
);
982 create_bb_after_loop (loop
);
986 /* Origin number is set to the new versioned loop's num. */
987 gcc_assert (loop
->orig_loop_num
!= loop
->num
);
990 /* Remove stmts not in the PARTITION bitmap. */
991 bbs
= get_loop_body_in_dom_order (loop
);
993 if (MAY_HAVE_DEBUG_BIND_STMTS
)
994 for (i
= 0; i
< loop
->num_nodes
; i
++)
996 basic_block bb
= bbs
[i
];
998 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);
1001 gphi
*phi
= bsi
.phi ();
1002 if (!virtual_operand_p (gimple_phi_result (phi
))
1003 && !bitmap_bit_p (partition
->stmts
, gimple_uid (phi
)))
1004 reset_debug_uses (phi
);
1007 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1009 gimple
*stmt
= gsi_stmt (bsi
);
1010 if (gimple_code (stmt
) != GIMPLE_LABEL
1011 && !is_gimple_debug (stmt
)
1012 && !bitmap_bit_p (partition
->stmts
, gimple_uid (stmt
)))
1013 reset_debug_uses (stmt
);
1017 for (i
= 0; i
< loop
->num_nodes
; i
++)
1019 basic_block bb
= bbs
[i
];
1020 edge inner_exit
= NULL
;
1022 if (loop
!= bb
->loop_father
)
1023 inner_exit
= single_exit (bb
->loop_father
);
1025 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);)
1027 gphi
*phi
= bsi
.phi ();
1028 if (!virtual_operand_p (gimple_phi_result (phi
))
1029 && !bitmap_bit_p (partition
->stmts
, gimple_uid (phi
)))
1030 remove_phi_node (&bsi
, true);
1035 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);)
1037 gimple
*stmt
= gsi_stmt (bsi
);
1038 if (gimple_code (stmt
) != GIMPLE_LABEL
1039 && !is_gimple_debug (stmt
)
1040 && !bitmap_bit_p (partition
->stmts
, gimple_uid (stmt
)))
1042 /* In distribution of loop nest, if bb is inner loop's exit_bb,
1043 we choose its exit edge/path in order to avoid generating
1044 infinite loop. For all other cases, we choose an arbitrary
1045 path through the empty CFG part that this unnecessary
1046 control stmt controls. */
1047 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
1049 if (inner_exit
&& inner_exit
->flags
& EDGE_TRUE_VALUE
)
1050 gimple_cond_make_true (cond_stmt
);
1052 gimple_cond_make_false (cond_stmt
);
1055 else if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1057 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
1058 gimple_switch_set_index
1059 (switch_stmt
, CASE_LOW (gimple_switch_label (switch_stmt
, 1)));
1064 unlink_stmt_vdef (stmt
);
1065 gsi_remove (&bsi
, true);
1066 release_defs (stmt
);
1077 /* If VAL memory representation contains the same value in all bytes,
1078 return that value, otherwise return -1.
1079 E.g. for 0x24242424 return 0x24, for IEEE double
1080 747708026454360457216.0 return 0x44, etc. */
1083 const_with_all_bytes_same (tree val
)
1085 unsigned char buf
[64];
1088 if (integer_zerop (val
)
1089 || (TREE_CODE (val
) == CONSTRUCTOR
1090 && !TREE_CLOBBER_P (val
)
1091 && CONSTRUCTOR_NELTS (val
) == 0))
1094 if (real_zerop (val
))
1096 /* Only return 0 for +0.0, not for -0.0, which doesn't have
1097 an all bytes same memory representation. Don't transform
1098 -0.0 stores into +0.0 even for !HONOR_SIGNED_ZEROS. */
1099 switch (TREE_CODE (val
))
1102 if (!real_isneg (TREE_REAL_CST_PTR (val
)))
1106 if (!const_with_all_bytes_same (TREE_REALPART (val
))
1107 && !const_with_all_bytes_same (TREE_IMAGPART (val
)))
1112 unsigned int count
= vector_cst_encoded_nelts (val
);
1114 for (j
= 0; j
< count
; ++j
)
1115 if (const_with_all_bytes_same (VECTOR_CST_ENCODED_ELT (val
, j
)))
1126 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
1129 len
= native_encode_expr (val
, buf
, sizeof (buf
));
1132 for (i
= 1; i
< len
; i
++)
1133 if (buf
[i
] != buf
[0])
1138 /* Generate a call to memset for PARTITION in LOOP. */
1141 generate_memset_builtin (class loop
*loop
, partition
*partition
)
1143 gimple_stmt_iterator gsi
;
1144 tree mem
, fn
, nb_bytes
;
1146 struct builtin_info
*builtin
= partition
->builtin
;
1149 /* The new statements will be placed before LOOP. */
1150 gsi
= gsi_last_bb (loop_preheader_edge (loop
)->src
);
1152 nb_bytes
= rewrite_to_non_trapping_overflow (builtin
->size
);
1153 nb_bytes
= force_gimple_operand_gsi (&gsi
, nb_bytes
, true, NULL_TREE
,
1154 false, GSI_CONTINUE_LINKING
);
1155 mem
= rewrite_to_non_trapping_overflow (builtin
->dst_base
);
1156 mem
= force_gimple_operand_gsi (&gsi
, mem
, true, NULL_TREE
,
1157 false, GSI_CONTINUE_LINKING
);
1159 /* This exactly matches the pattern recognition in classify_partition. */
1160 val
= gimple_assign_rhs1 (DR_STMT (builtin
->dst_dr
));
1161 /* Handle constants like 0x15151515 and similarly
1162 floating point constants etc. where all bytes are the same. */
1163 int bytev
= const_with_all_bytes_same (val
);
1165 val
= build_int_cst (integer_type_node
, bytev
);
1166 else if (TREE_CODE (val
) == INTEGER_CST
)
1167 val
= fold_convert (integer_type_node
, val
);
1168 else if (!useless_type_conversion_p (integer_type_node
, TREE_TYPE (val
)))
1170 tree tem
= make_ssa_name (integer_type_node
);
1171 gimple
*cstmt
= gimple_build_assign (tem
, NOP_EXPR
, val
);
1172 gsi_insert_after (&gsi
, cstmt
, GSI_CONTINUE_LINKING
);
1176 fn
= build_fold_addr_expr (builtin_decl_implicit (BUILT_IN_MEMSET
));
1177 fn_call
= gimple_build_call (fn
, 3, mem
, val
, nb_bytes
);
1178 gimple_set_location (fn_call
, partition
->loc
);
1179 gsi_insert_after (&gsi
, fn_call
, GSI_CONTINUE_LINKING
);
1182 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1184 fprintf (dump_file
, "generated memset");
1186 fprintf (dump_file
, " zero\n");
1188 fprintf (dump_file
, "\n");
1192 /* Generate a call to memcpy for PARTITION in LOOP. */
1195 generate_memcpy_builtin (class loop
*loop
, partition
*partition
)
1197 gimple_stmt_iterator gsi
;
1199 tree dest
, src
, fn
, nb_bytes
;
1200 enum built_in_function kind
;
1201 struct builtin_info
*builtin
= partition
->builtin
;
1203 /* The new statements will be placed before LOOP. */
1204 gsi
= gsi_last_bb (loop_preheader_edge (loop
)->src
);
1206 nb_bytes
= rewrite_to_non_trapping_overflow (builtin
->size
);
1207 nb_bytes
= force_gimple_operand_gsi (&gsi
, nb_bytes
, true, NULL_TREE
,
1208 false, GSI_CONTINUE_LINKING
);
1209 dest
= rewrite_to_non_trapping_overflow (builtin
->dst_base
);
1210 src
= rewrite_to_non_trapping_overflow (builtin
->src_base
);
1211 if (partition
->kind
== PKIND_MEMCPY
1212 || ! ptr_derefs_may_alias_p (dest
, src
))
1213 kind
= BUILT_IN_MEMCPY
;
1215 kind
= BUILT_IN_MEMMOVE
;
1216 /* Try harder if we're copying a constant size. */
1217 if (kind
== BUILT_IN_MEMMOVE
&& poly_int_tree_p (nb_bytes
))
1219 aff_tree asrc
, adest
;
1220 tree_to_aff_combination (src
, ptr_type_node
, &asrc
);
1221 tree_to_aff_combination (dest
, ptr_type_node
, &adest
);
1222 aff_combination_scale (&adest
, -1);
1223 aff_combination_add (&asrc
, &adest
);
1224 if (aff_comb_cannot_overlap_p (&asrc
, wi::to_poly_widest (nb_bytes
),
1225 wi::to_poly_widest (nb_bytes
)))
1226 kind
= BUILT_IN_MEMCPY
;
1229 dest
= force_gimple_operand_gsi (&gsi
, dest
, true, NULL_TREE
,
1230 false, GSI_CONTINUE_LINKING
);
1231 src
= force_gimple_operand_gsi (&gsi
, src
, true, NULL_TREE
,
1232 false, GSI_CONTINUE_LINKING
);
1233 fn
= build_fold_addr_expr (builtin_decl_implicit (kind
));
1234 fn_call
= gimple_build_call (fn
, 3, dest
, src
, nb_bytes
);
1235 gimple_set_location (fn_call
, partition
->loc
);
1236 gsi_insert_after (&gsi
, fn_call
, GSI_CONTINUE_LINKING
);
1239 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1241 if (kind
== BUILT_IN_MEMCPY
)
1242 fprintf (dump_file
, "generated memcpy\n");
1244 fprintf (dump_file
, "generated memmove\n");
1248 /* Remove and destroy the loop LOOP. */
1251 destroy_loop (class loop
*loop
)
1253 unsigned nbbs
= loop
->num_nodes
;
1254 edge exit
= single_exit (loop
);
1255 basic_block src
= loop_preheader_edge (loop
)->src
, dest
= exit
->dest
;
1259 bbs
= get_loop_body_in_dom_order (loop
);
1261 gimple_stmt_iterator dst_gsi
= gsi_after_labels (exit
->dest
);
1262 bool safe_p
= single_pred_p (exit
->dest
);
1263 for (unsigned i
= 0; i
< nbbs
; ++i
)
1265 /* We have made sure to not leave any dangling uses of SSA
1266 names defined in the loop. With the exception of virtuals.
1267 Make sure we replace all uses of virtual defs that will remain
1268 outside of the loop with the bare symbol as delete_basic_block
1269 will release them. */
1270 for (gphi_iterator gsi
= gsi_start_phis (bbs
[i
]); !gsi_end_p (gsi
);
1273 gphi
*phi
= gsi
.phi ();
1274 if (virtual_operand_p (gimple_phi_result (phi
)))
1275 mark_virtual_phi_result_for_renaming (phi
);
1277 for (gimple_stmt_iterator gsi
= gsi_start_bb (bbs
[i
]); !gsi_end_p (gsi
);)
1279 gimple
*stmt
= gsi_stmt (gsi
);
1280 tree vdef
= gimple_vdef (stmt
);
1281 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
1282 mark_virtual_operand_for_renaming (vdef
);
1283 /* Also move and eventually reset debug stmts. We can leave
1284 constant values in place in case the stmt dominates the exit.
1285 ??? Non-constant values from the last iteration can be
1286 replaced with final values if we can compute them. */
1287 if (gimple_debug_bind_p (stmt
))
1289 tree val
= gimple_debug_bind_get_value (stmt
);
1290 gsi_move_before (&gsi
, &dst_gsi
);
1293 || !is_gimple_min_invariant (val
)
1294 || !dominated_by_p (CDI_DOMINATORS
, exit
->src
, bbs
[i
])))
1296 gimple_debug_bind_reset_value (stmt
);
1305 redirect_edge_pred (exit
, src
);
1306 exit
->flags
&= ~(EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
1307 exit
->flags
|= EDGE_FALLTHRU
;
1308 cancel_loop_tree (loop
);
1309 rescan_loop_exit (exit
, false, true);
1315 delete_basic_block (bbs
[i
]);
1321 set_immediate_dominator (CDI_DOMINATORS
, dest
,
1322 recompute_dominator (CDI_DOMINATORS
, dest
));
1325 /* Generates code for PARTITION. Return whether LOOP needs to be destroyed. */
1328 generate_code_for_partition (class loop
*loop
,
1329 partition
*partition
, bool copy_p
)
1331 switch (partition
->kind
)
1334 case PKIND_PARTIAL_MEMSET
:
1335 /* Reductions all have to be in the last partition. */
1336 gcc_assert (!partition_reduction_p (partition
)
1338 generate_loops_for_partition (loop
, partition
, copy_p
);
1342 generate_memset_builtin (loop
, partition
);
1347 generate_memcpy_builtin (loop
, partition
);
1354 /* Common tail for partitions we turn into a call. If this was the last
1355 partition for which we generate code, we have to destroy the loop. */
1361 data_dependence_relation
*
1362 loop_distribution::get_data_dependence (struct graph
*rdg
, data_reference_p a
,
1365 struct data_dependence_relation ent
, **slot
;
1366 struct data_dependence_relation
*ddr
;
1368 gcc_assert (DR_IS_WRITE (a
) || DR_IS_WRITE (b
));
1369 gcc_assert (rdg_vertex_for_stmt (rdg
, DR_STMT (a
))
1370 <= rdg_vertex_for_stmt (rdg
, DR_STMT (b
)));
1373 slot
= ddrs_table
->find_slot (&ent
, INSERT
);
1376 ddr
= initialize_data_dependence_relation (a
, b
, loop_nest
);
1377 compute_affine_dependence (ddr
, loop_nest
[0]);
1385 loop_distribution::data_dep_in_cycle_p (struct graph
*rdg
,
1386 data_reference_p dr1
,
1387 data_reference_p dr2
)
1389 struct data_dependence_relation
*ddr
;
1391 /* Re-shuffle data-refs to be in topological order. */
1392 if (rdg_vertex_for_stmt (rdg
, DR_STMT (dr1
))
1393 > rdg_vertex_for_stmt (rdg
, DR_STMT (dr2
)))
1394 std::swap (dr1
, dr2
);
1396 ddr
= get_data_dependence (rdg
, dr1
, dr2
);
1398 /* In case of no data dependence. */
1399 if (DDR_ARE_DEPENDENT (ddr
) == chrec_known
)
1401 /* For unknown data dependence or known data dependence which can't be
1402 expressed in classic distance vector, we check if it can be resolved
1403 by runtime alias check. If yes, we still consider data dependence
1404 as won't introduce data dependence cycle. */
1405 else if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
1406 || DDR_NUM_DIST_VECTS (ddr
) == 0)
1407 return !runtime_alias_check_p (ddr
, NULL
, true);
1408 else if (DDR_NUM_DIST_VECTS (ddr
) > 1)
1410 else if (DDR_REVERSED_P (ddr
)
1411 || lambda_vector_zerop (DDR_DIST_VECT (ddr
, 0), 1))
1418 loop_distribution::update_type_for_merge (struct graph
*rdg
,
1419 partition
*partition1
,
1420 partition
*partition2
)
1423 bitmap_iterator bi
, bj
;
1424 data_reference_p dr1
, dr2
;
1426 EXECUTE_IF_SET_IN_BITMAP (partition1
->datarefs
, 0, i
, bi
)
1428 unsigned start
= (partition1
== partition2
) ? i
+ 1 : 0;
1430 dr1
= datarefs_vec
[i
];
1431 EXECUTE_IF_SET_IN_BITMAP (partition2
->datarefs
, start
, j
, bj
)
1433 dr2
= datarefs_vec
[j
];
1434 if (DR_IS_READ (dr1
) && DR_IS_READ (dr2
))
1437 /* Partition can only be executed sequentially if there is any
1438 data dependence cycle. */
1439 if (data_dep_in_cycle_p (rdg
, dr1
, dr2
))
1441 partition1
->type
= PTYPE_SEQUENTIAL
;
1449 loop_distribution::build_rdg_partition_for_vertex (struct graph
*rdg
, int v
)
1451 partition
*partition
= partition_alloc ();
1452 auto_vec
<int, 3> nodes
;
1455 data_reference_p dr
;
1457 graphds_dfs (rdg
, &v
, 1, &nodes
, false, NULL
);
1459 FOR_EACH_VEC_ELT (nodes
, i
, x
)
1461 bitmap_set_bit (partition
->stmts
, x
);
1463 for (j
= 0; RDG_DATAREFS (rdg
, x
).iterate (j
, &dr
); ++j
)
1465 unsigned idx
= (unsigned) DR_INDEX (dr
);
1466 gcc_assert (idx
< datarefs_vec
.length ());
1468 /* Partition can only be executed sequentially if there is any
1469 unknown data reference. */
1470 if (!DR_BASE_ADDRESS (dr
) || !DR_OFFSET (dr
)
1471 || !DR_INIT (dr
) || !DR_STEP (dr
))
1472 partition
->type
= PTYPE_SEQUENTIAL
;
1474 bitmap_set_bit (partition
->datarefs
, idx
);
1478 if (partition
->type
== PTYPE_SEQUENTIAL
)
1481 /* Further check if any data dependence prevents us from executing the
1482 partition parallelly. */
1483 update_type_for_merge (rdg
, partition
, partition
);
1488 /* Given PARTITION of LOOP and RDG, record single load/store data references
1489 for builtin partition in SRC_DR/DST_DR, return false if there is no such
1493 find_single_drs (class loop
*loop
, struct graph
*rdg
, partition
*partition
,
1494 data_reference_p
*dst_dr
, data_reference_p
*src_dr
)
1497 data_reference_p single_ld
= NULL
, single_st
= NULL
;
1500 EXECUTE_IF_SET_IN_BITMAP (partition
->stmts
, 0, i
, bi
)
1502 gimple
*stmt
= RDG_STMT (rdg
, i
);
1503 data_reference_p dr
;
1505 if (gimple_code (stmt
) == GIMPLE_PHI
)
1508 /* Any scalar stmts are ok. */
1509 if (!gimple_vuse (stmt
))
1512 /* Otherwise just regular loads/stores. */
1513 if (!gimple_assign_single_p (stmt
))
1516 /* But exactly one store and/or load. */
1517 for (unsigned j
= 0; RDG_DATAREFS (rdg
, i
).iterate (j
, &dr
); ++j
)
1519 tree type
= TREE_TYPE (DR_REF (dr
));
1521 /* The memset, memcpy and memmove library calls are only
1522 able to deal with generic address space. */
1523 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type
)))
1526 if (DR_IS_READ (dr
))
1528 if (single_ld
!= NULL
)
1534 if (single_st
!= NULL
)
1544 /* Bail out if this is a bitfield memory reference. */
1545 if (TREE_CODE (DR_REF (single_st
)) == COMPONENT_REF
1546 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (single_st
), 1)))
1549 /* Data reference must be executed exactly once per iteration of each
1550 loop in the loop nest. We only need to check dominance information
1551 against the outermost one in a perfect loop nest because a bb can't
1552 dominate outermost loop's latch without dominating inner loop's. */
1553 basic_block bb_st
= gimple_bb (DR_STMT (single_st
));
1554 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, bb_st
))
1559 gimple
*store
= DR_STMT (single_st
), *load
= DR_STMT (single_ld
);
1560 /* Direct aggregate copy or via an SSA name temporary. */
1562 && gimple_assign_lhs (load
) != gimple_assign_rhs1 (store
))
1565 /* Bail out if this is a bitfield memory reference. */
1566 if (TREE_CODE (DR_REF (single_ld
)) == COMPONENT_REF
1567 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (single_ld
), 1)))
1570 /* Load and store must be in the same loop nest. */
1571 basic_block bb_ld
= gimple_bb (DR_STMT (single_ld
));
1572 if (bb_st
->loop_father
!= bb_ld
->loop_father
)
1575 /* Data reference must be executed exactly once per iteration.
1576 Same as single_st, we only need to check against the outermost
1578 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, bb_ld
))
1581 edge e
= single_exit (bb_st
->loop_father
);
1582 bool dom_ld
= dominated_by_p (CDI_DOMINATORS
, e
->src
, bb_ld
);
1583 bool dom_st
= dominated_by_p (CDI_DOMINATORS
, e
->src
, bb_st
);
1584 if (dom_ld
!= dom_st
)
1588 *src_dr
= single_ld
;
1589 *dst_dr
= single_st
;
1593 /* Given data reference DR in LOOP_NEST, this function checks the enclosing
1594 loops from inner to outer to see if loop's step equals to access size at
1595 each level of loop. Return 2 if we can prove this at all level loops;
1596 record access base and size in BASE and SIZE; save loop's step at each
1597 level of loop in STEPS if it is not null. For example:
1599 int arr[100][100][100];
1600 for (i = 0; i < 100; i++) ;steps[2] = 40000
1601 for (j = 100; j > 0; j--) ;steps[1] = -400
1602 for (k = 0; k < 100; k++) ;steps[0] = 4
1603 arr[i][j - 1][k] = 0; ;base = &arr, size = 4000000
1605 Return 1 if we can prove the equality at the innermost loop, but not all
1606 level loops. In this case, no information is recorded.
1608 Return 0 if no equality can be proven at any level loops. */
1611 compute_access_range (loop_p loop_nest
, data_reference_p dr
, tree
*base
,
1612 tree
*size
, vec
<tree
> *steps
= NULL
)
1614 location_t loc
= gimple_location (DR_STMT (dr
));
1615 basic_block bb
= gimple_bb (DR_STMT (dr
));
1616 class loop
*loop
= bb
->loop_father
;
1617 tree ref
= DR_REF (dr
);
1618 tree access_base
= build_fold_addr_expr (ref
);
1619 tree access_size
= TYPE_SIZE_UNIT (TREE_TYPE (ref
));
1623 tree scev_fn
= analyze_scalar_evolution (loop
, access_base
);
1624 if (TREE_CODE (scev_fn
) != POLYNOMIAL_CHREC
)
1627 access_base
= CHREC_LEFT (scev_fn
);
1628 if (tree_contains_chrecs (access_base
, NULL
))
1631 tree scev_step
= CHREC_RIGHT (scev_fn
);
1632 /* Only support constant steps. */
1633 if (TREE_CODE (scev_step
) != INTEGER_CST
)
1636 enum ev_direction access_dir
= scev_direction (scev_fn
);
1637 if (access_dir
== EV_DIR_UNKNOWN
)
1641 steps
->safe_push (scev_step
);
1643 scev_step
= fold_convert_loc (loc
, sizetype
, scev_step
);
1644 /* Compute absolute value of scev step. */
1645 if (access_dir
== EV_DIR_DECREASES
)
1646 scev_step
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, scev_step
);
1648 /* At each level of loop, scev step must equal to access size. In other
1649 words, DR must access consecutive memory between loop iterations. */
1650 if (!operand_equal_p (scev_step
, access_size
, 0))
1653 /* Access stride can be computed for data reference at least for the
1657 /* Compute DR's execution times in loop. */
1658 tree niters
= number_of_latch_executions (loop
);
1659 niters
= fold_convert_loc (loc
, sizetype
, niters
);
1660 if (dominated_by_p (CDI_DOMINATORS
, single_exit (loop
)->src
, bb
))
1661 niters
= size_binop_loc (loc
, PLUS_EXPR
, niters
, size_one_node
);
1663 /* Compute DR's overall access size in loop. */
1664 access_size
= fold_build2_loc (loc
, MULT_EXPR
, sizetype
,
1666 /* Adjust base address in case of negative step. */
1667 if (access_dir
== EV_DIR_DECREASES
)
1669 tree adj
= fold_build2_loc (loc
, MINUS_EXPR
, sizetype
,
1670 scev_step
, access_size
);
1671 access_base
= fold_build_pointer_plus_loc (loc
, access_base
, adj
);
1673 } while (loop
!= loop_nest
&& (loop
= loop_outer (loop
)) != NULL
);
1675 *base
= access_base
;
1676 *size
= access_size
;
1677 /* Access stride can be computed for data reference at each level loop. */
1681 /* Allocate and return builtin struct. Record information like DST_DR,
1682 SRC_DR, DST_BASE, SRC_BASE and SIZE in the allocated struct. */
1684 static struct builtin_info
*
1685 alloc_builtin (data_reference_p dst_dr
, data_reference_p src_dr
,
1686 tree dst_base
, tree src_base
, tree size
)
1688 struct builtin_info
*builtin
= XNEW (struct builtin_info
);
1689 builtin
->dst_dr
= dst_dr
;
1690 builtin
->src_dr
= src_dr
;
1691 builtin
->dst_base
= dst_base
;
1692 builtin
->src_base
= src_base
;
1693 builtin
->size
= size
;
1697 /* Given data reference DR in loop nest LOOP, classify if it forms builtin
1701 classify_builtin_st (loop_p loop
, partition
*partition
, data_reference_p dr
)
1703 gimple
*stmt
= DR_STMT (dr
);
1704 tree base
, size
, rhs
= gimple_assign_rhs1 (stmt
);
1706 if (const_with_all_bytes_same (rhs
) == -1
1707 && (!INTEGRAL_TYPE_P (TREE_TYPE (rhs
))
1708 || (TYPE_MODE (TREE_TYPE (rhs
))
1709 != TYPE_MODE (unsigned_char_type_node
))))
1712 if (TREE_CODE (rhs
) == SSA_NAME
1713 && !SSA_NAME_IS_DEFAULT_DEF (rhs
)
1714 && flow_bb_inside_loop_p (loop
, gimple_bb (SSA_NAME_DEF_STMT (rhs
))))
1717 int res
= compute_access_range (loop
, dr
, &base
, &size
);
1722 partition
->kind
= PKIND_PARTIAL_MEMSET
;
1726 poly_uint64 base_offset
;
1727 unsigned HOST_WIDE_INT const_base_offset
;
1728 tree base_base
= strip_offset (base
, &base_offset
);
1729 if (!base_offset
.is_constant (&const_base_offset
))
1732 struct builtin_info
*builtin
;
1733 builtin
= alloc_builtin (dr
, NULL
, base
, NULL_TREE
, size
);
1734 builtin
->dst_base_base
= base_base
;
1735 builtin
->dst_base_offset
= const_base_offset
;
1736 partition
->builtin
= builtin
;
1737 partition
->kind
= PKIND_MEMSET
;
1740 /* Given data references DST_DR and SRC_DR in loop nest LOOP and RDG, classify
1741 if it forms builtin memcpy or memmove call. */
1744 loop_distribution::classify_builtin_ldst (loop_p loop
, struct graph
*rdg
,
1745 partition
*partition
,
1746 data_reference_p dst_dr
,
1747 data_reference_p src_dr
)
1749 tree base
, size
, src_base
, src_size
;
1750 auto_vec
<tree
> dst_steps
, src_steps
;
1752 /* Compute access range of both load and store. */
1753 int res
= compute_access_range (loop
, dst_dr
, &base
, &size
, &dst_steps
);
1756 res
= compute_access_range (loop
, src_dr
, &src_base
, &src_size
, &src_steps
);
1760 /* They much have the same access size. */
1761 if (!operand_equal_p (size
, src_size
, 0))
1764 /* Load and store in loop nest must access memory in the same way, i.e,
1765 their must have the same steps in each loop of the nest. */
1766 if (dst_steps
.length () != src_steps
.length ())
1768 for (unsigned i
= 0; i
< dst_steps
.length (); ++i
)
1769 if (!operand_equal_p (dst_steps
[i
], src_steps
[i
], 0))
1772 /* Now check that if there is a dependence. */
1773 ddr_p ddr
= get_data_dependence (rdg
, src_dr
, dst_dr
);
1775 /* Classify as memmove if no dependence between load and store. */
1776 if (DDR_ARE_DEPENDENT (ddr
) == chrec_known
)
1778 partition
->builtin
= alloc_builtin (dst_dr
, src_dr
, base
, src_base
, size
);
1779 partition
->kind
= PKIND_MEMMOVE
;
1783 /* Can't do memmove in case of unknown dependence or dependence without
1784 classical distance vector. */
1785 if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
1786 || DDR_NUM_DIST_VECTS (ddr
) == 0)
1790 lambda_vector dist_v
;
1791 int num_lev
= (DDR_LOOP_NEST (ddr
)).length ();
1792 FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr
), i
, dist_v
)
1794 unsigned dep_lev
= dependence_level (dist_v
, num_lev
);
1795 /* Can't do memmove if load depends on store. */
1796 if (dep_lev
> 0 && dist_v
[dep_lev
- 1] > 0 && !DDR_REVERSED_P (ddr
))
1800 partition
->builtin
= alloc_builtin (dst_dr
, src_dr
, base
, src_base
, size
);
1801 partition
->kind
= PKIND_MEMMOVE
;
1806 loop_distribution::classify_partition (loop_p loop
,
1807 struct graph
*rdg
, partition
*partition
,
1808 bitmap stmt_in_all_partitions
)
1812 data_reference_p single_ld
= NULL
, single_st
= NULL
;
1813 bool volatiles_p
= false, has_reduction
= false;
1815 EXECUTE_IF_SET_IN_BITMAP (partition
->stmts
, 0, i
, bi
)
1817 gimple
*stmt
= RDG_STMT (rdg
, i
);
1819 if (gimple_has_volatile_ops (stmt
))
1822 /* If the stmt is not included by all partitions and there is uses
1823 outside of the loop, then mark the partition as reduction. */
1824 if (stmt_has_scalar_dependences_outside_loop (loop
, stmt
))
1826 /* Due to limitation in the transform phase we have to fuse all
1827 reduction partitions. As a result, this could cancel valid
1828 loop distribution especially for loop that induction variable
1829 is used outside of loop. To workaround this issue, we skip
1830 marking partition as reudction if the reduction stmt belongs
1831 to all partitions. In such case, reduction will be computed
1832 correctly no matter how partitions are fused/distributed. */
1833 if (!bitmap_bit_p (stmt_in_all_partitions
, i
))
1834 partition
->reduction_p
= true;
1836 has_reduction
= true;
1840 /* Simple workaround to prevent classifying the partition as builtin
1841 if it contains any use outside of loop. For the case where all
1842 partitions have the reduction this simple workaround is delayed
1843 to only affect the last partition. */
1844 if (partition
->reduction_p
)
1845 return has_reduction
;
1847 /* Perform general partition disqualification for builtins. */
1849 || !flag_tree_loop_distribute_patterns
)
1850 return has_reduction
;
1852 /* Find single load/store data references for builtin partition. */
1853 if (!find_single_drs (loop
, rdg
, partition
, &single_st
, &single_ld
))
1854 return has_reduction
;
1856 partition
->loc
= gimple_location (DR_STMT (single_st
));
1858 /* Classify the builtin kind. */
1859 if (single_ld
== NULL
)
1860 classify_builtin_st (loop
, partition
, single_st
);
1862 classify_builtin_ldst (loop
, rdg
, partition
, single_st
, single_ld
);
1863 return has_reduction
;
1867 loop_distribution::share_memory_accesses (struct graph
*rdg
,
1868 partition
*partition1
, partition
*partition2
)
1871 bitmap_iterator bi
, bj
;
1872 data_reference_p dr1
, dr2
;
1874 /* First check whether in the intersection of the two partitions are
1875 any loads or stores. Common loads are the situation that happens
1877 EXECUTE_IF_AND_IN_BITMAP (partition1
->stmts
, partition2
->stmts
, 0, i
, bi
)
1878 if (RDG_MEM_WRITE_STMT (rdg
, i
)
1879 || RDG_MEM_READS_STMT (rdg
, i
))
1882 /* Then check whether the two partitions access the same memory object. */
1883 EXECUTE_IF_SET_IN_BITMAP (partition1
->datarefs
, 0, i
, bi
)
1885 dr1
= datarefs_vec
[i
];
1887 if (!DR_BASE_ADDRESS (dr1
)
1888 || !DR_OFFSET (dr1
) || !DR_INIT (dr1
) || !DR_STEP (dr1
))
1891 EXECUTE_IF_SET_IN_BITMAP (partition2
->datarefs
, 0, j
, bj
)
1893 dr2
= datarefs_vec
[j
];
1895 if (!DR_BASE_ADDRESS (dr2
)
1896 || !DR_OFFSET (dr2
) || !DR_INIT (dr2
) || !DR_STEP (dr2
))
1899 if (operand_equal_p (DR_BASE_ADDRESS (dr1
), DR_BASE_ADDRESS (dr2
), 0)
1900 && operand_equal_p (DR_OFFSET (dr1
), DR_OFFSET (dr2
), 0)
1901 && operand_equal_p (DR_INIT (dr1
), DR_INIT (dr2
), 0)
1902 && operand_equal_p (DR_STEP (dr1
), DR_STEP (dr2
), 0))
1910 /* For each seed statement in STARTING_STMTS, this function builds
1911 partition for it by adding depended statements according to RDG.
1912 All partitions are recorded in PARTITIONS. */
1915 loop_distribution::rdg_build_partitions (struct graph
*rdg
,
1916 vec
<gimple
*> starting_stmts
,
1917 vec
<partition
*> *partitions
)
1919 auto_bitmap processed
;
1923 FOR_EACH_VEC_ELT (starting_stmts
, i
, stmt
)
1925 int v
= rdg_vertex_for_stmt (rdg
, stmt
);
1927 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1929 "ldist asked to generate code for vertex %d\n", v
);
1931 /* If the vertex is already contained in another partition so
1932 is the partition rooted at it. */
1933 if (bitmap_bit_p (processed
, v
))
1936 partition
*partition
= build_rdg_partition_for_vertex (rdg
, v
);
1937 bitmap_ior_into (processed
, partition
->stmts
);
1939 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1941 fprintf (dump_file
, "ldist creates useful %s partition:\n",
1942 partition
->type
== PTYPE_PARALLEL
? "parallel" : "sequent");
1943 bitmap_print (dump_file
, partition
->stmts
, " ", "\n");
1946 partitions
->safe_push (partition
);
1949 /* All vertices should have been assigned to at least one partition now,
1950 other than vertices belonging to dead code. */
1953 /* Dump to FILE the PARTITIONS. */
1956 dump_rdg_partitions (FILE *file
, vec
<partition
*> partitions
)
1959 partition
*partition
;
1961 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
1962 debug_bitmap_file (file
, partition
->stmts
);
1965 /* Debug PARTITIONS. */
1966 extern void debug_rdg_partitions (vec
<partition
*> );
1969 debug_rdg_partitions (vec
<partition
*> partitions
)
1971 dump_rdg_partitions (stderr
, partitions
);
1974 /* Returns the number of read and write operations in the RDG. */
1977 number_of_rw_in_rdg (struct graph
*rdg
)
1981 for (i
= 0; i
< rdg
->n_vertices
; i
++)
1983 if (RDG_MEM_WRITE_STMT (rdg
, i
))
1986 if (RDG_MEM_READS_STMT (rdg
, i
))
1993 /* Returns the number of read and write operations in a PARTITION of
1997 number_of_rw_in_partition (struct graph
*rdg
, partition
*partition
)
2003 EXECUTE_IF_SET_IN_BITMAP (partition
->stmts
, 0, i
, ii
)
2005 if (RDG_MEM_WRITE_STMT (rdg
, i
))
2008 if (RDG_MEM_READS_STMT (rdg
, i
))
2015 /* Returns true when one of the PARTITIONS contains all the read or
2016 write operations of RDG. */
2019 partition_contains_all_rw (struct graph
*rdg
,
2020 vec
<partition
*> partitions
)
2023 partition
*partition
;
2024 int nrw
= number_of_rw_in_rdg (rdg
);
2026 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
2027 if (nrw
== number_of_rw_in_partition (rdg
, partition
))
2034 loop_distribution::pg_add_dependence_edges (struct graph
*rdg
, int dir
,
2035 bitmap drs1
, bitmap drs2
, vec
<ddr_p
> *alias_ddrs
)
2038 bitmap_iterator bi
, bj
;
2039 data_reference_p dr1
, dr2
, saved_dr1
;
2041 /* dependence direction - 0 is no dependence, -1 is back,
2042 1 is forth, 2 is both (we can stop then, merging will occur). */
2043 EXECUTE_IF_SET_IN_BITMAP (drs1
, 0, i
, bi
)
2045 dr1
= datarefs_vec
[i
];
2047 EXECUTE_IF_SET_IN_BITMAP (drs2
, 0, j
, bj
)
2049 int res
, this_dir
= 1;
2052 dr2
= datarefs_vec
[j
];
2054 /* Skip all <read, read> data dependence. */
2055 if (DR_IS_READ (dr1
) && DR_IS_READ (dr2
))
2059 /* Re-shuffle data-refs to be in topological order. */
2060 if (rdg_vertex_for_stmt (rdg
, DR_STMT (dr1
))
2061 > rdg_vertex_for_stmt (rdg
, DR_STMT (dr2
)))
2063 std::swap (dr1
, dr2
);
2064 this_dir
= -this_dir
;
2066 ddr
= get_data_dependence (rdg
, dr1
, dr2
);
2067 if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
)
2070 res
= data_ref_compare_tree (DR_BASE_ADDRESS (dr1
),
2071 DR_BASE_ADDRESS (dr2
));
2072 /* Be conservative. If data references are not well analyzed,
2073 or the two data references have the same base address and
2074 offset, add dependence and consider it alias to each other.
2075 In other words, the dependence cannot be resolved by
2076 runtime alias check. */
2077 if (!DR_BASE_ADDRESS (dr1
) || !DR_BASE_ADDRESS (dr2
)
2078 || !DR_OFFSET (dr1
) || !DR_OFFSET (dr2
)
2079 || !DR_INIT (dr1
) || !DR_INIT (dr2
)
2080 || !DR_STEP (dr1
) || !tree_fits_uhwi_p (DR_STEP (dr1
))
2081 || !DR_STEP (dr2
) || !tree_fits_uhwi_p (DR_STEP (dr2
))
2084 /* Data dependence could be resolved by runtime alias check,
2085 record it in ALIAS_DDRS. */
2086 else if (alias_ddrs
!= NULL
)
2087 alias_ddrs
->safe_push (ddr
);
2088 /* Or simply ignore it. */
2090 else if (DDR_ARE_DEPENDENT (ddr
) == NULL_TREE
)
2092 if (DDR_REVERSED_P (ddr
))
2093 this_dir
= -this_dir
;
2095 /* Known dependences can still be unordered througout the
2096 iteration space, see gcc.dg/tree-ssa/ldist-16.c and
2097 gcc.dg/tree-ssa/pr94969.c. */
2098 if (DDR_NUM_DIST_VECTS (ddr
) != 1)
2100 /* If the overlap is exact preserve stmt order. */
2101 else if (lambda_vector_zerop (DDR_DIST_VECT (ddr
, 0),
2102 DDR_NB_LOOPS (ddr
)))
2104 /* Else as the distance vector is lexicographic positive swap
2105 the dependence direction. */
2107 this_dir
= -this_dir
;
2115 else if (this_dir
!= 0 && dir
!= this_dir
)
2117 /* Shuffle "back" dr1. */
2124 /* Compare postorder number of the partition graph vertices V1 and V2. */
2127 pgcmp (const void *v1_
, const void *v2_
)
2129 const vertex
*v1
= (const vertex
*)v1_
;
2130 const vertex
*v2
= (const vertex
*)v2_
;
2131 return v2
->post
- v1
->post
;
2134 /* Data attached to vertices of partition dependence graph. */
2137 /* ID of the corresponding partition. */
2139 /* The partition. */
2140 struct partition
*partition
;
2143 /* Data attached to edges of partition dependence graph. */
2146 /* If the dependence edge can be resolved by runtime alias check,
2147 this vector contains data dependence relations for runtime alias
2148 check. On the other hand, if the dependence edge is introduced
2149 because of compilation time known data dependence, this vector
2150 contains nothing. */
2151 vec
<ddr_p
> alias_ddrs
;
2154 /* Callback data for traversing edges in graph. */
2155 struct pg_edge_callback_data
2157 /* Bitmap contains strong connected components should be merged. */
2158 bitmap sccs_to_merge
;
2159 /* Array constains component information for all vertices. */
2160 int *vertices_component
;
2161 /* Array constains postorder information for all vertices. */
2163 /* Vector to record all data dependence relations which are needed
2164 to break strong connected components by runtime alias checks. */
2165 vec
<ddr_p
> *alias_ddrs
;
2168 /* Initialize vertice's data for partition dependence graph PG with
2172 init_partition_graph_vertices (struct graph
*pg
,
2173 vec
<struct partition
*> *partitions
)
2176 partition
*partition
;
2177 struct pg_vdata
*data
;
2179 for (i
= 0; partitions
->iterate (i
, &partition
); ++i
)
2181 data
= new pg_vdata
;
2182 pg
->vertices
[i
].data
= data
;
2184 data
->partition
= partition
;
2188 /* Add edge <I, J> to partition dependence graph PG. Attach vector of data
2189 dependence relations to the EDGE if DDRS isn't NULL. */
2192 add_partition_graph_edge (struct graph
*pg
, int i
, int j
, vec
<ddr_p
> *ddrs
)
2194 struct graph_edge
*e
= add_edge (pg
, i
, j
);
2196 /* If the edge is attached with data dependence relations, it means this
2197 dependence edge can be resolved by runtime alias checks. */
2200 struct pg_edata
*data
= new pg_edata
;
2202 gcc_assert (ddrs
->length () > 0);
2204 data
->alias_ddrs
= vNULL
;
2205 data
->alias_ddrs
.safe_splice (*ddrs
);
2209 /* Callback function for graph travesal algorithm. It returns true
2210 if edge E should skipped when traversing the graph. */
2213 pg_skip_alias_edge (struct graph_edge
*e
)
2215 struct pg_edata
*data
= (struct pg_edata
*)e
->data
;
2216 return (data
!= NULL
&& data
->alias_ddrs
.length () > 0);
2219 /* Callback function freeing data attached to edge E of graph. */
2222 free_partition_graph_edata_cb (struct graph
*, struct graph_edge
*e
, void *)
2224 if (e
->data
!= NULL
)
2226 struct pg_edata
*data
= (struct pg_edata
*)e
->data
;
2227 data
->alias_ddrs
.release ();
2232 /* Free data attached to vertice of partition dependence graph PG. */
2235 free_partition_graph_vdata (struct graph
*pg
)
2238 struct pg_vdata
*data
;
2240 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2242 data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2247 /* Build and return partition dependence graph for PARTITIONS. RDG is
2248 reduced dependence graph for the loop to be distributed. If IGNORE_ALIAS_P
2249 is true, data dependence caused by possible alias between references
2250 is ignored, as if it doesn't exist at all; otherwise all depdendences
2254 loop_distribution::build_partition_graph (struct graph
*rdg
,
2255 vec
<struct partition
*> *partitions
,
2256 bool ignore_alias_p
)
2259 struct partition
*partition1
, *partition2
;
2260 graph
*pg
= new_graph (partitions
->length ());
2261 auto_vec
<ddr_p
> alias_ddrs
, *alias_ddrs_p
;
2263 alias_ddrs_p
= ignore_alias_p
? NULL
: &alias_ddrs
;
2265 init_partition_graph_vertices (pg
, partitions
);
2267 for (i
= 0; partitions
->iterate (i
, &partition1
); ++i
)
2269 for (j
= i
+ 1; partitions
->iterate (j
, &partition2
); ++j
)
2271 /* dependence direction - 0 is no dependence, -1 is back,
2272 1 is forth, 2 is both (we can stop then, merging will occur). */
2275 /* If the first partition has reduction, add back edge; if the
2276 second partition has reduction, add forth edge. This makes
2277 sure that reduction partition will be sorted as the last one. */
2278 if (partition_reduction_p (partition1
))
2280 else if (partition_reduction_p (partition2
))
2283 /* Cleanup the temporary vector. */
2284 alias_ddrs
.truncate (0);
2286 dir
= pg_add_dependence_edges (rdg
, dir
, partition1
->datarefs
,
2287 partition2
->datarefs
, alias_ddrs_p
);
2289 /* Add edge to partition graph if there exists dependence. There
2290 are two types of edges. One type edge is caused by compilation
2291 time known dependence, this type cannot be resolved by runtime
2292 alias check. The other type can be resolved by runtime alias
2294 if (dir
== 1 || dir
== 2
2295 || alias_ddrs
.length () > 0)
2297 /* Attach data dependence relations to edge that can be resolved
2298 by runtime alias check. */
2299 bool alias_edge_p
= (dir
!= 1 && dir
!= 2);
2300 add_partition_graph_edge (pg
, i
, j
,
2301 (alias_edge_p
) ? &alias_ddrs
: NULL
);
2303 if (dir
== -1 || dir
== 2
2304 || alias_ddrs
.length () > 0)
2306 /* Attach data dependence relations to edge that can be resolved
2307 by runtime alias check. */
2308 bool alias_edge_p
= (dir
!= -1 && dir
!= 2);
2309 add_partition_graph_edge (pg
, j
, i
,
2310 (alias_edge_p
) ? &alias_ddrs
: NULL
);
2317 /* Sort partitions in PG in descending post order and store them in
2321 sort_partitions_by_post_order (struct graph
*pg
,
2322 vec
<struct partition
*> *partitions
)
2325 struct pg_vdata
*data
;
2327 /* Now order the remaining nodes in descending postorder. */
2328 qsort (pg
->vertices
, pg
->n_vertices
, sizeof (vertex
), pgcmp
);
2329 partitions
->truncate (0);
2330 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2332 data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2333 if (data
->partition
)
2334 partitions
->safe_push (data
->partition
);
2339 loop_distribution::merge_dep_scc_partitions (struct graph
*rdg
,
2340 vec
<struct partition
*> *partitions
,
2341 bool ignore_alias_p
)
2343 struct partition
*partition1
, *partition2
;
2344 struct pg_vdata
*data
;
2345 graph
*pg
= build_partition_graph (rdg
, partitions
, ignore_alias_p
);
2346 int i
, j
, num_sccs
= graphds_scc (pg
, NULL
);
2348 /* Strong connected compoenent means dependence cycle, we cannot distribute
2349 them. So fuse them together. */
2350 if ((unsigned) num_sccs
< partitions
->length ())
2352 for (i
= 0; i
< num_sccs
; ++i
)
2354 for (j
= 0; partitions
->iterate (j
, &partition1
); ++j
)
2355 if (pg
->vertices
[j
].component
== i
)
2357 for (j
= j
+ 1; partitions
->iterate (j
, &partition2
); ++j
)
2358 if (pg
->vertices
[j
].component
== i
)
2360 partition_merge_into (NULL
, partition1
,
2361 partition2
, FUSE_SAME_SCC
);
2362 partition1
->type
= PTYPE_SEQUENTIAL
;
2363 (*partitions
)[j
] = NULL
;
2364 partition_free (partition2
);
2365 data
= (struct pg_vdata
*)pg
->vertices
[j
].data
;
2366 data
->partition
= NULL
;
2371 sort_partitions_by_post_order (pg
, partitions
);
2372 gcc_assert (partitions
->length () == (unsigned)num_sccs
);
2373 free_partition_graph_vdata (pg
);
2374 for_each_edge (pg
, free_partition_graph_edata_cb
, NULL
);
2378 /* Callback function for traversing edge E in graph G. DATA is private
2382 pg_collect_alias_ddrs (struct graph
*g
, struct graph_edge
*e
, void *data
)
2384 int i
, j
, component
;
2385 struct pg_edge_callback_data
*cbdata
;
2386 struct pg_edata
*edata
= (struct pg_edata
*) e
->data
;
2388 /* If the edge doesn't have attached data dependence, it represents
2389 compilation time known dependences. This type dependence cannot
2390 be resolved by runtime alias check. */
2391 if (edata
== NULL
|| edata
->alias_ddrs
.length () == 0)
2394 cbdata
= (struct pg_edge_callback_data
*) data
;
2397 component
= cbdata
->vertices_component
[i
];
2398 /* Vertices are topologically sorted according to compilation time
2399 known dependences, so we can break strong connected components
2400 by removing edges of the opposite direction, i.e, edges pointing
2401 from vertice with smaller post number to vertice with bigger post
2403 if (g
->vertices
[i
].post
< g
->vertices
[j
].post
2404 /* We only need to remove edges connecting vertices in the same
2405 strong connected component to break it. */
2406 && component
== cbdata
->vertices_component
[j
]
2407 /* Check if we want to break the strong connected component or not. */
2408 && !bitmap_bit_p (cbdata
->sccs_to_merge
, component
))
2409 cbdata
->alias_ddrs
->safe_splice (edata
->alias_ddrs
);
2412 /* This is the main function breaking strong conected components in
2413 PARTITIONS giving reduced depdendence graph RDG. Store data dependence
2414 relations for runtime alias check in ALIAS_DDRS. */
2416 loop_distribution::break_alias_scc_partitions (struct graph
*rdg
,
2417 vec
<struct partition
*> *partitions
,
2418 vec
<ddr_p
> *alias_ddrs
)
2420 int i
, j
, k
, num_sccs
, num_sccs_no_alias
= 0;
2421 /* Build partition dependence graph. */
2422 graph
*pg
= build_partition_graph (rdg
, partitions
, false);
2424 alias_ddrs
->truncate (0);
2425 /* Find strong connected components in the graph, with all dependence edges
2427 num_sccs
= graphds_scc (pg
, NULL
);
2428 /* All SCCs now can be broken by runtime alias checks because SCCs caused by
2429 compilation time known dependences are merged before this function. */
2430 if ((unsigned) num_sccs
< partitions
->length ())
2432 struct pg_edge_callback_data cbdata
;
2433 auto_bitmap sccs_to_merge
;
2434 auto_vec
<enum partition_type
> scc_types
;
2435 struct partition
*partition
, *first
;
2437 /* If all partitions in a SCC have the same type, we can simply merge the
2438 SCC. This loop finds out such SCCS and record them in bitmap. */
2439 bitmap_set_range (sccs_to_merge
, 0, (unsigned) num_sccs
);
2440 for (i
= 0; i
< num_sccs
; ++i
)
2442 for (j
= 0; partitions
->iterate (j
, &first
); ++j
)
2443 if (pg
->vertices
[j
].component
== i
)
2446 bool same_type
= true, all_builtins
= partition_builtin_p (first
);
2447 for (++j
; partitions
->iterate (j
, &partition
); ++j
)
2449 if (pg
->vertices
[j
].component
!= i
)
2452 if (first
->type
!= partition
->type
)
2457 all_builtins
&= partition_builtin_p (partition
);
2459 /* Merge SCC if all partitions in SCC have the same type, though the
2460 result partition is sequential, because vectorizer can do better
2461 runtime alias check. One expecption is all partitions in SCC are
2463 if (!same_type
|| all_builtins
)
2464 bitmap_clear_bit (sccs_to_merge
, i
);
2467 /* Initialize callback data for traversing. */
2468 cbdata
.sccs_to_merge
= sccs_to_merge
;
2469 cbdata
.alias_ddrs
= alias_ddrs
;
2470 cbdata
.vertices_component
= XNEWVEC (int, pg
->n_vertices
);
2471 cbdata
.vertices_post
= XNEWVEC (int, pg
->n_vertices
);
2472 /* Record the component information which will be corrupted by next
2473 graph scc finding call. */
2474 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2475 cbdata
.vertices_component
[i
] = pg
->vertices
[i
].component
;
2477 /* Collect data dependences for runtime alias checks to break SCCs. */
2478 if (bitmap_count_bits (sccs_to_merge
) != (unsigned) num_sccs
)
2480 /* Record the postorder information which will be corrupted by next
2481 graph SCC finding call. */
2482 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2483 cbdata
.vertices_post
[i
] = pg
->vertices
[i
].post
;
2485 /* Run SCC finding algorithm again, with alias dependence edges
2486 skipped. This is to topologically sort partitions according to
2487 compilation time known dependence. Note the topological order
2488 is stored in the form of pg's post order number. */
2489 num_sccs_no_alias
= graphds_scc (pg
, NULL
, pg_skip_alias_edge
);
2490 gcc_assert (partitions
->length () == (unsigned) num_sccs_no_alias
);
2491 /* With topological order, we can construct two subgraphs L and R.
2492 L contains edge <x, y> where x < y in terms of post order, while
2493 R contains edge <x, y> where x > y. Edges for compilation time
2494 known dependence all fall in R, so we break SCCs by removing all
2495 (alias) edges of in subgraph L. */
2496 for_each_edge (pg
, pg_collect_alias_ddrs
, &cbdata
);
2499 /* For SCC that doesn't need to be broken, merge it. */
2500 for (i
= 0; i
< num_sccs
; ++i
)
2502 if (!bitmap_bit_p (sccs_to_merge
, i
))
2505 for (j
= 0; partitions
->iterate (j
, &first
); ++j
)
2506 if (cbdata
.vertices_component
[j
] == i
)
2508 for (k
= j
+ 1; partitions
->iterate (k
, &partition
); ++k
)
2510 struct pg_vdata
*data
;
2512 if (cbdata
.vertices_component
[k
] != i
)
2515 partition_merge_into (NULL
, first
, partition
, FUSE_SAME_SCC
);
2516 (*partitions
)[k
] = NULL
;
2517 partition_free (partition
);
2518 data
= (struct pg_vdata
*)pg
->vertices
[k
].data
;
2519 gcc_assert (data
->id
== k
);
2520 data
->partition
= NULL
;
2521 /* The result partition of merged SCC must be sequential. */
2522 first
->type
= PTYPE_SEQUENTIAL
;
2525 /* Restore the postorder information if it's corrupted in finding SCC
2526 with alias dependence edges skipped. If reduction partition's SCC is
2527 broken by runtime alias checks, we force a negative post order to it
2528 making sure it will be scheduled in the last. */
2529 if (num_sccs_no_alias
> 0)
2532 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2534 pg
->vertices
[i
].post
= cbdata
.vertices_post
[i
];
2535 struct pg_vdata
*data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2536 if (data
->partition
&& partition_reduction_p (data
->partition
))
2538 gcc_assert (j
== -1);
2543 pg
->vertices
[j
].post
= -1;
2546 free (cbdata
.vertices_component
);
2547 free (cbdata
.vertices_post
);
2550 sort_partitions_by_post_order (pg
, partitions
);
2551 free_partition_graph_vdata (pg
);
2552 for_each_edge (pg
, free_partition_graph_edata_cb
, NULL
);
2555 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2557 fprintf (dump_file
, "Possible alias data dependence to break:\n");
2558 dump_data_dependence_relations (dump_file
, *alias_ddrs
);
2562 /* Compute and return an expression whose value is the segment length which
2563 will be accessed by DR in NITERS iterations. */
2566 data_ref_segment_size (struct data_reference
*dr
, tree niters
)
2568 niters
= size_binop (MINUS_EXPR
,
2569 fold_convert (sizetype
, niters
),
2571 return size_binop (MULT_EXPR
,
2572 fold_convert (sizetype
, DR_STEP (dr
)),
2573 fold_convert (sizetype
, niters
));
2576 /* Return true if LOOP's latch is dominated by statement for data reference
2580 latch_dominated_by_data_ref (class loop
*loop
, data_reference
*dr
)
2582 return dominated_by_p (CDI_DOMINATORS
, single_exit (loop
)->src
,
2583 gimple_bb (DR_STMT (dr
)));
2586 /* Compute alias check pairs and store them in COMP_ALIAS_PAIRS for LOOP's
2587 data dependence relations ALIAS_DDRS. */
2590 compute_alias_check_pairs (class loop
*loop
, vec
<ddr_p
> *alias_ddrs
,
2591 vec
<dr_with_seg_len_pair_t
> *comp_alias_pairs
)
2594 unsigned HOST_WIDE_INT factor
= 1;
2595 tree niters_plus_one
, niters
= number_of_latch_executions (loop
);
2597 gcc_assert (niters
!= NULL_TREE
&& niters
!= chrec_dont_know
);
2598 niters
= fold_convert (sizetype
, niters
);
2599 niters_plus_one
= size_binop (PLUS_EXPR
, niters
, size_one_node
);
2601 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2602 fprintf (dump_file
, "Creating alias check pairs:\n");
2604 /* Iterate all data dependence relations and compute alias check pairs. */
2605 for (i
= 0; i
< alias_ddrs
->length (); i
++)
2607 ddr_p ddr
= (*alias_ddrs
)[i
];
2608 struct data_reference
*dr_a
= DDR_A (ddr
);
2609 struct data_reference
*dr_b
= DDR_B (ddr
);
2610 tree seg_length_a
, seg_length_b
;
2612 if (latch_dominated_by_data_ref (loop
, dr_a
))
2613 seg_length_a
= data_ref_segment_size (dr_a
, niters_plus_one
);
2615 seg_length_a
= data_ref_segment_size (dr_a
, niters
);
2617 if (latch_dominated_by_data_ref (loop
, dr_b
))
2618 seg_length_b
= data_ref_segment_size (dr_b
, niters_plus_one
);
2620 seg_length_b
= data_ref_segment_size (dr_b
, niters
);
2622 unsigned HOST_WIDE_INT access_size_a
2623 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_a
))));
2624 unsigned HOST_WIDE_INT access_size_b
2625 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_b
))));
2626 unsigned int align_a
= TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_a
)));
2627 unsigned int align_b
= TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_b
)));
2629 dr_with_seg_len_pair_t dr_with_seg_len_pair
2630 (dr_with_seg_len (dr_a
, seg_length_a
, access_size_a
, align_a
),
2631 dr_with_seg_len (dr_b
, seg_length_b
, access_size_b
, align_b
),
2632 /* ??? Would WELL_ORDERED be safe? */
2633 dr_with_seg_len_pair_t::REORDERED
);
2635 comp_alias_pairs
->safe_push (dr_with_seg_len_pair
);
2638 if (tree_fits_uhwi_p (niters
))
2639 factor
= tree_to_uhwi (niters
);
2641 /* Prune alias check pairs. */
2642 prune_runtime_alias_test_list (comp_alias_pairs
, factor
);
2643 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2645 "Improved number of alias checks from %d to %d\n",
2646 alias_ddrs
->length (), comp_alias_pairs
->length ());
2649 /* Given data dependence relations in ALIAS_DDRS, generate runtime alias
2650 checks and version LOOP under condition of these runtime alias checks. */
2653 version_loop_by_alias_check (vec
<struct partition
*> *partitions
,
2654 class loop
*loop
, vec
<ddr_p
> *alias_ddrs
)
2656 profile_probability prob
;
2657 basic_block cond_bb
;
2659 tree lhs
, arg0
, cond_expr
= NULL_TREE
;
2660 gimple_seq cond_stmts
= NULL
;
2661 gimple
*call_stmt
= NULL
;
2662 auto_vec
<dr_with_seg_len_pair_t
> comp_alias_pairs
;
2664 /* Generate code for runtime alias checks if necessary. */
2665 gcc_assert (alias_ddrs
->length () > 0);
2667 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2669 "Version loop <%d> with runtime alias check\n", loop
->num
);
2671 compute_alias_check_pairs (loop
, alias_ddrs
, &comp_alias_pairs
);
2672 create_runtime_alias_checks (loop
, &comp_alias_pairs
, &cond_expr
);
2673 cond_expr
= force_gimple_operand_1 (cond_expr
, &cond_stmts
,
2674 is_gimple_val
, NULL_TREE
);
2676 /* Depend on vectorizer to fold IFN_LOOP_DIST_ALIAS. */
2677 bool cancelable_p
= flag_tree_loop_vectorize
;
2681 struct partition
*partition
;
2682 for (; partitions
->iterate (i
, &partition
); ++i
)
2683 if (!partition_builtin_p (partition
))
2686 /* If all partitions are builtins, distributing it would be profitable and
2687 we don't want to cancel the runtime alias checks. */
2688 if (i
== partitions
->length ())
2689 cancelable_p
= false;
2692 /* Generate internal function call for loop distribution alias check if the
2693 runtime alias check should be cancelable. */
2696 call_stmt
= gimple_build_call_internal (IFN_LOOP_DIST_ALIAS
,
2697 2, NULL_TREE
, cond_expr
);
2698 lhs
= make_ssa_name (boolean_type_node
);
2699 gimple_call_set_lhs (call_stmt
, lhs
);
2704 prob
= profile_probability::guessed_always ().apply_scale (9, 10);
2705 initialize_original_copy_tables ();
2706 nloop
= loop_version (loop
, lhs
, &cond_bb
, prob
, prob
.invert (),
2707 prob
, prob
.invert (), true);
2708 free_original_copy_tables ();
2709 /* Record the original loop number in newly generated loops. In case of
2710 distribution, the original loop will be distributed and the new loop
2712 loop
->orig_loop_num
= nloop
->num
;
2713 nloop
->orig_loop_num
= nloop
->num
;
2714 nloop
->dont_vectorize
= true;
2715 nloop
->force_vectorize
= false;
2719 /* Record new loop's num in IFN_LOOP_DIST_ALIAS because the original
2720 loop could be destroyed. */
2721 arg0
= build_int_cst (integer_type_node
, loop
->orig_loop_num
);
2722 gimple_call_set_arg (call_stmt
, 0, arg0
);
2723 gimple_seq_add_stmt_without_update (&cond_stmts
, call_stmt
);
2728 gimple_stmt_iterator cond_gsi
= gsi_last_bb (cond_bb
);
2729 gsi_insert_seq_before (&cond_gsi
, cond_stmts
, GSI_SAME_STMT
);
2731 update_ssa (TODO_update_ssa
);
2734 /* Return true if loop versioning is needed to distrubute PARTITIONS.
2735 ALIAS_DDRS are data dependence relations for runtime alias check. */
2738 version_for_distribution_p (vec
<struct partition
*> *partitions
,
2739 vec
<ddr_p
> *alias_ddrs
)
2741 /* No need to version loop if we have only one partition. */
2742 if (partitions
->length () == 1)
2745 /* Need to version loop if runtime alias check is necessary. */
2746 return (alias_ddrs
->length () > 0);
2749 /* Compare base offset of builtin mem* partitions P1 and P2. */
2752 offset_cmp (const void *vp1
, const void *vp2
)
2754 struct partition
*p1
= *(struct partition
*const *) vp1
;
2755 struct partition
*p2
= *(struct partition
*const *) vp2
;
2756 unsigned HOST_WIDE_INT o1
= p1
->builtin
->dst_base_offset
;
2757 unsigned HOST_WIDE_INT o2
= p2
->builtin
->dst_base_offset
;
2758 return (o2
< o1
) - (o1
< o2
);
2761 /* Fuse adjacent memset builtin PARTITIONS if possible. This is a special
2762 case optimization transforming below code:
2764 __builtin_memset (&obj, 0, 100);
2766 __builtin_memset (_1, 0, 200);
2768 __builtin_memset (_2, 0, 100);
2772 __builtin_memset (&obj, 0, 400);
2774 Note we don't have dependence information between different partitions
2775 at this point, as a result, we can't handle nonadjacent memset builtin
2776 partitions since dependence might be broken. */
2779 fuse_memset_builtins (vec
<struct partition
*> *partitions
)
2782 struct partition
*part1
, *part2
;
2785 for (i
= 0; partitions
->iterate (i
, &part1
);)
2787 if (part1
->kind
!= PKIND_MEMSET
)
2793 /* Find sub-array of memset builtins of the same base. Index range
2794 of the sub-array is [i, j) with "j > i". */
2795 for (j
= i
+ 1; partitions
->iterate (j
, &part2
); ++j
)
2797 if (part2
->kind
!= PKIND_MEMSET
2798 || !operand_equal_p (part1
->builtin
->dst_base_base
,
2799 part2
->builtin
->dst_base_base
, 0))
2802 /* Memset calls setting different values can't be merged. */
2803 rhs1
= gimple_assign_rhs1 (DR_STMT (part1
->builtin
->dst_dr
));
2804 rhs2
= gimple_assign_rhs1 (DR_STMT (part2
->builtin
->dst_dr
));
2805 if (!operand_equal_p (rhs1
, rhs2
, 0))
2809 /* Stable sort is required in order to avoid breaking dependence. */
2810 gcc_stablesort (&(*partitions
)[i
], j
- i
, sizeof (*partitions
)[i
],
2812 /* Continue with next partition. */
2816 /* Merge all consecutive memset builtin partitions. */
2817 for (i
= 0; i
< partitions
->length () - 1;)
2819 part1
= (*partitions
)[i
];
2820 if (part1
->kind
!= PKIND_MEMSET
)
2826 part2
= (*partitions
)[i
+ 1];
2827 /* Only merge memset partitions of the same base and with constant
2829 if (part2
->kind
!= PKIND_MEMSET
2830 || TREE_CODE (part1
->builtin
->size
) != INTEGER_CST
2831 || TREE_CODE (part2
->builtin
->size
) != INTEGER_CST
2832 || !operand_equal_p (part1
->builtin
->dst_base_base
,
2833 part2
->builtin
->dst_base_base
, 0))
2838 rhs1
= gimple_assign_rhs1 (DR_STMT (part1
->builtin
->dst_dr
));
2839 rhs2
= gimple_assign_rhs1 (DR_STMT (part2
->builtin
->dst_dr
));
2840 int bytev1
= const_with_all_bytes_same (rhs1
);
2841 int bytev2
= const_with_all_bytes_same (rhs2
);
2842 /* Only merge memset partitions of the same value. */
2843 if (bytev1
!= bytev2
|| bytev1
== -1)
2848 wide_int end1
= wi::add (part1
->builtin
->dst_base_offset
,
2849 wi::to_wide (part1
->builtin
->size
));
2850 /* Only merge adjacent memset partitions. */
2851 if (wi::ne_p (end1
, part2
->builtin
->dst_base_offset
))
2856 /* Merge partitions[i] and partitions[i+1]. */
2857 part1
->builtin
->size
= fold_build2 (PLUS_EXPR
, sizetype
,
2858 part1
->builtin
->size
,
2859 part2
->builtin
->size
);
2860 partition_free (part2
);
2861 partitions
->ordered_remove (i
+ 1);
2866 loop_distribution::finalize_partitions (class loop
*loop
,
2867 vec
<struct partition
*> *partitions
,
2868 vec
<ddr_p
> *alias_ddrs
)
2871 struct partition
*partition
, *a
;
2873 if (partitions
->length () == 1
2874 || alias_ddrs
->length () > 0)
2877 unsigned num_builtin
= 0, num_normal
= 0, num_partial_memset
= 0;
2878 bool same_type_p
= true;
2879 enum partition_type type
= ((*partitions
)[0])->type
;
2880 for (i
= 0; partitions
->iterate (i
, &partition
); ++i
)
2882 same_type_p
&= (type
== partition
->type
);
2883 if (partition_builtin_p (partition
))
2889 if (partition
->kind
== PKIND_PARTIAL_MEMSET
)
2890 num_partial_memset
++;
2893 /* Don't distribute current loop into too many loops given we don't have
2894 memory stream cost model. Be even more conservative in case of loop
2895 nest distribution. */
2896 if ((same_type_p
&& num_builtin
== 0
2897 && (loop
->inner
== NULL
|| num_normal
!= 2 || num_partial_memset
!= 1))
2898 || (loop
->inner
!= NULL
2899 && i
>= NUM_PARTITION_THRESHOLD
&& num_normal
> 1)
2900 || (loop
->inner
== NULL
2901 && i
>= NUM_PARTITION_THRESHOLD
&& num_normal
> num_builtin
))
2903 a
= (*partitions
)[0];
2904 for (i
= 1; partitions
->iterate (i
, &partition
); ++i
)
2906 partition_merge_into (NULL
, a
, partition
, FUSE_FINALIZE
);
2907 partition_free (partition
);
2909 partitions
->truncate (1);
2912 /* Fuse memset builtins if possible. */
2913 if (partitions
->length () > 1)
2914 fuse_memset_builtins (partitions
);
2917 /* Distributes the code from LOOP in such a way that producer statements
2918 are placed before consumer statements. Tries to separate only the
2919 statements from STMTS into separate loops. Returns the number of
2920 distributed loops. Set NB_CALLS to number of generated builtin calls.
2921 Set *DESTROY_P to whether LOOP needs to be destroyed. */
2924 loop_distribution::distribute_loop (class loop
*loop
, vec
<gimple
*> stmts
,
2925 control_dependences
*cd
, int *nb_calls
, bool *destroy_p
,
2926 bool only_patterns_p
)
2928 ddrs_table
= new hash_table
<ddr_hasher
> (389);
2930 partition
*partition
;
2935 loop_nest
.create (0);
2936 if (!find_loop_nest (loop
, &loop_nest
))
2938 loop_nest
.release ();
2943 datarefs_vec
.create (20);
2944 has_nonaddressable_dataref_p
= false;
2945 rdg
= build_rdg (loop
, cd
);
2948 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2950 "Loop %d not distributed: failed to build the RDG.\n",
2953 loop_nest
.release ();
2954 free_data_refs (datarefs_vec
);
2959 if (datarefs_vec
.length () > MAX_DATAREFS_NUM
)
2961 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2963 "Loop %d not distributed: too many memory references.\n",
2967 loop_nest
.release ();
2968 free_data_refs (datarefs_vec
);
2973 data_reference_p dref
;
2974 for (i
= 0; datarefs_vec
.iterate (i
, &dref
); ++i
)
2975 dref
->aux
= (void *) (uintptr_t) i
;
2977 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2978 dump_rdg (dump_file
, rdg
);
2980 auto_vec
<struct partition
*, 3> partitions
;
2981 rdg_build_partitions (rdg
, stmts
, &partitions
);
2983 auto_vec
<ddr_p
> alias_ddrs
;
2985 auto_bitmap stmt_in_all_partitions
;
2986 bitmap_copy (stmt_in_all_partitions
, partitions
[0]->stmts
);
2987 for (i
= 1; partitions
.iterate (i
, &partition
); ++i
)
2988 bitmap_and_into (stmt_in_all_partitions
, partitions
[i
]->stmts
);
2990 bool any_builtin
= false;
2991 bool reduction_in_all
= false;
2992 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
2995 |= classify_partition (loop
, rdg
, partition
, stmt_in_all_partitions
);
2996 any_builtin
|= partition_builtin_p (partition
);
2999 /* If we are only distributing patterns but did not detect any,
3008 /* If we are only distributing patterns fuse all partitions that
3009 were not classified as builtins. This also avoids chopping
3010 a loop into pieces, separated by builtin calls. That is, we
3011 only want no or a single loop body remaining. */
3012 struct partition
*into
;
3013 if (only_patterns_p
)
3015 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3016 if (!partition_builtin_p (into
))
3018 for (++i
; partitions
.iterate (i
, &partition
); ++i
)
3019 if (!partition_builtin_p (partition
))
3021 partition_merge_into (NULL
, into
, partition
, FUSE_NON_BUILTIN
);
3022 partitions
.unordered_remove (i
);
3023 partition_free (partition
);
3028 /* Due to limitations in the transform phase we have to fuse all
3029 reduction partitions into the last partition so the existing
3030 loop will contain all loop-closed PHI nodes. */
3031 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3032 if (partition_reduction_p (into
))
3034 for (i
= i
+ 1; partitions
.iterate (i
, &partition
); ++i
)
3035 if (partition_reduction_p (partition
))
3037 partition_merge_into (rdg
, into
, partition
, FUSE_REDUCTION
);
3038 partitions
.unordered_remove (i
);
3039 partition_free (partition
);
3043 /* Apply our simple cost model - fuse partitions with similar
3045 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3047 bool changed
= false;
3048 if (partition_builtin_p (into
) || into
->kind
== PKIND_PARTIAL_MEMSET
)
3051 partitions
.iterate (j
, &partition
); ++j
)
3053 if (share_memory_accesses (rdg
, into
, partition
))
3055 partition_merge_into (rdg
, into
, partition
, FUSE_SHARE_REF
);
3056 partitions
.unordered_remove (j
);
3057 partition_free (partition
);
3062 /* If we fused 0 1 2 in step 1 to 0,2 1 as 0 and 2 have similar
3063 accesses when 1 and 2 have similar accesses but not 0 and 1
3064 then in the next iteration we will fail to consider merging
3065 1 into 0,2. So try again if we did any merging into 0. */
3070 /* Put a non-builtin partition last if we need to preserve a reduction.
3071 ??? This is a workaround that makes sort_partitions_by_post_order do
3072 the correct thing while in reality it should sort each component
3073 separately and then put the component with a reduction or a non-builtin
3075 if (reduction_in_all
3076 && partition_builtin_p (partitions
.last()))
3077 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3078 if (!partition_builtin_p (partition
))
3080 partitions
.unordered_remove (i
);
3081 partitions
.quick_push (partition
);
3085 /* Build the partition dependency graph and fuse partitions in strong
3086 connected component. */
3087 if (partitions
.length () > 1)
3089 /* Don't support loop nest distribution under runtime alias check
3090 since it's not likely to enable many vectorization opportunities.
3091 Also if loop has any data reference which may be not addressable
3092 since alias check needs to take, compare address of the object. */
3093 if (loop
->inner
|| has_nonaddressable_dataref_p
)
3094 merge_dep_scc_partitions (rdg
, &partitions
, false);
3097 merge_dep_scc_partitions (rdg
, &partitions
, true);
3098 if (partitions
.length () > 1)
3099 break_alias_scc_partitions (rdg
, &partitions
, &alias_ddrs
);
3103 finalize_partitions (loop
, &partitions
, &alias_ddrs
);
3105 /* If there is a reduction in all partitions make sure the last one
3106 is not classified for builtin code generation. */
3107 if (reduction_in_all
)
3109 partition
= partitions
.last ();
3111 && partition_builtin_p (partition
)
3112 && !partition_builtin_p (partitions
[0]))
3117 partition
->kind
= PKIND_NORMAL
;
3120 nbp
= partitions
.length ();
3122 || (nbp
== 1 && !partition_builtin_p (partitions
[0]))
3123 || (nbp
> 1 && partition_contains_all_rw (rdg
, partitions
)))
3129 if (version_for_distribution_p (&partitions
, &alias_ddrs
))
3130 version_loop_by_alias_check (&partitions
, loop
, &alias_ddrs
);
3132 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3135 "distribute loop <%d> into partitions:\n", loop
->num
);
3136 dump_rdg_partitions (dump_file
, partitions
);
3139 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3141 if (partition_builtin_p (partition
))
3143 *destroy_p
|= generate_code_for_partition (loop
, partition
, i
< nbp
- 1);
3147 loop_nest
.release ();
3148 free_data_refs (datarefs_vec
);
3149 for (hash_table
<ddr_hasher
>::iterator iter
= ddrs_table
->begin ();
3150 iter
!= ddrs_table
->end (); ++iter
)
3152 free_dependence_relation (*iter
);
3157 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3158 partition_free (partition
);
3161 return nbp
- *nb_calls
;
3165 void loop_distribution::bb_top_order_init (void)
3168 int *rpo
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
3169 edge entry
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
3170 bitmap exit_bbs
= BITMAP_ALLOC (NULL
);
3172 bb_top_order_index
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
3173 bb_top_order_index_size
= last_basic_block_for_fn (cfun
);
3175 entry
->flags
&= ~EDGE_DFS_BACK
;
3176 bitmap_set_bit (exit_bbs
, EXIT_BLOCK
);
3177 rpo_num
= rev_post_order_and_mark_dfs_back_seme (cfun
, entry
, exit_bbs
, true,
3179 BITMAP_FREE (exit_bbs
);
3181 for (int i
= 0; i
< rpo_num
; i
++)
3182 bb_top_order_index
[rpo
[i
]] = i
;
3187 void loop_distribution::bb_top_order_destroy ()
3189 free (bb_top_order_index
);
3190 bb_top_order_index
= NULL
;
3191 bb_top_order_index_size
= 0;
3195 /* Given LOOP, this function records seed statements for distribution in
3196 WORK_LIST. Return false if there is nothing for distribution. */
3199 find_seed_stmts_for_distribution (class loop
*loop
, vec
<gimple
*> *work_list
)
3201 basic_block
*bbs
= get_loop_body_in_dom_order (loop
);
3203 /* Initialize the worklist with stmts we seed the partitions with. */
3204 for (unsigned i
= 0; i
< loop
->num_nodes
; ++i
)
3206 for (gphi_iterator gsi
= gsi_start_phis (bbs
[i
]);
3207 !gsi_end_p (gsi
); gsi_next (&gsi
))
3209 gphi
*phi
= gsi
.phi ();
3210 if (virtual_operand_p (gimple_phi_result (phi
)))
3212 /* Distribute stmts which have defs that are used outside of
3214 if (!stmt_has_scalar_dependences_outside_loop (loop
, phi
))
3216 work_list
->safe_push (phi
);
3218 for (gimple_stmt_iterator gsi
= gsi_start_bb (bbs
[i
]);
3219 !gsi_end_p (gsi
); gsi_next (&gsi
))
3221 gimple
*stmt
= gsi_stmt (gsi
);
3223 /* Ignore clobbers, they do not have true side effects. */
3224 if (gimple_clobber_p (stmt
))
3227 /* If there is a stmt with side-effects bail out - we
3228 cannot and should not distribute this loop. */
3229 if (gimple_has_side_effects (stmt
))
3235 /* Distribute stmts which have defs that are used outside of
3237 if (stmt_has_scalar_dependences_outside_loop (loop
, stmt
))
3239 /* Otherwise only distribute stores for now. */
3240 else if (!gimple_vdef (stmt
))
3243 work_list
->safe_push (stmt
);
3247 return work_list
->length () > 0;
3250 /* Given innermost LOOP, return the outermost enclosing loop that forms a
3251 perfect loop nest. */
3254 prepare_perfect_loop_nest (class loop
*loop
)
3256 class loop
*outer
= loop_outer (loop
);
3257 tree niters
= number_of_latch_executions (loop
);
3259 /* TODO: We only support the innermost 3-level loop nest distribution
3260 because of compilation time issue for now. This should be relaxed
3261 in the future. Note we only allow 3-level loop nest distribution
3262 when parallelizing loops. */
3263 while ((loop
->inner
== NULL
3264 || (loop
->inner
->inner
== NULL
&& flag_tree_parallelize_loops
> 1))
3265 && loop_outer (outer
)
3266 && outer
->inner
== loop
&& loop
->next
== NULL
3267 && single_exit (outer
)
3268 && !chrec_contains_symbols_defined_in_loop (niters
, outer
->num
)
3269 && (niters
= number_of_latch_executions (outer
)) != NULL_TREE
3270 && niters
!= chrec_dont_know
)
3273 outer
= loop_outer (loop
);
3281 loop_distribution::execute (function
*fun
)
3284 bool changed
= false;
3286 control_dependences
*cd
= NULL
;
3287 auto_vec
<loop_p
> loops_to_be_destroyed
;
3289 if (number_of_loops (fun
) <= 1)
3292 bb_top_order_init ();
3294 FOR_ALL_BB_FN (bb
, fun
)
3296 gimple_stmt_iterator gsi
;
3297 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3298 gimple_set_uid (gsi_stmt (gsi
), -1);
3299 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3300 gimple_set_uid (gsi_stmt (gsi
), -1);
3303 /* We can at the moment only distribute non-nested loops, thus restrict
3304 walking to innermost loops. */
3305 FOR_EACH_LOOP (loop
, LI_ONLY_INNERMOST
)
3307 /* Don't distribute multiple exit edges loop, or cold loop when
3308 not doing pattern detection. */
3309 if (!single_exit (loop
)
3310 || (!flag_tree_loop_distribute_patterns
3311 && !optimize_loop_for_speed_p (loop
)))
3314 /* Don't distribute loop if niters is unknown. */
3315 tree niters
= number_of_latch_executions (loop
);
3316 if (niters
== NULL_TREE
|| niters
== chrec_dont_know
)
3319 /* Get the perfect loop nest for distribution. */
3320 loop
= prepare_perfect_loop_nest (loop
);
3321 for (; loop
; loop
= loop
->inner
)
3323 auto_vec
<gimple
*> work_list
;
3324 if (!find_seed_stmts_for_distribution (loop
, &work_list
))
3327 const char *str
= loop
->inner
? " nest" : "";
3328 dump_user_location_t loc
= find_loop_location (loop
);
3331 calculate_dominance_info (CDI_DOMINATORS
);
3332 calculate_dominance_info (CDI_POST_DOMINATORS
);
3333 cd
= new control_dependences ();
3334 free_dominance_info (CDI_POST_DOMINATORS
);
3338 int nb_generated_loops
, nb_generated_calls
;
3340 = distribute_loop (loop
, work_list
, cd
, &nb_generated_calls
,
3341 &destroy_p
, (!optimize_loop_for_speed_p (loop
)
3342 || !flag_tree_loop_distribution
));
3344 loops_to_be_destroyed
.safe_push (loop
);
3346 if (nb_generated_loops
+ nb_generated_calls
> 0)
3349 if (dump_enabled_p ())
3350 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
,
3351 loc
, "Loop%s %d distributed: split to %d loops "
3352 "and %d library calls.\n", str
, loop
->num
,
3353 nb_generated_loops
, nb_generated_calls
);
3358 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3359 fprintf (dump_file
, "Loop%s %d not distributed.\n", str
, loop
->num
);
3366 if (bb_top_order_index
!= NULL
)
3367 bb_top_order_destroy ();
3371 /* Destroy loop bodies that could not be reused. Do this late as we
3372 otherwise can end up refering to stale data in control dependences. */
3374 FOR_EACH_VEC_ELT (loops_to_be_destroyed
, i
, loop
)
3375 destroy_loop (loop
);
3377 /* Cached scalar evolutions now may refer to wrong or non-existing
3380 mark_virtual_operands_for_renaming (fun
);
3381 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
3384 checking_verify_loop_structure ();
3386 return changed
? TODO_cleanup_cfg
: 0;
3390 /* Distribute all loops in the current function. */
3394 const pass_data pass_data_loop_distribution
=
3396 GIMPLE_PASS
, /* type */
3398 OPTGROUP_LOOP
, /* optinfo_flags */
3399 TV_TREE_LOOP_DISTRIBUTION
, /* tv_id */
3400 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3401 0, /* properties_provided */
3402 0, /* properties_destroyed */
3403 0, /* todo_flags_start */
3404 0, /* todo_flags_finish */
3407 class pass_loop_distribution
: public gimple_opt_pass
3410 pass_loop_distribution (gcc::context
*ctxt
)
3411 : gimple_opt_pass (pass_data_loop_distribution
, ctxt
)
3414 /* opt_pass methods: */
3415 virtual bool gate (function
*)
3417 return flag_tree_loop_distribution
3418 || flag_tree_loop_distribute_patterns
;
3421 virtual unsigned int execute (function
*);
3423 }; // class pass_loop_distribution
3426 pass_loop_distribution::execute (function
*fun
)
3428 return loop_distribution ().execute (fun
);
3434 make_pass_loop_distribution (gcc::context
*ctxt
)
3436 return new pass_loop_distribution (ctxt
);