2 Copyright (C) 2006-2023 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 #include "memmodel.h"
123 #include "tree-ssa-loop-niter.h"
126 #define MAX_DATAREFS_NUM \
127 ((unsigned) param_loop_max_datarefs_for_datadeps)
129 /* Threshold controlling number of distributed partitions. Given it may
130 be unnecessary if a memory stream cost model is invented in the future,
131 we define it as a temporary macro, rather than a parameter. */
132 #define NUM_PARTITION_THRESHOLD (4)
134 /* Hashtable helpers. */
136 struct ddr_hasher
: nofree_ptr_hash
<struct data_dependence_relation
>
138 static inline hashval_t
hash (const data_dependence_relation
*);
139 static inline bool equal (const data_dependence_relation
*,
140 const data_dependence_relation
*);
143 /* Hash function for data dependence. */
146 ddr_hasher::hash (const data_dependence_relation
*ddr
)
149 h
.add_ptr (DDR_A (ddr
));
150 h
.add_ptr (DDR_B (ddr
));
154 /* Hash table equality function for data dependence. */
157 ddr_hasher::equal (const data_dependence_relation
*ddr1
,
158 const data_dependence_relation
*ddr2
)
160 return (DDR_A (ddr1
) == DDR_A (ddr2
) && DDR_B (ddr1
) == DDR_B (ddr2
));
165 #define DR_INDEX(dr) ((uintptr_t) (dr)->aux)
167 /* A Reduced Dependence Graph (RDG) vertex representing a statement. */
170 /* The statement represented by this vertex. */
173 /* Vector of data-references in this statement. */
174 vec
<data_reference_p
> datarefs
;
176 /* True when the statement contains a write to memory. */
179 /* True when the statement contains a read from memory. */
183 #define RDGV_STMT(V) ((struct rdg_vertex *) ((V)->data))->stmt
184 #define RDGV_DATAREFS(V) ((struct rdg_vertex *) ((V)->data))->datarefs
185 #define RDGV_HAS_MEM_WRITE(V) ((struct rdg_vertex *) ((V)->data))->has_mem_write
186 #define RDGV_HAS_MEM_READS(V) ((struct rdg_vertex *) ((V)->data))->has_mem_reads
187 #define RDG_STMT(RDG, I) RDGV_STMT (&(RDG->vertices[I]))
188 #define RDG_DATAREFS(RDG, I) RDGV_DATAREFS (&(RDG->vertices[I]))
189 #define RDG_MEM_WRITE_STMT(RDG, I) RDGV_HAS_MEM_WRITE (&(RDG->vertices[I]))
190 #define RDG_MEM_READS_STMT(RDG, I) RDGV_HAS_MEM_READS (&(RDG->vertices[I]))
192 /* Data dependence type. */
196 /* Read After Write (RAW). */
199 /* Control dependence (execute conditional on). */
203 /* Dependence information attached to an edge of the RDG. */
207 /* Type of the dependence. */
208 enum rdg_dep_type type
;
211 #define RDGE_TYPE(E) ((struct rdg_edge *) ((E)->data))->type
213 /* Kind of distributed loop. */
214 enum partition_kind
{
216 /* Partial memset stands for a paritition can be distributed into a loop
217 of memset calls, rather than a single memset call. It's handled just
218 like a normal parition, i.e, distributed as separate loop, no memset
221 Note: This is a hacking fix trying to distribute ZERO-ing stmt in a
222 loop nest as deep as possible. As a result, parloop achieves better
223 parallelization by parallelizing deeper loop nest. This hack should
224 be unnecessary and removed once distributed memset can be understood
225 and analyzed in data reference analysis. See PR82604 for more. */
226 PKIND_PARTIAL_MEMSET
,
227 PKIND_MEMSET
, PKIND_MEMCPY
, PKIND_MEMMOVE
230 /* Type of distributed loop. */
231 enum partition_type
{
232 /* The distributed loop can be executed parallelly. */
234 /* The distributed loop has to be executed sequentially. */
238 /* Builtin info for loop distribution. */
241 /* data-references a kind != PKIND_NORMAL partition is about. */
242 data_reference_p dst_dr
;
243 data_reference_p src_dr
;
244 /* Base address and size of memory objects operated by the builtin. Note
245 both dest and source memory objects must have the same size. */
249 /* Base and offset part of dst_base after stripping constant offset. This
250 is only used in memset builtin distribution for now. */
252 unsigned HOST_WIDE_INT dst_base_offset
;
255 /* Partition for loop distribution. */
258 /* Statements of the partition. */
260 /* True if the partition defines variable which is used outside of loop. */
263 enum partition_kind kind
;
264 enum partition_type type
;
265 /* Data references in the partition. */
267 /* Information of builtin parition. */
268 struct builtin_info
*builtin
;
271 /* Partitions are fused because of different reasons. */
274 FUSE_NON_BUILTIN
= 0,
281 /* Description on different fusing reason. */
282 static const char *fuse_message
[] = {
283 "they are non-builtins",
284 "they have reductions",
285 "they have shared memory refs",
286 "they are in the same dependence scc",
287 "there is no point to distribute loop"};
290 /* Dump vertex I in RDG to FILE. */
293 dump_rdg_vertex (FILE *file
, struct graph
*rdg
, int i
)
295 struct vertex
*v
= &(rdg
->vertices
[i
]);
296 struct graph_edge
*e
;
298 fprintf (file
, "(vertex %d: (%s%s) (in:", i
,
299 RDG_MEM_WRITE_STMT (rdg
, i
) ? "w" : "",
300 RDG_MEM_READS_STMT (rdg
, i
) ? "r" : "");
303 for (e
= v
->pred
; e
; e
= e
->pred_next
)
304 fprintf (file
, " %d", e
->src
);
306 fprintf (file
, ") (out:");
309 for (e
= v
->succ
; e
; e
= e
->succ_next
)
310 fprintf (file
, " %d", e
->dest
);
312 fprintf (file
, ")\n");
313 print_gimple_stmt (file
, RDGV_STMT (v
), 0, TDF_VOPS
|TDF_MEMSYMS
);
314 fprintf (file
, ")\n");
317 /* Call dump_rdg_vertex on stderr. */
320 debug_rdg_vertex (struct graph
*rdg
, int i
)
322 dump_rdg_vertex (stderr
, rdg
, i
);
325 /* Dump the reduced dependence graph RDG to FILE. */
328 dump_rdg (FILE *file
, struct graph
*rdg
)
330 fprintf (file
, "(rdg\n");
331 for (int i
= 0; i
< rdg
->n_vertices
; i
++)
332 dump_rdg_vertex (file
, rdg
, i
);
333 fprintf (file
, ")\n");
336 /* Call dump_rdg on stderr. */
339 debug_rdg (struct graph
*rdg
)
341 dump_rdg (stderr
, rdg
);
345 dot_rdg_1 (FILE *file
, struct graph
*rdg
)
348 pretty_printer buffer
;
349 pp_needs_newline (&buffer
) = false;
350 buffer
.buffer
->stream
= file
;
352 fprintf (file
, "digraph RDG {\n");
354 for (i
= 0; i
< rdg
->n_vertices
; i
++)
356 struct vertex
*v
= &(rdg
->vertices
[i
]);
357 struct graph_edge
*e
;
359 fprintf (file
, "%d [label=\"[%d] ", i
, i
);
360 pp_gimple_stmt_1 (&buffer
, RDGV_STMT (v
), 0, TDF_SLIM
);
362 fprintf (file
, "\"]\n");
364 /* Highlight reads from memory. */
365 if (RDG_MEM_READS_STMT (rdg
, i
))
366 fprintf (file
, "%d [style=filled, fillcolor=green]\n", i
);
368 /* Highlight stores to memory. */
369 if (RDG_MEM_WRITE_STMT (rdg
, i
))
370 fprintf (file
, "%d [style=filled, fillcolor=red]\n", i
);
373 for (e
= v
->succ
; e
; e
= e
->succ_next
)
374 switch (RDGE_TYPE (e
))
377 /* These are the most common dependences: don't print these. */
378 fprintf (file
, "%d -> %d \n", i
, e
->dest
);
382 fprintf (file
, "%d -> %d [label=control] \n", i
, e
->dest
);
390 fprintf (file
, "}\n\n");
393 /* Display the Reduced Dependence Graph using dotty. */
396 dot_rdg (struct graph
*rdg
)
398 /* When debugging, you may want to enable the following code. */
400 FILE *file
= popen ("dot -Tx11", "w");
403 dot_rdg_1 (file
, rdg
);
405 close (fileno (file
));
408 dot_rdg_1 (stderr
, rdg
);
412 /* Returns the index of STMT in RDG. */
415 rdg_vertex_for_stmt (struct graph
*rdg ATTRIBUTE_UNUSED
, gimple
*stmt
)
417 int index
= gimple_uid (stmt
);
418 gcc_checking_assert (index
== -1 || RDG_STMT (rdg
, index
) == stmt
);
422 /* Creates dependence edges in RDG for all the uses of DEF. IDEF is
423 the index of DEF in RDG. */
426 create_rdg_edges_for_scalar (struct graph
*rdg
, tree def
, int idef
)
428 use_operand_p imm_use_p
;
429 imm_use_iterator iterator
;
431 FOR_EACH_IMM_USE_FAST (imm_use_p
, iterator
, def
)
433 struct graph_edge
*e
;
434 int use
= rdg_vertex_for_stmt (rdg
, USE_STMT (imm_use_p
));
439 e
= add_edge (rdg
, idef
, use
);
440 e
->data
= XNEW (struct rdg_edge
);
441 RDGE_TYPE (e
) = flow_dd
;
445 /* Creates an edge for the control dependences of BB to the vertex V. */
448 create_edge_for_control_dependence (struct graph
*rdg
, basic_block bb
,
449 int v
, control_dependences
*cd
)
453 EXECUTE_IF_SET_IN_BITMAP (cd
->get_edges_dependent_on (bb
->index
),
456 basic_block cond_bb
= cd
->get_edge_src (edge_n
);
457 gimple
*stmt
= *gsi_last_bb (cond_bb
);
458 if (stmt
&& is_ctrl_stmt (stmt
))
460 struct graph_edge
*e
;
461 int c
= rdg_vertex_for_stmt (rdg
, stmt
);
465 e
= add_edge (rdg
, c
, v
);
466 e
->data
= XNEW (struct rdg_edge
);
467 RDGE_TYPE (e
) = control_dd
;
472 /* Creates the edges of the reduced dependence graph RDG. */
475 create_rdg_flow_edges (struct graph
*rdg
)
481 for (i
= 0; i
< rdg
->n_vertices
; i
++)
482 FOR_EACH_PHI_OR_STMT_DEF (def_p
, RDG_STMT (rdg
, i
),
484 create_rdg_edges_for_scalar (rdg
, DEF_FROM_PTR (def_p
), i
);
487 /* Creates the edges of the reduced dependence graph RDG. */
490 create_rdg_cd_edges (struct graph
*rdg
, control_dependences
*cd
, loop_p loop
)
494 for (i
= 0; i
< rdg
->n_vertices
; i
++)
496 gimple
*stmt
= RDG_STMT (rdg
, i
);
497 if (gimple_code (stmt
) == GIMPLE_PHI
)
501 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->preds
)
502 if (flow_bb_inside_loop_p (loop
, e
->src
))
503 create_edge_for_control_dependence (rdg
, e
->src
, i
, cd
);
506 create_edge_for_control_dependence (rdg
, gimple_bb (stmt
), i
, cd
);
511 class loop_distribution
514 /* The loop (nest) to be distributed. */
515 vec
<loop_p
> loop_nest
;
517 /* Vector of data references in the loop to be distributed. */
518 vec
<data_reference_p
> datarefs_vec
;
520 /* If there is nonaddressable data reference in above vector. */
521 bool has_nonaddressable_dataref_p
;
523 /* Store index of data reference in aux field. */
525 /* Hash table for data dependence relation in the loop to be distributed. */
526 hash_table
<ddr_hasher
> *ddrs_table
;
528 /* Array mapping basic block's index to its topological order. */
529 int *bb_top_order_index
;
530 /* And size of the array. */
531 int bb_top_order_index_size
;
533 /* Build the vertices of the reduced dependence graph RDG. Return false
535 bool create_rdg_vertices (struct graph
*rdg
, const vec
<gimple
*> &stmts
,
538 /* Initialize STMTS with all the statements of LOOP. We use topological
539 order to discover all statements. The order is important because
540 generate_loops_for_partition is using the same traversal for identifying
541 statements in loop copies. */
542 void stmts_from_loop (class loop
*loop
, vec
<gimple
*> *stmts
);
545 /* Build the Reduced Dependence Graph (RDG) with one vertex per statement of
546 LOOP, and one edge per flow dependence or control dependence from control
547 dependence CD. During visiting each statement, data references are also
548 collected and recorded in global data DATAREFS_VEC. */
549 struct graph
* build_rdg (class loop
*loop
, control_dependences
*cd
);
551 /* Merge PARTITION into the partition DEST. RDG is the reduced dependence
552 graph and we update type for result partition if it is non-NULL. */
553 void partition_merge_into (struct graph
*rdg
,
554 partition
*dest
, partition
*partition
,
558 /* Return data dependence relation for data references A and B. The two
559 data references must be in lexicographic order wrto reduced dependence
560 graph RDG. We firstly try to find ddr from global ddr hash table. If
561 it doesn't exist, compute the ddr and cache it. */
562 data_dependence_relation
* get_data_dependence (struct graph
*rdg
,
567 /* In reduced dependence graph RDG for loop distribution, return true if
568 dependence between references DR1 and DR2 leads to a dependence cycle
569 and such dependence cycle can't be resolved by runtime alias check. */
570 bool data_dep_in_cycle_p (struct graph
*rdg
, data_reference_p dr1
,
571 data_reference_p dr2
);
574 /* Given reduced dependence graph RDG, PARTITION1 and PARTITION2, update
575 PARTITION1's type after merging PARTITION2 into PARTITION1. */
576 void update_type_for_merge (struct graph
*rdg
,
577 partition
*partition1
, partition
*partition2
);
580 /* Returns a partition with all the statements needed for computing
581 the vertex V of the RDG, also including the loop exit conditions. */
582 partition
*build_rdg_partition_for_vertex (struct graph
*rdg
, int v
);
584 /* Given data references DST_DR and SRC_DR in loop nest LOOP and RDG, classify
585 if it forms builtin memcpy or memmove call. */
586 void classify_builtin_ldst (loop_p loop
, struct graph
*rdg
, partition
*partition
,
587 data_reference_p dst_dr
, data_reference_p src_dr
);
589 /* Classifies the builtin kind we can generate for PARTITION of RDG and LOOP.
590 For the moment we detect memset, memcpy and memmove patterns. Bitmap
591 STMT_IN_ALL_PARTITIONS contains statements belonging to all partitions.
592 Returns true if there is a reduction in all partitions and we
593 possibly did not mark PARTITION as having one for this reason. */
596 classify_partition (loop_p loop
,
597 struct graph
*rdg
, partition
*partition
,
598 bitmap stmt_in_all_partitions
);
601 /* Returns true when PARTITION1 and PARTITION2 access the same memory
603 bool share_memory_accesses (struct graph
*rdg
,
604 partition
*partition1
, partition
*partition2
);
606 /* For each seed statement in STARTING_STMTS, this function builds
607 partition for it by adding depended statements according to RDG.
608 All partitions are recorded in PARTITIONS. */
609 void rdg_build_partitions (struct graph
*rdg
,
610 vec
<gimple
*> starting_stmts
,
611 vec
<partition
*> *partitions
);
613 /* Compute partition dependence created by the data references in DRS1
614 and DRS2, modify and return DIR according to that. IF ALIAS_DDR is
615 not NULL, we record dependence introduced by possible alias between
616 two data references in ALIAS_DDRS; otherwise, we simply ignore such
617 dependence as if it doesn't exist at all. */
618 int pg_add_dependence_edges (struct graph
*rdg
, int dir
, bitmap drs1
,
619 bitmap drs2
, vec
<ddr_p
> *alias_ddrs
);
622 /* Build and return partition dependence graph for PARTITIONS. RDG is
623 reduced dependence graph for the loop to be distributed. If IGNORE_ALIAS_P
624 is true, data dependence caused by possible alias between references
625 is ignored, as if it doesn't exist at all; otherwise all depdendences
627 struct graph
*build_partition_graph (struct graph
*rdg
,
628 vec
<struct partition
*> *partitions
,
629 bool ignore_alias_p
);
631 /* Given reduced dependence graph RDG merge strong connected components
632 of PARTITIONS. If IGNORE_ALIAS_P is true, data dependence caused by
633 possible alias between references is ignored, as if it doesn't exist
634 at all; otherwise all depdendences are considered. */
635 void merge_dep_scc_partitions (struct graph
*rdg
, vec
<struct partition
*>
636 *partitions
, bool ignore_alias_p
);
638 /* This is the main function breaking strong conected components in
639 PARTITIONS giving reduced depdendence graph RDG. Store data dependence
640 relations for runtime alias check in ALIAS_DDRS. */
641 void break_alias_scc_partitions (struct graph
*rdg
, vec
<struct partition
*>
642 *partitions
, vec
<ddr_p
> *alias_ddrs
);
645 /* Fuse PARTITIONS of LOOP if necessary before finalizing distribution.
646 ALIAS_DDRS contains ddrs which need runtime alias check. */
647 void finalize_partitions (class loop
*loop
, vec
<struct partition
*>
648 *partitions
, vec
<ddr_p
> *alias_ddrs
);
650 /* Distributes the code from LOOP in such a way that producer statements
651 are placed before consumer statements. Tries to separate only the
652 statements from STMTS into separate loops. Returns the number of
653 distributed loops. Set NB_CALLS to number of generated builtin calls.
654 Set *DESTROY_P to whether LOOP needs to be destroyed. */
655 int distribute_loop (class loop
*loop
, const vec
<gimple
*> &stmts
,
656 control_dependences
*cd
, int *nb_calls
, bool *destroy_p
,
657 bool only_patterns_p
);
659 /* Transform loops which mimic the effects of builtins rawmemchr or strlen and
660 replace them accordingly. */
661 bool transform_reduction_loop (loop_p loop
);
663 /* Compute topological order for basic blocks. Topological order is
664 needed because data dependence is computed for data references in
665 lexicographical order. */
666 void bb_top_order_init (void);
668 void bb_top_order_destroy (void);
672 /* Getter for bb_top_order. */
674 inline int get_bb_top_order_index_size (void)
676 return bb_top_order_index_size
;
679 inline int get_bb_top_order_index (int i
)
681 return bb_top_order_index
[i
];
684 unsigned int execute (function
*fun
);
688 /* If X has a smaller topological sort number than Y, returns -1;
689 if greater, returns 1. */
691 bb_top_order_cmp_r (const void *x
, const void *y
, void *loop
)
693 loop_distribution
*_loop
=
694 (loop_distribution
*) loop
;
696 basic_block bb1
= *(const basic_block
*) x
;
697 basic_block bb2
= *(const basic_block
*) y
;
699 int bb_top_order_index_size
= _loop
->get_bb_top_order_index_size ();
701 gcc_assert (bb1
->index
< bb_top_order_index_size
702 && bb2
->index
< bb_top_order_index_size
);
703 gcc_assert (bb1
== bb2
704 || _loop
->get_bb_top_order_index(bb1
->index
)
705 != _loop
->get_bb_top_order_index(bb2
->index
));
707 return (_loop
->get_bb_top_order_index(bb1
->index
) -
708 _loop
->get_bb_top_order_index(bb2
->index
));
712 loop_distribution::create_rdg_vertices (struct graph
*rdg
,
713 const vec
<gimple
*> &stmts
,
719 FOR_EACH_VEC_ELT (stmts
, i
, stmt
)
721 struct vertex
*v
= &(rdg
->vertices
[i
]);
723 /* Record statement to vertex mapping. */
724 gimple_set_uid (stmt
, i
);
726 v
->data
= XNEW (struct rdg_vertex
);
727 RDGV_STMT (v
) = stmt
;
728 RDGV_DATAREFS (v
).create (0);
729 RDGV_HAS_MEM_WRITE (v
) = false;
730 RDGV_HAS_MEM_READS (v
) = false;
731 if (gimple_code (stmt
) == GIMPLE_PHI
)
734 unsigned drp
= datarefs_vec
.length ();
735 if (!find_data_references_in_stmt (loop
, stmt
, &datarefs_vec
))
737 for (unsigned j
= drp
; j
< datarefs_vec
.length (); ++j
)
739 data_reference_p dr
= datarefs_vec
[j
];
741 RDGV_HAS_MEM_READS (v
) = true;
743 RDGV_HAS_MEM_WRITE (v
) = true;
744 RDGV_DATAREFS (v
).safe_push (dr
);
745 has_nonaddressable_dataref_p
|= may_be_nonaddressable_p (dr
->ref
);
752 loop_distribution::stmts_from_loop (class loop
*loop
, vec
<gimple
*> *stmts
)
755 basic_block
*bbs
= get_loop_body_in_custom_order (loop
, this, bb_top_order_cmp_r
);
757 for (i
= 0; i
< loop
->num_nodes
; i
++)
759 basic_block bb
= bbs
[i
];
761 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);
763 if (!virtual_operand_p (gimple_phi_result (bsi
.phi ())))
764 stmts
->safe_push (bsi
.phi ());
766 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);
769 gimple
*stmt
= gsi_stmt (bsi
);
770 if (gimple_code (stmt
) != GIMPLE_LABEL
&& !is_gimple_debug (stmt
))
771 stmts
->safe_push (stmt
);
778 /* Free the reduced dependence graph RDG. */
781 free_rdg (struct graph
*rdg
)
785 for (i
= 0; i
< rdg
->n_vertices
; i
++)
787 struct vertex
*v
= &(rdg
->vertices
[i
]);
788 struct graph_edge
*e
;
790 for (e
= v
->succ
; e
; e
= e
->succ_next
)
795 gimple_set_uid (RDGV_STMT (v
), -1);
796 (RDGV_DATAREFS (v
)).release ();
805 loop_distribution::build_rdg (class loop
*loop
, control_dependences
*cd
)
809 /* Create the RDG vertices from the stmts of the loop nest. */
810 auto_vec
<gimple
*, 10> stmts
;
811 stmts_from_loop (loop
, &stmts
);
812 rdg
= new_graph (stmts
.length ());
813 if (!create_rdg_vertices (rdg
, stmts
, loop
))
820 create_rdg_flow_edges (rdg
);
822 create_rdg_cd_edges (rdg
, cd
, loop
);
828 /* Allocate and initialize a partition from BITMAP. */
831 partition_alloc (void)
833 partition
*partition
= XCNEW (struct partition
);
834 partition
->stmts
= BITMAP_ALLOC (NULL
);
835 partition
->reduction_p
= false;
836 partition
->loc
= UNKNOWN_LOCATION
;
837 partition
->kind
= PKIND_NORMAL
;
838 partition
->type
= PTYPE_PARALLEL
;
839 partition
->datarefs
= BITMAP_ALLOC (NULL
);
843 /* Free PARTITION. */
846 partition_free (partition
*partition
)
848 BITMAP_FREE (partition
->stmts
);
849 BITMAP_FREE (partition
->datarefs
);
850 if (partition
->builtin
)
851 free (partition
->builtin
);
856 /* Returns true if the partition can be generated as a builtin. */
859 partition_builtin_p (partition
*partition
)
861 return partition
->kind
> PKIND_PARTIAL_MEMSET
;
864 /* Returns true if the partition contains a reduction. */
867 partition_reduction_p (partition
*partition
)
869 return partition
->reduction_p
;
873 loop_distribution::partition_merge_into (struct graph
*rdg
,
874 partition
*dest
, partition
*partition
, enum fuse_type ft
)
876 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
878 fprintf (dump_file
, "Fuse partitions because %s:\n", fuse_message
[ft
]);
879 fprintf (dump_file
, " Part 1: ");
880 dump_bitmap (dump_file
, dest
->stmts
);
881 fprintf (dump_file
, " Part 2: ");
882 dump_bitmap (dump_file
, partition
->stmts
);
885 dest
->kind
= PKIND_NORMAL
;
886 if (dest
->type
== PTYPE_PARALLEL
)
887 dest
->type
= partition
->type
;
889 bitmap_ior_into (dest
->stmts
, partition
->stmts
);
890 if (partition_reduction_p (partition
))
891 dest
->reduction_p
= true;
893 /* Further check if any data dependence prevents us from executing the
894 new partition parallelly. */
895 if (dest
->type
== PTYPE_PARALLEL
&& rdg
!= NULL
)
896 update_type_for_merge (rdg
, dest
, partition
);
898 bitmap_ior_into (dest
->datarefs
, partition
->datarefs
);
902 /* Returns true when DEF is an SSA_NAME defined in LOOP and used after
906 ssa_name_has_uses_outside_loop_p (tree def
, loop_p loop
)
908 imm_use_iterator imm_iter
;
911 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, def
)
913 if (is_gimple_debug (USE_STMT (use_p
)))
916 basic_block use_bb
= gimple_bb (USE_STMT (use_p
));
917 if (!flow_bb_inside_loop_p (loop
, use_bb
))
924 /* Returns true when STMT defines a scalar variable used after the
928 stmt_has_scalar_dependences_outside_loop (loop_p loop
, gimple
*stmt
)
933 if (gimple_code (stmt
) == GIMPLE_PHI
)
934 return ssa_name_has_uses_outside_loop_p (gimple_phi_result (stmt
), loop
);
936 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
937 if (ssa_name_has_uses_outside_loop_p (DEF_FROM_PTR (def_p
), loop
))
943 /* Return a copy of LOOP placed before LOOP. */
946 copy_loop_before (class loop
*loop
, bool redirect_lc_phi_defs
)
949 edge preheader
= loop_preheader_edge (loop
);
951 initialize_original_copy_tables ();
952 res
= slpeel_tree_duplicate_loop_to_edge_cfg (loop
, single_exit (loop
), NULL
,
953 NULL
, preheader
, NULL
, false);
954 gcc_assert (res
!= NULL
);
956 /* When a not last partition is supposed to keep the LC PHIs computed
957 adjust their definitions. */
958 if (redirect_lc_phi_defs
)
960 edge exit
= single_exit (loop
);
961 for (gphi_iterator si
= gsi_start_phis (exit
->dest
); !gsi_end_p (si
);
964 gphi
*phi
= si
.phi ();
965 if (virtual_operand_p (gimple_phi_result (phi
)))
967 use_operand_p use_p
= PHI_ARG_DEF_PTR_FROM_EDGE (phi
, exit
);
968 tree new_def
= get_current_def (USE_FROM_PTR (use_p
));
969 SET_USE (use_p
, new_def
);
973 free_original_copy_tables ();
974 delete_update_ssa ();
979 /* Creates an empty basic block after LOOP. */
982 create_bb_after_loop (class loop
*loop
)
984 edge exit
= single_exit (loop
);
992 /* Generate code for PARTITION from the code in LOOP. The loop is
993 copied when COPY_P is true. All the statements not flagged in the
994 PARTITION bitmap are removed from the loop or from its copy. The
995 statements are indexed in sequence inside a basic block, and the
996 basic blocks of a loop are taken in dom order. */
999 generate_loops_for_partition (class loop
*loop
, partition
*partition
,
1000 bool copy_p
, bool keep_lc_phis_p
)
1007 int orig_loop_num
= loop
->orig_loop_num
;
1008 loop
= copy_loop_before (loop
, keep_lc_phis_p
);
1009 gcc_assert (loop
!= NULL
);
1010 loop
->orig_loop_num
= orig_loop_num
;
1011 create_preheader (loop
, CP_SIMPLE_PREHEADERS
);
1012 create_bb_after_loop (loop
);
1016 /* Origin number is set to the new versioned loop's num. */
1017 gcc_assert (loop
->orig_loop_num
!= loop
->num
);
1020 /* Remove stmts not in the PARTITION bitmap. */
1021 bbs
= get_loop_body_in_dom_order (loop
);
1023 if (MAY_HAVE_DEBUG_BIND_STMTS
)
1024 for (i
= 0; i
< loop
->num_nodes
; i
++)
1026 basic_block bb
= bbs
[i
];
1028 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);
1031 gphi
*phi
= bsi
.phi ();
1032 if (!virtual_operand_p (gimple_phi_result (phi
))
1033 && !bitmap_bit_p (partition
->stmts
, gimple_uid (phi
)))
1034 reset_debug_uses (phi
);
1037 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1039 gimple
*stmt
= gsi_stmt (bsi
);
1040 if (gimple_code (stmt
) != GIMPLE_LABEL
1041 && !is_gimple_debug (stmt
)
1042 && !bitmap_bit_p (partition
->stmts
, gimple_uid (stmt
)))
1043 reset_debug_uses (stmt
);
1047 for (i
= 0; i
< loop
->num_nodes
; i
++)
1049 basic_block bb
= bbs
[i
];
1050 edge inner_exit
= NULL
;
1052 if (loop
!= bb
->loop_father
)
1053 inner_exit
= single_exit (bb
->loop_father
);
1055 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);)
1057 gphi
*phi
= bsi
.phi ();
1058 if (!virtual_operand_p (gimple_phi_result (phi
))
1059 && !bitmap_bit_p (partition
->stmts
, gimple_uid (phi
)))
1060 remove_phi_node (&bsi
, true);
1065 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);)
1067 gimple
*stmt
= gsi_stmt (bsi
);
1068 if (gimple_code (stmt
) != GIMPLE_LABEL
1069 && !is_gimple_debug (stmt
)
1070 && !bitmap_bit_p (partition
->stmts
, gimple_uid (stmt
)))
1072 /* In distribution of loop nest, if bb is inner loop's exit_bb,
1073 we choose its exit edge/path in order to avoid generating
1074 infinite loop. For all other cases, we choose an arbitrary
1075 path through the empty CFG part that this unnecessary
1076 control stmt controls. */
1077 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
1079 if (inner_exit
&& inner_exit
->flags
& EDGE_TRUE_VALUE
)
1080 gimple_cond_make_true (cond_stmt
);
1082 gimple_cond_make_false (cond_stmt
);
1085 else if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1087 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
1088 gimple_switch_set_index
1089 (switch_stmt
, CASE_LOW (gimple_switch_label (switch_stmt
, 1)));
1094 unlink_stmt_vdef (stmt
);
1095 gsi_remove (&bsi
, true);
1096 release_defs (stmt
);
1107 /* If VAL memory representation contains the same value in all bytes,
1108 return that value, otherwise return -1.
1109 E.g. for 0x24242424 return 0x24, for IEEE double
1110 747708026454360457216.0 return 0x44, etc. */
1113 const_with_all_bytes_same (tree val
)
1115 unsigned char buf
[64];
1118 if (integer_zerop (val
)
1119 || (TREE_CODE (val
) == CONSTRUCTOR
1120 && !TREE_CLOBBER_P (val
)
1121 && CONSTRUCTOR_NELTS (val
) == 0))
1124 if (real_zerop (val
))
1126 /* Only return 0 for +0.0, not for -0.0, which doesn't have
1127 an all bytes same memory representation. Don't transform
1128 -0.0 stores into +0.0 even for !HONOR_SIGNED_ZEROS. */
1129 switch (TREE_CODE (val
))
1132 if (!real_isneg (TREE_REAL_CST_PTR (val
)))
1136 if (!const_with_all_bytes_same (TREE_REALPART (val
))
1137 && !const_with_all_bytes_same (TREE_IMAGPART (val
)))
1142 unsigned int count
= vector_cst_encoded_nelts (val
);
1144 for (j
= 0; j
< count
; ++j
)
1145 if (const_with_all_bytes_same (VECTOR_CST_ENCODED_ELT (val
, j
)))
1156 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
1159 len
= native_encode_expr (val
, buf
, sizeof (buf
));
1162 for (i
= 1; i
< len
; i
++)
1163 if (buf
[i
] != buf
[0])
1168 /* Generate a call to memset for PARTITION in LOOP. */
1171 generate_memset_builtin (class loop
*loop
, partition
*partition
)
1173 gimple_stmt_iterator gsi
;
1174 tree mem
, fn
, nb_bytes
;
1176 struct builtin_info
*builtin
= partition
->builtin
;
1179 /* The new statements will be placed before LOOP. */
1180 gsi
= gsi_last_bb (loop_preheader_edge (loop
)->src
);
1182 nb_bytes
= rewrite_to_non_trapping_overflow (builtin
->size
);
1183 nb_bytes
= force_gimple_operand_gsi (&gsi
, nb_bytes
, true, NULL_TREE
,
1184 false, GSI_CONTINUE_LINKING
);
1185 mem
= rewrite_to_non_trapping_overflow (builtin
->dst_base
);
1186 mem
= force_gimple_operand_gsi (&gsi
, mem
, true, NULL_TREE
,
1187 false, GSI_CONTINUE_LINKING
);
1189 /* This exactly matches the pattern recognition in classify_partition. */
1190 val
= gimple_assign_rhs1 (DR_STMT (builtin
->dst_dr
));
1191 /* Handle constants like 0x15151515 and similarly
1192 floating point constants etc. where all bytes are the same. */
1193 int bytev
= const_with_all_bytes_same (val
);
1195 val
= build_int_cst (integer_type_node
, bytev
);
1196 else if (TREE_CODE (val
) == INTEGER_CST
)
1197 val
= fold_convert (integer_type_node
, val
);
1198 else if (!useless_type_conversion_p (integer_type_node
, TREE_TYPE (val
)))
1200 tree tem
= make_ssa_name (integer_type_node
);
1201 gimple
*cstmt
= gimple_build_assign (tem
, NOP_EXPR
, val
);
1202 gsi_insert_after (&gsi
, cstmt
, GSI_CONTINUE_LINKING
);
1206 fn
= build_fold_addr_expr (builtin_decl_implicit (BUILT_IN_MEMSET
));
1207 fn_call
= gimple_build_call (fn
, 3, mem
, val
, nb_bytes
);
1208 gimple_set_location (fn_call
, partition
->loc
);
1209 gsi_insert_after (&gsi
, fn_call
, GSI_CONTINUE_LINKING
);
1212 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1214 fprintf (dump_file
, "generated memset");
1216 fprintf (dump_file
, " zero\n");
1218 fprintf (dump_file
, "\n");
1222 /* Generate a call to memcpy for PARTITION in LOOP. */
1225 generate_memcpy_builtin (class loop
*loop
, partition
*partition
)
1227 gimple_stmt_iterator gsi
;
1229 tree dest
, src
, fn
, nb_bytes
;
1230 enum built_in_function kind
;
1231 struct builtin_info
*builtin
= partition
->builtin
;
1233 /* The new statements will be placed before LOOP. */
1234 gsi
= gsi_last_bb (loop_preheader_edge (loop
)->src
);
1236 nb_bytes
= rewrite_to_non_trapping_overflow (builtin
->size
);
1237 nb_bytes
= force_gimple_operand_gsi (&gsi
, nb_bytes
, true, NULL_TREE
,
1238 false, GSI_CONTINUE_LINKING
);
1239 dest
= rewrite_to_non_trapping_overflow (builtin
->dst_base
);
1240 src
= rewrite_to_non_trapping_overflow (builtin
->src_base
);
1241 if (partition
->kind
== PKIND_MEMCPY
1242 || ! ptr_derefs_may_alias_p (dest
, src
))
1243 kind
= BUILT_IN_MEMCPY
;
1245 kind
= BUILT_IN_MEMMOVE
;
1246 /* Try harder if we're copying a constant size. */
1247 if (kind
== BUILT_IN_MEMMOVE
&& poly_int_tree_p (nb_bytes
))
1249 aff_tree asrc
, adest
;
1250 tree_to_aff_combination (src
, ptr_type_node
, &asrc
);
1251 tree_to_aff_combination (dest
, ptr_type_node
, &adest
);
1252 aff_combination_scale (&adest
, -1);
1253 aff_combination_add (&asrc
, &adest
);
1254 if (aff_comb_cannot_overlap_p (&asrc
, wi::to_poly_widest (nb_bytes
),
1255 wi::to_poly_widest (nb_bytes
)))
1256 kind
= BUILT_IN_MEMCPY
;
1259 dest
= force_gimple_operand_gsi (&gsi
, dest
, true, NULL_TREE
,
1260 false, GSI_CONTINUE_LINKING
);
1261 src
= force_gimple_operand_gsi (&gsi
, src
, true, NULL_TREE
,
1262 false, GSI_CONTINUE_LINKING
);
1263 fn
= build_fold_addr_expr (builtin_decl_implicit (kind
));
1264 fn_call
= gimple_build_call (fn
, 3, dest
, src
, nb_bytes
);
1265 gimple_set_location (fn_call
, partition
->loc
);
1266 gsi_insert_after (&gsi
, fn_call
, GSI_CONTINUE_LINKING
);
1269 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1271 if (kind
== BUILT_IN_MEMCPY
)
1272 fprintf (dump_file
, "generated memcpy\n");
1274 fprintf (dump_file
, "generated memmove\n");
1278 /* Remove and destroy the loop LOOP. */
1281 destroy_loop (class loop
*loop
)
1283 unsigned nbbs
= loop
->num_nodes
;
1284 edge exit
= single_exit (loop
);
1285 basic_block src
= loop_preheader_edge (loop
)->src
, dest
= exit
->dest
;
1289 bbs
= get_loop_body_in_dom_order (loop
);
1291 gimple_stmt_iterator dst_gsi
= gsi_after_labels (exit
->dest
);
1292 bool safe_p
= single_pred_p (exit
->dest
);
1293 for (unsigned i
= 0; i
< nbbs
; ++i
)
1295 /* We have made sure to not leave any dangling uses of SSA
1296 names defined in the loop. With the exception of virtuals.
1297 Make sure we replace all uses of virtual defs that will remain
1298 outside of the loop with the bare symbol as delete_basic_block
1299 will release them. */
1300 for (gphi_iterator gsi
= gsi_start_phis (bbs
[i
]); !gsi_end_p (gsi
);
1303 gphi
*phi
= gsi
.phi ();
1304 if (virtual_operand_p (gimple_phi_result (phi
)))
1305 mark_virtual_phi_result_for_renaming (phi
);
1307 for (gimple_stmt_iterator gsi
= gsi_start_bb (bbs
[i
]); !gsi_end_p (gsi
);)
1309 gimple
*stmt
= gsi_stmt (gsi
);
1310 tree vdef
= gimple_vdef (stmt
);
1311 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
1312 mark_virtual_operand_for_renaming (vdef
);
1313 /* Also move and eventually reset debug stmts. We can leave
1314 constant values in place in case the stmt dominates the exit.
1315 ??? Non-constant values from the last iteration can be
1316 replaced with final values if we can compute them. */
1317 if (gimple_debug_bind_p (stmt
))
1319 tree val
= gimple_debug_bind_get_value (stmt
);
1320 gsi_move_before (&gsi
, &dst_gsi
);
1323 || !is_gimple_min_invariant (val
)
1324 || !dominated_by_p (CDI_DOMINATORS
, exit
->src
, bbs
[i
])))
1326 gimple_debug_bind_reset_value (stmt
);
1335 redirect_edge_pred (exit
, src
);
1336 exit
->flags
&= ~(EDGE_TRUE_VALUE
|EDGE_FALSE_VALUE
);
1337 exit
->flags
|= EDGE_FALLTHRU
;
1338 cancel_loop_tree (loop
);
1339 rescan_loop_exit (exit
, false, true);
1345 delete_basic_block (bbs
[i
]);
1351 set_immediate_dominator (CDI_DOMINATORS
, dest
,
1352 recompute_dominator (CDI_DOMINATORS
, dest
));
1355 /* Generates code for PARTITION. Return whether LOOP needs to be destroyed. */
1358 generate_code_for_partition (class loop
*loop
,
1359 partition
*partition
, bool copy_p
,
1360 bool keep_lc_phis_p
)
1362 switch (partition
->kind
)
1365 case PKIND_PARTIAL_MEMSET
:
1366 /* Reductions all have to be in the last partition. */
1367 gcc_assert (!partition_reduction_p (partition
)
1369 generate_loops_for_partition (loop
, partition
, copy_p
,
1374 generate_memset_builtin (loop
, partition
);
1379 generate_memcpy_builtin (loop
, partition
);
1386 /* Common tail for partitions we turn into a call. If this was the last
1387 partition for which we generate code, we have to destroy the loop. */
1393 data_dependence_relation
*
1394 loop_distribution::get_data_dependence (struct graph
*rdg
, data_reference_p a
,
1397 struct data_dependence_relation ent
, **slot
;
1398 struct data_dependence_relation
*ddr
;
1400 gcc_assert (DR_IS_WRITE (a
) || DR_IS_WRITE (b
));
1401 gcc_assert (rdg_vertex_for_stmt (rdg
, DR_STMT (a
))
1402 <= rdg_vertex_for_stmt (rdg
, DR_STMT (b
)));
1405 slot
= ddrs_table
->find_slot (&ent
, INSERT
);
1408 ddr
= initialize_data_dependence_relation (a
, b
, loop_nest
);
1409 compute_affine_dependence (ddr
, loop_nest
[0]);
1417 loop_distribution::data_dep_in_cycle_p (struct graph
*rdg
,
1418 data_reference_p dr1
,
1419 data_reference_p dr2
)
1421 struct data_dependence_relation
*ddr
;
1423 /* Re-shuffle data-refs to be in topological order. */
1424 if (rdg_vertex_for_stmt (rdg
, DR_STMT (dr1
))
1425 > rdg_vertex_for_stmt (rdg
, DR_STMT (dr2
)))
1426 std::swap (dr1
, dr2
);
1428 ddr
= get_data_dependence (rdg
, dr1
, dr2
);
1430 /* In case of no data dependence. */
1431 if (DDR_ARE_DEPENDENT (ddr
) == chrec_known
)
1433 /* For unknown data dependence or known data dependence which can't be
1434 expressed in classic distance vector, we check if it can be resolved
1435 by runtime alias check. If yes, we still consider data dependence
1436 as won't introduce data dependence cycle. */
1437 else if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
1438 || DDR_NUM_DIST_VECTS (ddr
) == 0)
1439 return !runtime_alias_check_p (ddr
, NULL
, true);
1440 else if (DDR_NUM_DIST_VECTS (ddr
) > 1)
1442 else if (DDR_REVERSED_P (ddr
)
1443 || lambda_vector_zerop (DDR_DIST_VECT (ddr
, 0), 1))
1450 loop_distribution::update_type_for_merge (struct graph
*rdg
,
1451 partition
*partition1
,
1452 partition
*partition2
)
1455 bitmap_iterator bi
, bj
;
1456 data_reference_p dr1
, dr2
;
1458 EXECUTE_IF_SET_IN_BITMAP (partition1
->datarefs
, 0, i
, bi
)
1460 unsigned start
= (partition1
== partition2
) ? i
+ 1 : 0;
1462 dr1
= datarefs_vec
[i
];
1463 EXECUTE_IF_SET_IN_BITMAP (partition2
->datarefs
, start
, j
, bj
)
1465 dr2
= datarefs_vec
[j
];
1466 if (DR_IS_READ (dr1
) && DR_IS_READ (dr2
))
1469 /* Partition can only be executed sequentially if there is any
1470 data dependence cycle. */
1471 if (data_dep_in_cycle_p (rdg
, dr1
, dr2
))
1473 partition1
->type
= PTYPE_SEQUENTIAL
;
1481 loop_distribution::build_rdg_partition_for_vertex (struct graph
*rdg
, int v
)
1483 partition
*partition
= partition_alloc ();
1484 auto_vec
<int, 3> nodes
;
1487 data_reference_p dr
;
1489 graphds_dfs (rdg
, &v
, 1, &nodes
, false, NULL
);
1491 FOR_EACH_VEC_ELT (nodes
, i
, x
)
1493 bitmap_set_bit (partition
->stmts
, x
);
1495 for (j
= 0; RDG_DATAREFS (rdg
, x
).iterate (j
, &dr
); ++j
)
1497 unsigned idx
= (unsigned) DR_INDEX (dr
);
1498 gcc_assert (idx
< datarefs_vec
.length ());
1500 /* Partition can only be executed sequentially if there is any
1501 unknown data reference. */
1502 if (!DR_BASE_ADDRESS (dr
) || !DR_OFFSET (dr
)
1503 || !DR_INIT (dr
) || !DR_STEP (dr
))
1504 partition
->type
= PTYPE_SEQUENTIAL
;
1506 bitmap_set_bit (partition
->datarefs
, idx
);
1510 if (partition
->type
== PTYPE_SEQUENTIAL
)
1513 /* Further check if any data dependence prevents us from executing the
1514 partition parallelly. */
1515 update_type_for_merge (rdg
, partition
, partition
);
1520 /* Given PARTITION of LOOP and RDG, record single load/store data references
1521 for builtin partition in SRC_DR/DST_DR, return false if there is no such
1525 find_single_drs (class loop
*loop
, struct graph
*rdg
, const bitmap
&partition_stmts
,
1526 data_reference_p
*dst_dr
, data_reference_p
*src_dr
)
1529 data_reference_p single_ld
= NULL
, single_st
= NULL
;
1532 EXECUTE_IF_SET_IN_BITMAP (partition_stmts
, 0, i
, bi
)
1534 gimple
*stmt
= RDG_STMT (rdg
, i
);
1535 data_reference_p dr
;
1537 if (gimple_code (stmt
) == GIMPLE_PHI
)
1540 /* Any scalar stmts are ok. */
1541 if (!gimple_vuse (stmt
))
1544 /* Otherwise just regular loads/stores. */
1545 if (!gimple_assign_single_p (stmt
))
1548 /* But exactly one store and/or load. */
1549 for (unsigned j
= 0; RDG_DATAREFS (rdg
, i
).iterate (j
, &dr
); ++j
)
1551 tree type
= TREE_TYPE (DR_REF (dr
));
1553 /* The memset, memcpy and memmove library calls are only
1554 able to deal with generic address space. */
1555 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type
)))
1558 if (DR_IS_READ (dr
))
1560 if (single_ld
!= NULL
)
1566 if (single_st
!= NULL
)
1573 if (!single_ld
&& !single_st
)
1576 basic_block bb_ld
= NULL
;
1577 basic_block bb_st
= NULL
;
1578 edge exit
= single_exit (loop
);
1582 /* Bail out if this is a bitfield memory reference. */
1583 if (TREE_CODE (DR_REF (single_ld
)) == COMPONENT_REF
1584 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (single_ld
), 1)))
1587 /* Data reference must be executed exactly once per iteration of each
1588 loop in the loop nest. We only need to check dominance information
1589 against the outermost one in a perfect loop nest because a bb can't
1590 dominate outermost loop's latch without dominating inner loop's. */
1591 bb_ld
= gimple_bb (DR_STMT (single_ld
));
1592 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, bb_ld
))
1595 /* The data reference must also be executed before possibly exiting
1596 the loop as otherwise we'd for example unconditionally execute
1597 memset (ptr, 0, n) which even with n == 0 implies ptr is non-NULL. */
1598 if (bb_ld
!= loop
->header
1600 || !dominated_by_p (CDI_DOMINATORS
, exit
->src
, bb_ld
)))
1606 /* Bail out if this is a bitfield memory reference. */
1607 if (TREE_CODE (DR_REF (single_st
)) == COMPONENT_REF
1608 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (single_st
), 1)))
1611 /* Data reference must be executed exactly once per iteration.
1612 Same as single_ld, we only need to check against the outermost
1614 bb_st
= gimple_bb (DR_STMT (single_st
));
1615 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, bb_st
))
1618 /* And before exiting the loop. */
1619 if (bb_st
!= loop
->header
1621 || !dominated_by_p (CDI_DOMINATORS
, exit
->src
, bb_st
)))
1625 if (single_ld
&& single_st
)
1627 /* Load and store must be in the same loop nest. */
1628 if (bb_st
->loop_father
!= bb_ld
->loop_father
)
1631 edge e
= single_exit (bb_st
->loop_father
);
1632 bool dom_ld
= dominated_by_p (CDI_DOMINATORS
, e
->src
, bb_ld
);
1633 bool dom_st
= dominated_by_p (CDI_DOMINATORS
, e
->src
, bb_st
);
1634 if (dom_ld
!= dom_st
)
1638 *src_dr
= single_ld
;
1639 *dst_dr
= single_st
;
1643 /* Given data reference DR in LOOP_NEST, this function checks the enclosing
1644 loops from inner to outer to see if loop's step equals to access size at
1645 each level of loop. Return 2 if we can prove this at all level loops;
1646 record access base and size in BASE and SIZE; save loop's step at each
1647 level of loop in STEPS if it is not null. For example:
1649 int arr[100][100][100];
1650 for (i = 0; i < 100; i++) ;steps[2] = 40000
1651 for (j = 100; j > 0; j--) ;steps[1] = -400
1652 for (k = 0; k < 100; k++) ;steps[0] = 4
1653 arr[i][j - 1][k] = 0; ;base = &arr, size = 4000000
1655 Return 1 if we can prove the equality at the innermost loop, but not all
1656 level loops. In this case, no information is recorded.
1658 Return 0 if no equality can be proven at any level loops. */
1661 compute_access_range (loop_p loop_nest
, data_reference_p dr
, tree
*base
,
1662 tree
*size
, vec
<tree
> *steps
= NULL
)
1664 location_t loc
= gimple_location (DR_STMT (dr
));
1665 basic_block bb
= gimple_bb (DR_STMT (dr
));
1666 class loop
*loop
= bb
->loop_father
;
1667 tree ref
= DR_REF (dr
);
1668 tree access_base
= build_fold_addr_expr (ref
);
1669 tree access_size
= TYPE_SIZE_UNIT (TREE_TYPE (ref
));
1673 tree scev_fn
= analyze_scalar_evolution (loop
, access_base
);
1674 if (TREE_CODE (scev_fn
) != POLYNOMIAL_CHREC
)
1677 access_base
= CHREC_LEFT (scev_fn
);
1678 if (tree_contains_chrecs (access_base
, NULL
))
1681 tree scev_step
= CHREC_RIGHT (scev_fn
);
1682 /* Only support constant steps. */
1683 if (TREE_CODE (scev_step
) != INTEGER_CST
)
1686 enum ev_direction access_dir
= scev_direction (scev_fn
);
1687 if (access_dir
== EV_DIR_UNKNOWN
)
1691 steps
->safe_push (scev_step
);
1693 scev_step
= fold_convert_loc (loc
, sizetype
, scev_step
);
1694 /* Compute absolute value of scev step. */
1695 if (access_dir
== EV_DIR_DECREASES
)
1696 scev_step
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, scev_step
);
1698 /* At each level of loop, scev step must equal to access size. In other
1699 words, DR must access consecutive memory between loop iterations. */
1700 if (!operand_equal_p (scev_step
, access_size
, 0))
1703 /* Access stride can be computed for data reference at least for the
1707 /* Compute DR's execution times in loop. */
1708 tree niters
= number_of_latch_executions (loop
);
1709 niters
= fold_convert_loc (loc
, sizetype
, niters
);
1710 if (dominated_by_p (CDI_DOMINATORS
, single_exit (loop
)->src
, bb
))
1711 niters
= size_binop_loc (loc
, PLUS_EXPR
, niters
, size_one_node
);
1713 /* Compute DR's overall access size in loop. */
1714 access_size
= fold_build2_loc (loc
, MULT_EXPR
, sizetype
,
1716 /* Adjust base address in case of negative step. */
1717 if (access_dir
== EV_DIR_DECREASES
)
1719 tree adj
= fold_build2_loc (loc
, MINUS_EXPR
, sizetype
,
1720 scev_step
, access_size
);
1721 access_base
= fold_build_pointer_plus_loc (loc
, access_base
, adj
);
1723 } while (loop
!= loop_nest
&& (loop
= loop_outer (loop
)) != NULL
);
1725 *base
= access_base
;
1726 *size
= access_size
;
1727 /* Access stride can be computed for data reference at each level loop. */
1731 /* Allocate and return builtin struct. Record information like DST_DR,
1732 SRC_DR, DST_BASE, SRC_BASE and SIZE in the allocated struct. */
1734 static struct builtin_info
*
1735 alloc_builtin (data_reference_p dst_dr
, data_reference_p src_dr
,
1736 tree dst_base
, tree src_base
, tree size
)
1738 struct builtin_info
*builtin
= XNEW (struct builtin_info
);
1739 builtin
->dst_dr
= dst_dr
;
1740 builtin
->src_dr
= src_dr
;
1741 builtin
->dst_base
= dst_base
;
1742 builtin
->src_base
= src_base
;
1743 builtin
->size
= size
;
1747 /* Given data reference DR in loop nest LOOP, classify if it forms builtin
1751 classify_builtin_st (loop_p loop
, partition
*partition
, data_reference_p dr
)
1753 gimple
*stmt
= DR_STMT (dr
);
1754 tree base
, size
, rhs
= gimple_assign_rhs1 (stmt
);
1756 if (const_with_all_bytes_same (rhs
) == -1
1757 && (!INTEGRAL_TYPE_P (TREE_TYPE (rhs
))
1758 || (TYPE_MODE (TREE_TYPE (rhs
))
1759 != TYPE_MODE (unsigned_char_type_node
))))
1762 if (TREE_CODE (rhs
) == SSA_NAME
1763 && !SSA_NAME_IS_DEFAULT_DEF (rhs
)
1764 && flow_bb_inside_loop_p (loop
, gimple_bb (SSA_NAME_DEF_STMT (rhs
))))
1767 int res
= compute_access_range (loop
, dr
, &base
, &size
);
1772 partition
->kind
= PKIND_PARTIAL_MEMSET
;
1778 split_constant_offset (base
, &base_base
, &base_offset
);
1779 if (!cst_and_fits_in_hwi (base_offset
))
1781 unsigned HOST_WIDE_INT const_base_offset
= int_cst_value (base_offset
);
1783 struct builtin_info
*builtin
;
1784 builtin
= alloc_builtin (dr
, NULL
, base
, NULL_TREE
, size
);
1785 builtin
->dst_base_base
= base_base
;
1786 builtin
->dst_base_offset
= const_base_offset
;
1787 partition
->builtin
= builtin
;
1788 partition
->kind
= PKIND_MEMSET
;
1791 /* Given data references DST_DR and SRC_DR in loop nest LOOP and RDG, classify
1792 if it forms builtin memcpy or memmove call. */
1795 loop_distribution::classify_builtin_ldst (loop_p loop
, struct graph
*rdg
,
1796 partition
*partition
,
1797 data_reference_p dst_dr
,
1798 data_reference_p src_dr
)
1800 tree base
, size
, src_base
, src_size
;
1801 auto_vec
<tree
> dst_steps
, src_steps
;
1803 /* Compute access range of both load and store. */
1804 int res
= compute_access_range (loop
, dst_dr
, &base
, &size
, &dst_steps
);
1807 res
= compute_access_range (loop
, src_dr
, &src_base
, &src_size
, &src_steps
);
1811 /* They must have the same access size. */
1812 if (!operand_equal_p (size
, src_size
, 0))
1815 /* They must have the same storage order. */
1816 if (reverse_storage_order_for_component_p (DR_REF (dst_dr
))
1817 != reverse_storage_order_for_component_p (DR_REF (src_dr
)))
1820 /* Load and store in loop nest must access memory in the same way, i.e,
1821 their must have the same steps in each loop of the nest. */
1822 if (dst_steps
.length () != src_steps
.length ())
1824 for (unsigned i
= 0; i
< dst_steps
.length (); ++i
)
1825 if (!operand_equal_p (dst_steps
[i
], src_steps
[i
], 0))
1828 /* Now check that if there is a dependence. */
1829 ddr_p ddr
= get_data_dependence (rdg
, src_dr
, dst_dr
);
1831 /* Classify as memmove if no dependence between load and store. */
1832 if (DDR_ARE_DEPENDENT (ddr
) == chrec_known
)
1834 partition
->builtin
= alloc_builtin (dst_dr
, src_dr
, base
, src_base
, size
);
1835 partition
->kind
= PKIND_MEMMOVE
;
1839 /* Can't do memmove in case of unknown dependence or dependence without
1840 classical distance vector. */
1841 if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
1842 || DDR_NUM_DIST_VECTS (ddr
) == 0)
1846 lambda_vector dist_v
;
1847 int num_lev
= (DDR_LOOP_NEST (ddr
)).length ();
1848 FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr
), i
, dist_v
)
1850 unsigned dep_lev
= dependence_level (dist_v
, num_lev
);
1851 /* Can't do memmove if load depends on store. */
1852 if (dep_lev
> 0 && dist_v
[dep_lev
- 1] > 0 && !DDR_REVERSED_P (ddr
))
1856 partition
->builtin
= alloc_builtin (dst_dr
, src_dr
, base
, src_base
, size
);
1857 partition
->kind
= PKIND_MEMMOVE
;
1862 loop_distribution::classify_partition (loop_p loop
,
1863 struct graph
*rdg
, partition
*partition
,
1864 bitmap stmt_in_all_partitions
)
1868 data_reference_p single_ld
= NULL
, single_st
= NULL
;
1869 bool volatiles_p
= false, has_reduction
= false;
1871 EXECUTE_IF_SET_IN_BITMAP (partition
->stmts
, 0, i
, bi
)
1873 gimple
*stmt
= RDG_STMT (rdg
, i
);
1875 if (gimple_has_volatile_ops (stmt
))
1878 /* If the stmt is not included by all partitions and there is uses
1879 outside of the loop, then mark the partition as reduction. */
1880 if (stmt_has_scalar_dependences_outside_loop (loop
, stmt
))
1882 /* Due to limitation in the transform phase we have to fuse all
1883 reduction partitions. As a result, this could cancel valid
1884 loop distribution especially for loop that induction variable
1885 is used outside of loop. To workaround this issue, we skip
1886 marking partition as reudction if the reduction stmt belongs
1887 to all partitions. In such case, reduction will be computed
1888 correctly no matter how partitions are fused/distributed. */
1889 if (!bitmap_bit_p (stmt_in_all_partitions
, i
))
1890 partition
->reduction_p
= true;
1892 has_reduction
= true;
1896 /* Simple workaround to prevent classifying the partition as builtin
1897 if it contains any use outside of loop. For the case where all
1898 partitions have the reduction this simple workaround is delayed
1899 to only affect the last partition. */
1900 if (partition
->reduction_p
)
1901 return has_reduction
;
1903 /* Perform general partition disqualification for builtins. */
1905 || !flag_tree_loop_distribute_patterns
)
1906 return has_reduction
;
1908 /* Find single load/store data references for builtin partition. */
1909 if (!find_single_drs (loop
, rdg
, partition
->stmts
, &single_st
, &single_ld
)
1911 return has_reduction
;
1913 if (single_ld
&& single_st
)
1915 gimple
*store
= DR_STMT (single_st
), *load
= DR_STMT (single_ld
);
1916 /* Direct aggregate copy or via an SSA name temporary. */
1918 && gimple_assign_lhs (load
) != gimple_assign_rhs1 (store
))
1919 return has_reduction
;
1922 partition
->loc
= gimple_location (DR_STMT (single_st
));
1924 /* Classify the builtin kind. */
1925 if (single_ld
== NULL
)
1926 classify_builtin_st (loop
, partition
, single_st
);
1928 classify_builtin_ldst (loop
, rdg
, partition
, single_st
, single_ld
);
1929 return has_reduction
;
1933 loop_distribution::share_memory_accesses (struct graph
*rdg
,
1934 partition
*partition1
, partition
*partition2
)
1937 bitmap_iterator bi
, bj
;
1938 data_reference_p dr1
, dr2
;
1940 /* First check whether in the intersection of the two partitions are
1941 any loads or stores. Common loads are the situation that happens
1943 EXECUTE_IF_AND_IN_BITMAP (partition1
->stmts
, partition2
->stmts
, 0, i
, bi
)
1944 if (RDG_MEM_WRITE_STMT (rdg
, i
)
1945 || RDG_MEM_READS_STMT (rdg
, i
))
1948 /* Then check whether the two partitions access the same memory object. */
1949 EXECUTE_IF_SET_IN_BITMAP (partition1
->datarefs
, 0, i
, bi
)
1951 dr1
= datarefs_vec
[i
];
1953 if (!DR_BASE_ADDRESS (dr1
)
1954 || !DR_OFFSET (dr1
) || !DR_INIT (dr1
) || !DR_STEP (dr1
))
1957 EXECUTE_IF_SET_IN_BITMAP (partition2
->datarefs
, 0, j
, bj
)
1959 dr2
= datarefs_vec
[j
];
1961 if (!DR_BASE_ADDRESS (dr2
)
1962 || !DR_OFFSET (dr2
) || !DR_INIT (dr2
) || !DR_STEP (dr2
))
1965 if (operand_equal_p (DR_BASE_ADDRESS (dr1
), DR_BASE_ADDRESS (dr2
), 0)
1966 && operand_equal_p (DR_OFFSET (dr1
), DR_OFFSET (dr2
), 0)
1967 && operand_equal_p (DR_INIT (dr1
), DR_INIT (dr2
), 0)
1968 && operand_equal_p (DR_STEP (dr1
), DR_STEP (dr2
), 0))
1976 /* For each seed statement in STARTING_STMTS, this function builds
1977 partition for it by adding depended statements according to RDG.
1978 All partitions are recorded in PARTITIONS. */
1981 loop_distribution::rdg_build_partitions (struct graph
*rdg
,
1982 vec
<gimple
*> starting_stmts
,
1983 vec
<partition
*> *partitions
)
1985 auto_bitmap processed
;
1989 FOR_EACH_VEC_ELT (starting_stmts
, i
, stmt
)
1991 int v
= rdg_vertex_for_stmt (rdg
, stmt
);
1993 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1995 "ldist asked to generate code for vertex %d\n", v
);
1997 /* If the vertex is already contained in another partition so
1998 is the partition rooted at it. */
1999 if (bitmap_bit_p (processed
, v
))
2002 partition
*partition
= build_rdg_partition_for_vertex (rdg
, v
);
2003 bitmap_ior_into (processed
, partition
->stmts
);
2005 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2007 fprintf (dump_file
, "ldist creates useful %s partition:\n",
2008 partition
->type
== PTYPE_PARALLEL
? "parallel" : "sequent");
2009 bitmap_print (dump_file
, partition
->stmts
, " ", "\n");
2012 partitions
->safe_push (partition
);
2015 /* All vertices should have been assigned to at least one partition now,
2016 other than vertices belonging to dead code. */
2019 /* Dump to FILE the PARTITIONS. */
2022 dump_rdg_partitions (FILE *file
, const vec
<partition
*> &partitions
)
2025 partition
*partition
;
2027 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
2028 debug_bitmap_file (file
, partition
->stmts
);
2031 /* Debug PARTITIONS. */
2032 extern void debug_rdg_partitions (const vec
<partition
*> &);
2035 debug_rdg_partitions (const vec
<partition
*> &partitions
)
2037 dump_rdg_partitions (stderr
, partitions
);
2040 /* Returns the number of read and write operations in the RDG. */
2043 number_of_rw_in_rdg (struct graph
*rdg
)
2047 for (i
= 0; i
< rdg
->n_vertices
; i
++)
2049 if (RDG_MEM_WRITE_STMT (rdg
, i
))
2052 if (RDG_MEM_READS_STMT (rdg
, i
))
2059 /* Returns the number of read and write operations in a PARTITION of
2063 number_of_rw_in_partition (struct graph
*rdg
, partition
*partition
)
2069 EXECUTE_IF_SET_IN_BITMAP (partition
->stmts
, 0, i
, ii
)
2071 if (RDG_MEM_WRITE_STMT (rdg
, i
))
2074 if (RDG_MEM_READS_STMT (rdg
, i
))
2081 /* Returns true when one of the PARTITIONS contains all the read or
2082 write operations of RDG. */
2085 partition_contains_all_rw (struct graph
*rdg
,
2086 const vec
<partition
*> &partitions
)
2089 partition
*partition
;
2090 int nrw
= number_of_rw_in_rdg (rdg
);
2092 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
2093 if (nrw
== number_of_rw_in_partition (rdg
, partition
))
2100 loop_distribution::pg_add_dependence_edges (struct graph
*rdg
, int dir
,
2101 bitmap drs1
, bitmap drs2
, vec
<ddr_p
> *alias_ddrs
)
2104 bitmap_iterator bi
, bj
;
2105 data_reference_p dr1
, dr2
, saved_dr1
;
2107 /* dependence direction - 0 is no dependence, -1 is back,
2108 1 is forth, 2 is both (we can stop then, merging will occur). */
2109 EXECUTE_IF_SET_IN_BITMAP (drs1
, 0, i
, bi
)
2111 dr1
= datarefs_vec
[i
];
2113 EXECUTE_IF_SET_IN_BITMAP (drs2
, 0, j
, bj
)
2115 int res
, this_dir
= 1;
2118 dr2
= datarefs_vec
[j
];
2120 /* Skip all <read, read> data dependence. */
2121 if (DR_IS_READ (dr1
) && DR_IS_READ (dr2
))
2125 /* Re-shuffle data-refs to be in topological order. */
2126 if (rdg_vertex_for_stmt (rdg
, DR_STMT (dr1
))
2127 > rdg_vertex_for_stmt (rdg
, DR_STMT (dr2
)))
2129 std::swap (dr1
, dr2
);
2130 this_dir
= -this_dir
;
2132 ddr
= get_data_dependence (rdg
, dr1
, dr2
);
2133 if (DDR_ARE_DEPENDENT (ddr
) == chrec_dont_know
)
2136 res
= data_ref_compare_tree (DR_BASE_ADDRESS (dr1
),
2137 DR_BASE_ADDRESS (dr2
));
2138 /* Be conservative. If data references are not well analyzed,
2139 or the two data references have the same base address and
2140 offset, add dependence and consider it alias to each other.
2141 In other words, the dependence cannot be resolved by
2142 runtime alias check. */
2143 if (!DR_BASE_ADDRESS (dr1
) || !DR_BASE_ADDRESS (dr2
)
2144 || !DR_OFFSET (dr1
) || !DR_OFFSET (dr2
)
2145 || !DR_INIT (dr1
) || !DR_INIT (dr2
)
2146 || !DR_STEP (dr1
) || !tree_fits_uhwi_p (DR_STEP (dr1
))
2147 || !DR_STEP (dr2
) || !tree_fits_uhwi_p (DR_STEP (dr2
))
2150 /* Data dependence could be resolved by runtime alias check,
2151 record it in ALIAS_DDRS. */
2152 else if (alias_ddrs
!= NULL
)
2153 alias_ddrs
->safe_push (ddr
);
2154 /* Or simply ignore it. */
2156 else if (DDR_ARE_DEPENDENT (ddr
) == NULL_TREE
)
2158 if (DDR_REVERSED_P (ddr
))
2159 this_dir
= -this_dir
;
2161 /* Known dependences can still be unordered througout the
2162 iteration space, see gcc.dg/tree-ssa/ldist-16.c and
2163 gcc.dg/tree-ssa/pr94969.c. */
2164 if (DDR_NUM_DIST_VECTS (ddr
) != 1)
2166 /* If the dependence distance is zero in the innermost
2167 loop preserve stmt order. */
2168 else if (DDR_DIST_VECT (ddr
, 0)
2169 [DDR_LOOP_NEST (ddr
).length () - 1] == 0)
2171 /* Else as the distance vector is lexicographic positive swap
2172 the dependence direction. */
2174 this_dir
= -this_dir
;
2182 else if (this_dir
!= 0 && dir
!= this_dir
)
2184 /* Shuffle "back" dr1. */
2191 /* Compare postorder number of the partition graph vertices V1 and V2. */
2194 pgcmp (const void *v1_
, const void *v2_
)
2196 const vertex
*v1
= (const vertex
*)v1_
;
2197 const vertex
*v2
= (const vertex
*)v2_
;
2198 return v2
->post
- v1
->post
;
2201 /* Data attached to vertices of partition dependence graph. */
2204 /* ID of the corresponding partition. */
2206 /* The partition. */
2207 struct partition
*partition
;
2210 /* Data attached to edges of partition dependence graph. */
2213 /* If the dependence edge can be resolved by runtime alias check,
2214 this vector contains data dependence relations for runtime alias
2215 check. On the other hand, if the dependence edge is introduced
2216 because of compilation time known data dependence, this vector
2217 contains nothing. */
2218 vec
<ddr_p
> alias_ddrs
;
2221 /* Callback data for traversing edges in graph. */
2222 struct pg_edge_callback_data
2224 /* Bitmap contains strong connected components should be merged. */
2225 bitmap sccs_to_merge
;
2226 /* Array constains component information for all vertices. */
2227 int *vertices_component
;
2228 /* Vector to record all data dependence relations which are needed
2229 to break strong connected components by runtime alias checks. */
2230 vec
<ddr_p
> *alias_ddrs
;
2233 /* Initialize vertice's data for partition dependence graph PG with
2237 init_partition_graph_vertices (struct graph
*pg
,
2238 vec
<struct partition
*> *partitions
)
2241 partition
*partition
;
2242 struct pg_vdata
*data
;
2244 for (i
= 0; partitions
->iterate (i
, &partition
); ++i
)
2246 data
= new pg_vdata
;
2247 pg
->vertices
[i
].data
= data
;
2249 data
->partition
= partition
;
2253 /* Add edge <I, J> to partition dependence graph PG. Attach vector of data
2254 dependence relations to the EDGE if DDRS isn't NULL. */
2257 add_partition_graph_edge (struct graph
*pg
, int i
, int j
, vec
<ddr_p
> *ddrs
)
2259 struct graph_edge
*e
= add_edge (pg
, i
, j
);
2261 /* If the edge is attached with data dependence relations, it means this
2262 dependence edge can be resolved by runtime alias checks. */
2265 struct pg_edata
*data
= new pg_edata
;
2267 gcc_assert (ddrs
->length () > 0);
2269 data
->alias_ddrs
= vNULL
;
2270 data
->alias_ddrs
.safe_splice (*ddrs
);
2274 /* Callback function for graph travesal algorithm. It returns true
2275 if edge E should skipped when traversing the graph. */
2278 pg_skip_alias_edge (struct graph_edge
*e
)
2280 struct pg_edata
*data
= (struct pg_edata
*)e
->data
;
2281 return (data
!= NULL
&& data
->alias_ddrs
.length () > 0);
2284 /* Callback function freeing data attached to edge E of graph. */
2287 free_partition_graph_edata_cb (struct graph
*, struct graph_edge
*e
, void *)
2289 if (e
->data
!= NULL
)
2291 struct pg_edata
*data
= (struct pg_edata
*)e
->data
;
2292 data
->alias_ddrs
.release ();
2297 /* Free data attached to vertice of partition dependence graph PG. */
2300 free_partition_graph_vdata (struct graph
*pg
)
2303 struct pg_vdata
*data
;
2305 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2307 data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2312 /* Build and return partition dependence graph for PARTITIONS. RDG is
2313 reduced dependence graph for the loop to be distributed. If IGNORE_ALIAS_P
2314 is true, data dependence caused by possible alias between references
2315 is ignored, as if it doesn't exist at all; otherwise all depdendences
2319 loop_distribution::build_partition_graph (struct graph
*rdg
,
2320 vec
<struct partition
*> *partitions
,
2321 bool ignore_alias_p
)
2324 struct partition
*partition1
, *partition2
;
2325 graph
*pg
= new_graph (partitions
->length ());
2326 auto_vec
<ddr_p
> alias_ddrs
, *alias_ddrs_p
;
2328 alias_ddrs_p
= ignore_alias_p
? NULL
: &alias_ddrs
;
2330 init_partition_graph_vertices (pg
, partitions
);
2332 for (i
= 0; partitions
->iterate (i
, &partition1
); ++i
)
2334 for (j
= i
+ 1; partitions
->iterate (j
, &partition2
); ++j
)
2336 /* dependence direction - 0 is no dependence, -1 is back,
2337 1 is forth, 2 is both (we can stop then, merging will occur). */
2340 /* If the first partition has reduction, add back edge; if the
2341 second partition has reduction, add forth edge. This makes
2342 sure that reduction partition will be sorted as the last one. */
2343 if (partition_reduction_p (partition1
))
2345 else if (partition_reduction_p (partition2
))
2348 /* Cleanup the temporary vector. */
2349 alias_ddrs
.truncate (0);
2351 dir
= pg_add_dependence_edges (rdg
, dir
, partition1
->datarefs
,
2352 partition2
->datarefs
, alias_ddrs_p
);
2354 /* Add edge to partition graph if there exists dependence. There
2355 are two types of edges. One type edge is caused by compilation
2356 time known dependence, this type cannot be resolved by runtime
2357 alias check. The other type can be resolved by runtime alias
2359 if (dir
== 1 || dir
== 2
2360 || alias_ddrs
.length () > 0)
2362 /* Attach data dependence relations to edge that can be resolved
2363 by runtime alias check. */
2364 bool alias_edge_p
= (dir
!= 1 && dir
!= 2);
2365 add_partition_graph_edge (pg
, i
, j
,
2366 (alias_edge_p
) ? &alias_ddrs
: NULL
);
2368 if (dir
== -1 || dir
== 2
2369 || alias_ddrs
.length () > 0)
2371 /* Attach data dependence relations to edge that can be resolved
2372 by runtime alias check. */
2373 bool alias_edge_p
= (dir
!= -1 && dir
!= 2);
2374 add_partition_graph_edge (pg
, j
, i
,
2375 (alias_edge_p
) ? &alias_ddrs
: NULL
);
2382 /* Sort partitions in PG in descending post order and store them in
2386 sort_partitions_by_post_order (struct graph
*pg
,
2387 vec
<struct partition
*> *partitions
)
2390 struct pg_vdata
*data
;
2392 /* Now order the remaining nodes in descending postorder. */
2393 qsort (pg
->vertices
, pg
->n_vertices
, sizeof (vertex
), pgcmp
);
2394 partitions
->truncate (0);
2395 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2397 data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2398 if (data
->partition
)
2399 partitions
->safe_push (data
->partition
);
2404 loop_distribution::merge_dep_scc_partitions (struct graph
*rdg
,
2405 vec
<struct partition
*> *partitions
,
2406 bool ignore_alias_p
)
2408 struct partition
*partition1
, *partition2
;
2409 struct pg_vdata
*data
;
2410 graph
*pg
= build_partition_graph (rdg
, partitions
, ignore_alias_p
);
2411 int i
, j
, num_sccs
= graphds_scc (pg
, NULL
);
2413 /* Strong connected compoenent means dependence cycle, we cannot distribute
2414 them. So fuse them together. */
2415 if ((unsigned) num_sccs
< partitions
->length ())
2417 for (i
= 0; i
< num_sccs
; ++i
)
2419 for (j
= 0; partitions
->iterate (j
, &partition1
); ++j
)
2420 if (pg
->vertices
[j
].component
== i
)
2422 for (j
= j
+ 1; partitions
->iterate (j
, &partition2
); ++j
)
2423 if (pg
->vertices
[j
].component
== i
)
2425 partition_merge_into (NULL
, partition1
,
2426 partition2
, FUSE_SAME_SCC
);
2427 partition1
->type
= PTYPE_SEQUENTIAL
;
2428 (*partitions
)[j
] = NULL
;
2429 partition_free (partition2
);
2430 data
= (struct pg_vdata
*)pg
->vertices
[j
].data
;
2431 data
->partition
= NULL
;
2436 sort_partitions_by_post_order (pg
, partitions
);
2437 gcc_assert (partitions
->length () == (unsigned)num_sccs
);
2438 free_partition_graph_vdata (pg
);
2439 for_each_edge (pg
, free_partition_graph_edata_cb
, NULL
);
2443 /* Callback function for traversing edge E in graph G. DATA is private
2447 pg_collect_alias_ddrs (struct graph
*g
, struct graph_edge
*e
, void *data
)
2449 int i
, j
, component
;
2450 struct pg_edge_callback_data
*cbdata
;
2451 struct pg_edata
*edata
= (struct pg_edata
*) e
->data
;
2453 /* If the edge doesn't have attached data dependence, it represents
2454 compilation time known dependences. This type dependence cannot
2455 be resolved by runtime alias check. */
2456 if (edata
== NULL
|| edata
->alias_ddrs
.length () == 0)
2459 cbdata
= (struct pg_edge_callback_data
*) data
;
2462 component
= cbdata
->vertices_component
[i
];
2463 /* Vertices are topologically sorted according to compilation time
2464 known dependences, so we can break strong connected components
2465 by removing edges of the opposite direction, i.e, edges pointing
2466 from vertice with smaller post number to vertice with bigger post
2468 if (g
->vertices
[i
].post
< g
->vertices
[j
].post
2469 /* We only need to remove edges connecting vertices in the same
2470 strong connected component to break it. */
2471 && component
== cbdata
->vertices_component
[j
]
2472 /* Check if we want to break the strong connected component or not. */
2473 && !bitmap_bit_p (cbdata
->sccs_to_merge
, component
))
2474 cbdata
->alias_ddrs
->safe_splice (edata
->alias_ddrs
);
2477 /* Callback function for traversing edge E. DATA is private
2481 pg_unmark_merged_alias_ddrs (struct graph
*, struct graph_edge
*e
, void *data
)
2483 int i
, j
, component
;
2484 struct pg_edge_callback_data
*cbdata
;
2485 struct pg_edata
*edata
= (struct pg_edata
*) e
->data
;
2487 if (edata
== NULL
|| edata
->alias_ddrs
.length () == 0)
2490 cbdata
= (struct pg_edge_callback_data
*) data
;
2493 component
= cbdata
->vertices_component
[i
];
2494 /* Make sure to not skip vertices inside SCCs we are going to merge. */
2495 if (component
== cbdata
->vertices_component
[j
]
2496 && bitmap_bit_p (cbdata
->sccs_to_merge
, component
))
2498 edata
->alias_ddrs
.release ();
2504 /* This is the main function breaking strong conected components in
2505 PARTITIONS giving reduced depdendence graph RDG. Store data dependence
2506 relations for runtime alias check in ALIAS_DDRS. */
2508 loop_distribution::break_alias_scc_partitions (struct graph
*rdg
,
2509 vec
<struct partition
*> *partitions
,
2510 vec
<ddr_p
> *alias_ddrs
)
2512 int i
, j
, k
, num_sccs
, num_sccs_no_alias
= 0;
2513 /* Build partition dependence graph. */
2514 graph
*pg
= build_partition_graph (rdg
, partitions
, false);
2516 alias_ddrs
->truncate (0);
2517 /* Find strong connected components in the graph, with all dependence edges
2519 num_sccs
= graphds_scc (pg
, NULL
);
2520 /* All SCCs now can be broken by runtime alias checks because SCCs caused by
2521 compilation time known dependences are merged before this function. */
2522 if ((unsigned) num_sccs
< partitions
->length ())
2524 struct pg_edge_callback_data cbdata
;
2525 auto_bitmap sccs_to_merge
;
2526 auto_vec
<enum partition_type
> scc_types
;
2527 struct partition
*partition
, *first
;
2529 /* If all partitions in a SCC have the same type, we can simply merge the
2530 SCC. This loop finds out such SCCS and record them in bitmap. */
2531 bitmap_set_range (sccs_to_merge
, 0, (unsigned) num_sccs
);
2532 for (i
= 0; i
< num_sccs
; ++i
)
2534 for (j
= 0; partitions
->iterate (j
, &first
); ++j
)
2535 if (pg
->vertices
[j
].component
== i
)
2538 bool same_type
= true, all_builtins
= partition_builtin_p (first
);
2539 for (++j
; partitions
->iterate (j
, &partition
); ++j
)
2541 if (pg
->vertices
[j
].component
!= i
)
2544 if (first
->type
!= partition
->type
)
2549 all_builtins
&= partition_builtin_p (partition
);
2551 /* Merge SCC if all partitions in SCC have the same type, though the
2552 result partition is sequential, because vectorizer can do better
2553 runtime alias check. One expecption is all partitions in SCC are
2555 if (!same_type
|| all_builtins
)
2556 bitmap_clear_bit (sccs_to_merge
, i
);
2559 /* Initialize callback data for traversing. */
2560 cbdata
.sccs_to_merge
= sccs_to_merge
;
2561 cbdata
.alias_ddrs
= alias_ddrs
;
2562 cbdata
.vertices_component
= XNEWVEC (int, pg
->n_vertices
);
2563 /* Record the component information which will be corrupted by next
2564 graph scc finding call. */
2565 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2566 cbdata
.vertices_component
[i
] = pg
->vertices
[i
].component
;
2568 /* Collect data dependences for runtime alias checks to break SCCs. */
2569 if (bitmap_count_bits (sccs_to_merge
) != (unsigned) num_sccs
)
2571 /* For SCCs we want to merge clear all alias_ddrs for edges
2572 inside the component. */
2573 for_each_edge (pg
, pg_unmark_merged_alias_ddrs
, &cbdata
);
2575 /* Run SCC finding algorithm again, with alias dependence edges
2576 skipped. This is to topologically sort partitions according to
2577 compilation time known dependence. Note the topological order
2578 is stored in the form of pg's post order number. */
2579 num_sccs_no_alias
= graphds_scc (pg
, NULL
, pg_skip_alias_edge
);
2580 /* We cannot assert partitions->length () == num_sccs_no_alias
2581 since we are not ignoring alias edges in cycles we are
2582 going to merge. That's required to compute correct postorder. */
2583 /* With topological order, we can construct two subgraphs L and R.
2584 L contains edge <x, y> where x < y in terms of post order, while
2585 R contains edge <x, y> where x > y. Edges for compilation time
2586 known dependence all fall in R, so we break SCCs by removing all
2587 (alias) edges of in subgraph L. */
2588 for_each_edge (pg
, pg_collect_alias_ddrs
, &cbdata
);
2591 /* For SCC that doesn't need to be broken, merge it. */
2592 for (i
= 0; i
< num_sccs
; ++i
)
2594 if (!bitmap_bit_p (sccs_to_merge
, i
))
2597 for (j
= 0; partitions
->iterate (j
, &first
); ++j
)
2598 if (cbdata
.vertices_component
[j
] == i
)
2600 for (k
= j
+ 1; partitions
->iterate (k
, &partition
); ++k
)
2602 struct pg_vdata
*data
;
2604 if (cbdata
.vertices_component
[k
] != i
)
2607 partition_merge_into (NULL
, first
, partition
, FUSE_SAME_SCC
);
2608 (*partitions
)[k
] = NULL
;
2609 partition_free (partition
);
2610 data
= (struct pg_vdata
*)pg
->vertices
[k
].data
;
2611 gcc_assert (data
->id
== k
);
2612 data
->partition
= NULL
;
2613 /* The result partition of merged SCC must be sequential. */
2614 first
->type
= PTYPE_SEQUENTIAL
;
2617 /* If reduction partition's SCC is broken by runtime alias checks,
2618 we force a negative post order to it making sure it will be scheduled
2620 if (num_sccs_no_alias
> 0)
2623 for (i
= 0; i
< pg
->n_vertices
; ++i
)
2625 struct pg_vdata
*data
= (struct pg_vdata
*)pg
->vertices
[i
].data
;
2626 if (data
->partition
&& partition_reduction_p (data
->partition
))
2628 gcc_assert (j
== -1);
2633 pg
->vertices
[j
].post
= -1;
2636 free (cbdata
.vertices_component
);
2639 sort_partitions_by_post_order (pg
, partitions
);
2640 free_partition_graph_vdata (pg
);
2641 for_each_edge (pg
, free_partition_graph_edata_cb
, NULL
);
2644 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2646 fprintf (dump_file
, "Possible alias data dependence to break:\n");
2647 dump_data_dependence_relations (dump_file
, *alias_ddrs
);
2651 /* Compute and return an expression whose value is the segment length which
2652 will be accessed by DR in NITERS iterations. */
2655 data_ref_segment_size (struct data_reference
*dr
, tree niters
)
2657 niters
= size_binop (MINUS_EXPR
,
2658 fold_convert (sizetype
, niters
),
2660 return size_binop (MULT_EXPR
,
2661 fold_convert (sizetype
, DR_STEP (dr
)),
2662 fold_convert (sizetype
, niters
));
2665 /* Return true if LOOP's latch is dominated by statement for data reference
2669 latch_dominated_by_data_ref (class loop
*loop
, data_reference
*dr
)
2671 return dominated_by_p (CDI_DOMINATORS
, single_exit (loop
)->src
,
2672 gimple_bb (DR_STMT (dr
)));
2675 /* Compute alias check pairs and store them in COMP_ALIAS_PAIRS for LOOP's
2676 data dependence relations ALIAS_DDRS. */
2679 compute_alias_check_pairs (class loop
*loop
, vec
<ddr_p
> *alias_ddrs
,
2680 vec
<dr_with_seg_len_pair_t
> *comp_alias_pairs
)
2683 unsigned HOST_WIDE_INT factor
= 1;
2684 tree niters_plus_one
, niters
= number_of_latch_executions (loop
);
2686 gcc_assert (niters
!= NULL_TREE
&& niters
!= chrec_dont_know
);
2687 niters
= fold_convert (sizetype
, niters
);
2688 niters_plus_one
= size_binop (PLUS_EXPR
, niters
, size_one_node
);
2690 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2691 fprintf (dump_file
, "Creating alias check pairs:\n");
2693 /* Iterate all data dependence relations and compute alias check pairs. */
2694 for (i
= 0; i
< alias_ddrs
->length (); i
++)
2696 ddr_p ddr
= (*alias_ddrs
)[i
];
2697 struct data_reference
*dr_a
= DDR_A (ddr
);
2698 struct data_reference
*dr_b
= DDR_B (ddr
);
2699 tree seg_length_a
, seg_length_b
;
2701 if (latch_dominated_by_data_ref (loop
, dr_a
))
2702 seg_length_a
= data_ref_segment_size (dr_a
, niters_plus_one
);
2704 seg_length_a
= data_ref_segment_size (dr_a
, niters
);
2706 if (latch_dominated_by_data_ref (loop
, dr_b
))
2707 seg_length_b
= data_ref_segment_size (dr_b
, niters_plus_one
);
2709 seg_length_b
= data_ref_segment_size (dr_b
, niters
);
2711 unsigned HOST_WIDE_INT access_size_a
2712 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_a
))));
2713 unsigned HOST_WIDE_INT access_size_b
2714 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr_b
))));
2715 unsigned int align_a
= TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_a
)));
2716 unsigned int align_b
= TYPE_ALIGN_UNIT (TREE_TYPE (DR_REF (dr_b
)));
2718 dr_with_seg_len_pair_t dr_with_seg_len_pair
2719 (dr_with_seg_len (dr_a
, seg_length_a
, access_size_a
, align_a
),
2720 dr_with_seg_len (dr_b
, seg_length_b
, access_size_b
, align_b
),
2721 /* ??? Would WELL_ORDERED be safe? */
2722 dr_with_seg_len_pair_t::REORDERED
);
2724 comp_alias_pairs
->safe_push (dr_with_seg_len_pair
);
2727 if (tree_fits_uhwi_p (niters
))
2728 factor
= tree_to_uhwi (niters
);
2730 /* Prune alias check pairs. */
2731 prune_runtime_alias_test_list (comp_alias_pairs
, factor
);
2732 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2734 "Improved number of alias checks from %d to %d\n",
2735 alias_ddrs
->length (), comp_alias_pairs
->length ());
2738 /* Given data dependence relations in ALIAS_DDRS, generate runtime alias
2739 checks and version LOOP under condition of these runtime alias checks. */
2742 version_loop_by_alias_check (vec
<struct partition
*> *partitions
,
2743 class loop
*loop
, vec
<ddr_p
> *alias_ddrs
)
2745 profile_probability prob
;
2746 basic_block cond_bb
;
2748 tree lhs
, arg0
, cond_expr
= NULL_TREE
;
2749 gimple_seq cond_stmts
= NULL
;
2750 gimple
*call_stmt
= NULL
;
2751 auto_vec
<dr_with_seg_len_pair_t
> comp_alias_pairs
;
2753 /* Generate code for runtime alias checks if necessary. */
2754 gcc_assert (alias_ddrs
->length () > 0);
2756 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2758 "Version loop <%d> with runtime alias check\n", loop
->num
);
2760 compute_alias_check_pairs (loop
, alias_ddrs
, &comp_alias_pairs
);
2761 create_runtime_alias_checks (loop
, &comp_alias_pairs
, &cond_expr
);
2762 cond_expr
= force_gimple_operand_1 (cond_expr
, &cond_stmts
,
2763 is_gimple_val
, NULL_TREE
);
2765 /* Depend on vectorizer to fold IFN_LOOP_DIST_ALIAS. */
2766 bool cancelable_p
= flag_tree_loop_vectorize
;
2770 struct partition
*partition
;
2771 for (; partitions
->iterate (i
, &partition
); ++i
)
2772 if (!partition_builtin_p (partition
))
2775 /* If all partitions are builtins, distributing it would be profitable and
2776 we don't want to cancel the runtime alias checks. */
2777 if (i
== partitions
->length ())
2778 cancelable_p
= false;
2781 /* Generate internal function call for loop distribution alias check if the
2782 runtime alias check should be cancelable. */
2785 call_stmt
= gimple_build_call_internal (IFN_LOOP_DIST_ALIAS
,
2786 2, NULL_TREE
, cond_expr
);
2787 lhs
= make_ssa_name (boolean_type_node
);
2788 gimple_call_set_lhs (call_stmt
, lhs
);
2793 prob
= profile_probability::guessed_always ().apply_scale (9, 10);
2794 initialize_original_copy_tables ();
2795 nloop
= loop_version (loop
, lhs
, &cond_bb
, prob
, prob
.invert (),
2796 prob
, prob
.invert (), true);
2797 free_original_copy_tables ();
2798 /* Record the original loop number in newly generated loops. In case of
2799 distribution, the original loop will be distributed and the new loop
2801 loop
->orig_loop_num
= nloop
->num
;
2802 nloop
->orig_loop_num
= nloop
->num
;
2803 nloop
->dont_vectorize
= true;
2804 nloop
->force_vectorize
= false;
2808 /* Record new loop's num in IFN_LOOP_DIST_ALIAS because the original
2809 loop could be destroyed. */
2810 arg0
= build_int_cst (integer_type_node
, loop
->orig_loop_num
);
2811 gimple_call_set_arg (call_stmt
, 0, arg0
);
2812 gimple_seq_add_stmt_without_update (&cond_stmts
, call_stmt
);
2817 gimple_stmt_iterator cond_gsi
= gsi_last_bb (cond_bb
);
2818 gsi_insert_seq_before (&cond_gsi
, cond_stmts
, GSI_SAME_STMT
);
2820 update_ssa (TODO_update_ssa_no_phi
);
2823 /* Return true if loop versioning is needed to distrubute PARTITIONS.
2824 ALIAS_DDRS are data dependence relations for runtime alias check. */
2827 version_for_distribution_p (vec
<struct partition
*> *partitions
,
2828 vec
<ddr_p
> *alias_ddrs
)
2830 /* No need to version loop if we have only one partition. */
2831 if (partitions
->length () == 1)
2834 /* Need to version loop if runtime alias check is necessary. */
2835 return (alias_ddrs
->length () > 0);
2838 /* Compare base offset of builtin mem* partitions P1 and P2. */
2841 offset_cmp (const void *vp1
, const void *vp2
)
2843 struct partition
*p1
= *(struct partition
*const *) vp1
;
2844 struct partition
*p2
= *(struct partition
*const *) vp2
;
2845 unsigned HOST_WIDE_INT o1
= p1
->builtin
->dst_base_offset
;
2846 unsigned HOST_WIDE_INT o2
= p2
->builtin
->dst_base_offset
;
2847 return (o2
< o1
) - (o1
< o2
);
2850 /* Fuse adjacent memset builtin PARTITIONS if possible. This is a special
2851 case optimization transforming below code:
2853 __builtin_memset (&obj, 0, 100);
2855 __builtin_memset (_1, 0, 200);
2857 __builtin_memset (_2, 0, 100);
2861 __builtin_memset (&obj, 0, 400);
2863 Note we don't have dependence information between different partitions
2864 at this point, as a result, we can't handle nonadjacent memset builtin
2865 partitions since dependence might be broken. */
2868 fuse_memset_builtins (vec
<struct partition
*> *partitions
)
2871 struct partition
*part1
, *part2
;
2874 for (i
= 0; partitions
->iterate (i
, &part1
);)
2876 if (part1
->kind
!= PKIND_MEMSET
)
2882 /* Find sub-array of memset builtins of the same base. Index range
2883 of the sub-array is [i, j) with "j > i". */
2884 for (j
= i
+ 1; partitions
->iterate (j
, &part2
); ++j
)
2886 if (part2
->kind
!= PKIND_MEMSET
2887 || !operand_equal_p (part1
->builtin
->dst_base_base
,
2888 part2
->builtin
->dst_base_base
, 0))
2891 /* Memset calls setting different values can't be merged. */
2892 rhs1
= gimple_assign_rhs1 (DR_STMT (part1
->builtin
->dst_dr
));
2893 rhs2
= gimple_assign_rhs1 (DR_STMT (part2
->builtin
->dst_dr
));
2894 if (!operand_equal_p (rhs1
, rhs2
, 0))
2898 /* Stable sort is required in order to avoid breaking dependence. */
2899 gcc_stablesort (&(*partitions
)[i
], j
- i
, sizeof (*partitions
)[i
],
2901 /* Continue with next partition. */
2905 /* Merge all consecutive memset builtin partitions. */
2906 for (i
= 0; i
< partitions
->length () - 1;)
2908 part1
= (*partitions
)[i
];
2909 if (part1
->kind
!= PKIND_MEMSET
)
2915 part2
= (*partitions
)[i
+ 1];
2916 /* Only merge memset partitions of the same base and with constant
2918 if (part2
->kind
!= PKIND_MEMSET
2919 || TREE_CODE (part1
->builtin
->size
) != INTEGER_CST
2920 || TREE_CODE (part2
->builtin
->size
) != INTEGER_CST
2921 || !operand_equal_p (part1
->builtin
->dst_base_base
,
2922 part2
->builtin
->dst_base_base
, 0))
2927 rhs1
= gimple_assign_rhs1 (DR_STMT (part1
->builtin
->dst_dr
));
2928 rhs2
= gimple_assign_rhs1 (DR_STMT (part2
->builtin
->dst_dr
));
2929 int bytev1
= const_with_all_bytes_same (rhs1
);
2930 int bytev2
= const_with_all_bytes_same (rhs2
);
2931 /* Only merge memset partitions of the same value. */
2932 if (bytev1
!= bytev2
|| bytev1
== -1)
2937 wide_int end1
= wi::add (part1
->builtin
->dst_base_offset
,
2938 wi::to_wide (part1
->builtin
->size
));
2939 /* Only merge adjacent memset partitions. */
2940 if (wi::ne_p (end1
, part2
->builtin
->dst_base_offset
))
2945 /* Merge partitions[i] and partitions[i+1]. */
2946 part1
->builtin
->size
= fold_build2 (PLUS_EXPR
, sizetype
,
2947 part1
->builtin
->size
,
2948 part2
->builtin
->size
);
2949 partition_free (part2
);
2950 partitions
->ordered_remove (i
+ 1);
2955 loop_distribution::finalize_partitions (class loop
*loop
,
2956 vec
<struct partition
*> *partitions
,
2957 vec
<ddr_p
> *alias_ddrs
)
2960 struct partition
*partition
, *a
;
2962 if (partitions
->length () == 1
2963 || alias_ddrs
->length () > 0)
2966 unsigned num_builtin
= 0, num_normal
= 0, num_partial_memset
= 0;
2967 bool same_type_p
= true;
2968 enum partition_type type
= ((*partitions
)[0])->type
;
2969 for (i
= 0; partitions
->iterate (i
, &partition
); ++i
)
2971 same_type_p
&= (type
== partition
->type
);
2972 if (partition_builtin_p (partition
))
2978 if (partition
->kind
== PKIND_PARTIAL_MEMSET
)
2979 num_partial_memset
++;
2982 /* Don't distribute current loop into too many loops given we don't have
2983 memory stream cost model. Be even more conservative in case of loop
2984 nest distribution. */
2985 if ((same_type_p
&& num_builtin
== 0
2986 && (loop
->inner
== NULL
|| num_normal
!= 2 || num_partial_memset
!= 1))
2987 || (loop
->inner
!= NULL
2988 && i
>= NUM_PARTITION_THRESHOLD
&& num_normal
> 1)
2989 || (loop
->inner
== NULL
2990 && i
>= NUM_PARTITION_THRESHOLD
&& num_normal
> num_builtin
))
2992 a
= (*partitions
)[0];
2993 for (i
= 1; partitions
->iterate (i
, &partition
); ++i
)
2995 partition_merge_into (NULL
, a
, partition
, FUSE_FINALIZE
);
2996 partition_free (partition
);
2998 partitions
->truncate (1);
3001 /* Fuse memset builtins if possible. */
3002 if (partitions
->length () > 1)
3003 fuse_memset_builtins (partitions
);
3006 /* Distributes the code from LOOP in such a way that producer statements
3007 are placed before consumer statements. Tries to separate only the
3008 statements from STMTS into separate loops. Returns the number of
3009 distributed loops. Set NB_CALLS to number of generated builtin calls.
3010 Set *DESTROY_P to whether LOOP needs to be destroyed. */
3013 loop_distribution::distribute_loop (class loop
*loop
,
3014 const vec
<gimple
*> &stmts
,
3015 control_dependences
*cd
, int *nb_calls
, bool *destroy_p
,
3016 bool only_patterns_p
)
3018 ddrs_table
= new hash_table
<ddr_hasher
> (389);
3020 partition
*partition
;
3025 loop_nest
.create (0);
3026 if (!find_loop_nest (loop
, &loop_nest
))
3028 loop_nest
.release ();
3033 datarefs_vec
.create (20);
3034 has_nonaddressable_dataref_p
= false;
3035 rdg
= build_rdg (loop
, cd
);
3038 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3040 "Loop %d not distributed: failed to build the RDG.\n",
3043 loop_nest
.release ();
3044 free_data_refs (datarefs_vec
);
3049 if (datarefs_vec
.length () > MAX_DATAREFS_NUM
)
3051 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3053 "Loop %d not distributed: too many memory references.\n",
3057 loop_nest
.release ();
3058 free_data_refs (datarefs_vec
);
3063 data_reference_p dref
;
3064 for (i
= 0; datarefs_vec
.iterate (i
, &dref
); ++i
)
3065 dref
->aux
= (void *) (uintptr_t) i
;
3067 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3068 dump_rdg (dump_file
, rdg
);
3070 auto_vec
<struct partition
*, 3> partitions
;
3071 rdg_build_partitions (rdg
, stmts
, &partitions
);
3073 auto_vec
<ddr_p
> alias_ddrs
;
3075 auto_bitmap stmt_in_all_partitions
;
3076 bitmap_copy (stmt_in_all_partitions
, partitions
[0]->stmts
);
3077 for (i
= 1; partitions
.iterate (i
, &partition
); ++i
)
3078 bitmap_and_into (stmt_in_all_partitions
, partitions
[i
]->stmts
);
3080 bool any_builtin
= false;
3081 bool reduction_in_all
= false;
3082 int reduction_partition_num
= -1;
3083 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3086 |= classify_partition (loop
, rdg
, partition
, stmt_in_all_partitions
);
3087 any_builtin
|= partition_builtin_p (partition
);
3090 /* If we are only distributing patterns but did not detect any,
3099 /* If we are only distributing patterns fuse all partitions that
3100 were not classified as builtins. This also avoids chopping
3101 a loop into pieces, separated by builtin calls. That is, we
3102 only want no or a single loop body remaining. */
3103 struct partition
*into
;
3104 if (only_patterns_p
)
3106 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3107 if (!partition_builtin_p (into
))
3109 for (++i
; partitions
.iterate (i
, &partition
); ++i
)
3110 if (!partition_builtin_p (partition
))
3112 partition_merge_into (NULL
, into
, partition
, FUSE_NON_BUILTIN
);
3113 partitions
.unordered_remove (i
);
3114 partition_free (partition
);
3119 /* Due to limitations in the transform phase we have to fuse all
3120 reduction partitions into the last partition so the existing
3121 loop will contain all loop-closed PHI nodes. */
3122 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3123 if (partition_reduction_p (into
))
3125 for (i
= i
+ 1; partitions
.iterate (i
, &partition
); ++i
)
3126 if (partition_reduction_p (partition
))
3128 partition_merge_into (rdg
, into
, partition
, FUSE_REDUCTION
);
3129 partitions
.unordered_remove (i
);
3130 partition_free (partition
);
3134 /* Apply our simple cost model - fuse partitions with similar
3136 for (i
= 0; partitions
.iterate (i
, &into
); ++i
)
3138 bool changed
= false;
3139 for (int j
= i
+ 1; partitions
.iterate (j
, &partition
); ++j
)
3141 if (share_memory_accesses (rdg
, into
, partition
))
3143 partition_merge_into (rdg
, into
, partition
, FUSE_SHARE_REF
);
3144 partitions
.unordered_remove (j
);
3145 partition_free (partition
);
3150 /* If we fused 0 1 2 in step 1 to 0,2 1 as 0 and 2 have similar
3151 accesses when 1 and 2 have similar accesses but not 0 and 1
3152 then in the next iteration we will fail to consider merging
3153 1 into 0,2. So try again if we did any merging into 0. */
3158 /* Put a non-builtin partition last if we need to preserve a reduction.
3159 In most cases this helps to keep a normal partition last avoiding to
3160 spill a reduction result across builtin calls.
3161 ??? The proper way would be to use dependences to see whether we
3162 can move builtin partitions earlier during merge_dep_scc_partitions
3163 and its sort_partitions_by_post_order. Especially when the
3164 dependence graph is composed of multiple independent subgraphs the
3165 heuristic does not work reliably. */
3166 if (reduction_in_all
3167 && partition_builtin_p (partitions
.last()))
3168 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3169 if (!partition_builtin_p (partition
))
3171 partitions
.unordered_remove (i
);
3172 partitions
.quick_push (partition
);
3176 /* Build the partition dependency graph and fuse partitions in strong
3177 connected component. */
3178 if (partitions
.length () > 1)
3180 /* Don't support loop nest distribution under runtime alias check
3181 since it's not likely to enable many vectorization opportunities.
3182 Also if loop has any data reference which may be not addressable
3183 since alias check needs to take, compare address of the object. */
3184 if (loop
->inner
|| has_nonaddressable_dataref_p
)
3185 merge_dep_scc_partitions (rdg
, &partitions
, false);
3188 merge_dep_scc_partitions (rdg
, &partitions
, true);
3189 if (partitions
.length () > 1)
3190 break_alias_scc_partitions (rdg
, &partitions
, &alias_ddrs
);
3194 finalize_partitions (loop
, &partitions
, &alias_ddrs
);
3196 /* If there is a reduction in all partitions make sure the last
3197 non-builtin partition provides the LC PHI defs. */
3198 if (reduction_in_all
)
3200 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3201 if (!partition_builtin_p (partition
))
3202 reduction_partition_num
= i
;
3203 if (reduction_partition_num
== -1)
3205 /* If all partitions are builtin, force the last one to
3206 be code generated as normal partition. */
3207 partition
= partitions
.last ();
3208 partition
->kind
= PKIND_NORMAL
;
3212 nbp
= partitions
.length ();
3214 || (nbp
== 1 && !partition_builtin_p (partitions
[0]))
3215 || (nbp
> 1 && partition_contains_all_rw (rdg
, partitions
)))
3221 if (version_for_distribution_p (&partitions
, &alias_ddrs
))
3222 version_loop_by_alias_check (&partitions
, loop
, &alias_ddrs
);
3224 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3227 "distribute loop <%d> into partitions:\n", loop
->num
);
3228 dump_rdg_partitions (dump_file
, partitions
);
3231 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3233 if (partition_builtin_p (partition
))
3235 *destroy_p
|= generate_code_for_partition (loop
, partition
, i
< nbp
- 1,
3236 i
== reduction_partition_num
);
3240 loop_nest
.release ();
3241 free_data_refs (datarefs_vec
);
3242 for (hash_table
<ddr_hasher
>::iterator iter
= ddrs_table
->begin ();
3243 iter
!= ddrs_table
->end (); ++iter
)
3245 free_dependence_relation (*iter
);
3250 FOR_EACH_VEC_ELT (partitions
, i
, partition
)
3251 partition_free (partition
);
3254 return nbp
- *nb_calls
;
3258 void loop_distribution::bb_top_order_init (void)
3261 int *rpo
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
) - NUM_FIXED_BLOCKS
);
3262 edge entry
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
3263 bitmap exit_bbs
= BITMAP_ALLOC (NULL
);
3265 bb_top_order_index
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
3266 bb_top_order_index_size
= last_basic_block_for_fn (cfun
);
3268 entry
->flags
&= ~EDGE_DFS_BACK
;
3269 bitmap_set_bit (exit_bbs
, EXIT_BLOCK
);
3270 rpo_num
= rev_post_order_and_mark_dfs_back_seme (cfun
, entry
, exit_bbs
, true,
3272 BITMAP_FREE (exit_bbs
);
3274 for (int i
= 0; i
< rpo_num
; i
++)
3275 bb_top_order_index
[rpo
[i
]] = i
;
3280 void loop_distribution::bb_top_order_destroy ()
3282 free (bb_top_order_index
);
3283 bb_top_order_index
= NULL
;
3284 bb_top_order_index_size
= 0;
3288 /* Given LOOP, this function records seed statements for distribution in
3289 WORK_LIST. Return false if there is nothing for distribution. */
3292 find_seed_stmts_for_distribution (class loop
*loop
, vec
<gimple
*> *work_list
)
3294 basic_block
*bbs
= get_loop_body_in_dom_order (loop
);
3296 /* Initialize the worklist with stmts we seed the partitions with. */
3297 for (unsigned i
= 0; i
< loop
->num_nodes
; ++i
)
3299 /* In irreducible sub-regions we don't know how to redirect
3300 conditions, so fail. See PR100492. */
3301 if (bbs
[i
]->flags
& BB_IRREDUCIBLE_LOOP
)
3303 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3304 fprintf (dump_file
, "loop %d contains an irreducible region.\n",
3306 work_list
->truncate (0);
3309 for (gphi_iterator gsi
= gsi_start_phis (bbs
[i
]);
3310 !gsi_end_p (gsi
); gsi_next (&gsi
))
3312 gphi
*phi
= gsi
.phi ();
3313 if (virtual_operand_p (gimple_phi_result (phi
)))
3315 /* Distribute stmts which have defs that are used outside of
3317 if (!stmt_has_scalar_dependences_outside_loop (loop
, phi
))
3319 work_list
->safe_push (phi
);
3321 for (gimple_stmt_iterator gsi
= gsi_start_bb (bbs
[i
]);
3322 !gsi_end_p (gsi
); gsi_next (&gsi
))
3324 gimple
*stmt
= gsi_stmt (gsi
);
3326 /* Ignore clobbers, they do not have true side effects. */
3327 if (gimple_clobber_p (stmt
))
3330 /* If there is a stmt with side-effects bail out - we
3331 cannot and should not distribute this loop. */
3332 if (gimple_has_side_effects (stmt
))
3338 /* Distribute stmts which have defs that are used outside of
3340 if (stmt_has_scalar_dependences_outside_loop (loop
, stmt
))
3342 /* Otherwise only distribute stores for now. */
3343 else if (!gimple_vdef (stmt
))
3346 work_list
->safe_push (stmt
);
3349 bool res
= work_list
->length () > 0;
3350 if (res
&& !can_copy_bbs_p (bbs
, loop
->num_nodes
))
3352 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3353 fprintf (dump_file
, "cannot copy loop %d.\n", loop
->num
);
3360 /* A helper function for generate_{rawmemchr,strlen}_builtin functions in order
3361 to place new statements SEQ before LOOP and replace the old reduction
3362 variable with the new one. */
3365 generate_reduction_builtin_1 (loop_p loop
, gimple_seq
&seq
,
3366 tree reduction_var_old
, tree reduction_var_new
,
3367 const char *info
, machine_mode load_mode
)
3369 gcc_assert (flag_tree_loop_distribute_patterns
);
3371 /* Place new statements before LOOP. */
3372 gimple_stmt_iterator gsi
= gsi_last_bb (loop_preheader_edge (loop
)->src
);
3373 gsi_insert_seq_after (&gsi
, seq
, GSI_CONTINUE_LINKING
);
3375 /* Replace old reduction variable with new one. */
3376 imm_use_iterator iter
;
3378 use_operand_p use_p
;
3379 FOR_EACH_IMM_USE_STMT (stmt
, iter
, reduction_var_old
)
3381 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
3382 SET_USE (use_p
, reduction_var_new
);
3387 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3388 fprintf (dump_file
, info
, GET_MODE_NAME (load_mode
));
3391 /* Generate a call to rawmemchr and place it before LOOP. REDUCTION_VAR is
3392 replaced with a fresh SSA name representing the result of the call. */
3395 generate_rawmemchr_builtin (loop_p loop
, tree reduction_var
,
3396 data_reference_p store_dr
, tree base
, tree pattern
,
3399 gimple_seq seq
= NULL
;
3401 tree mem
= force_gimple_operand (base
, &seq
, true, NULL_TREE
);
3402 gimple
*fn_call
= gimple_build_call_internal (IFN_RAWMEMCHR
, 2, mem
, pattern
);
3403 tree reduction_var_new
= copy_ssa_name (reduction_var
);
3404 gimple_call_set_lhs (fn_call
, reduction_var_new
);
3405 gimple_set_location (fn_call
, loc
);
3406 gimple_seq_add_stmt (&seq
, fn_call
);
3410 gassign
*g
= gimple_build_assign (DR_REF (store_dr
), reduction_var_new
);
3411 gimple_seq_add_stmt (&seq
, g
);
3414 generate_reduction_builtin_1 (loop
, seq
, reduction_var
, reduction_var_new
,
3415 "generated rawmemchr%s\n",
3416 TYPE_MODE (TREE_TYPE (TREE_TYPE (base
))));
3419 /* Helper function for generate_strlen_builtin(,_using_rawmemchr) */
3422 generate_strlen_builtin_1 (loop_p loop
, gimple_seq
&seq
,
3423 tree reduction_var_old
, tree reduction_var_new
,
3424 machine_mode mode
, tree start_len
)
3426 /* REDUCTION_VAR_NEW has either size type or ptrdiff type and must be
3427 converted if types of old and new reduction variable are not compatible. */
3428 reduction_var_new
= gimple_convert (&seq
, TREE_TYPE (reduction_var_old
),
3431 /* Loops of the form `for (i=42; s[i]; ++i);` have an additional start
3433 if (!integer_zerop (start_len
))
3435 tree lhs
= make_ssa_name (TREE_TYPE (reduction_var_new
));
3436 gimple
*g
= gimple_build_assign (lhs
, PLUS_EXPR
, reduction_var_new
,
3438 gimple_seq_add_stmt (&seq
, g
);
3439 reduction_var_new
= lhs
;
3442 generate_reduction_builtin_1 (loop
, seq
, reduction_var_old
, reduction_var_new
,
3443 "generated strlen%s\n", mode
);
3446 /* Generate a call to strlen and place it before LOOP. REDUCTION_VAR is
3447 replaced with a fresh SSA name representing the result of the call. */
3450 generate_strlen_builtin (loop_p loop
, tree reduction_var
, tree base
,
3451 tree start_len
, location_t loc
)
3453 gimple_seq seq
= NULL
;
3455 tree reduction_var_new
= make_ssa_name (size_type_node
);
3457 tree mem
= force_gimple_operand (base
, &seq
, true, NULL_TREE
);
3458 tree fn
= build_fold_addr_expr (builtin_decl_implicit (BUILT_IN_STRLEN
));
3459 gimple
*fn_call
= gimple_build_call (fn
, 1, mem
);
3460 gimple_call_set_lhs (fn_call
, reduction_var_new
);
3461 gimple_set_location (fn_call
, loc
);
3462 gimple_seq_add_stmt (&seq
, fn_call
);
3464 generate_strlen_builtin_1 (loop
, seq
, reduction_var
, reduction_var_new
,
3468 /* Generate code in order to mimic the behaviour of strlen but this time over
3469 an array of elements with mode different than QI. REDUCTION_VAR is replaced
3470 with a fresh SSA name representing the result, i.e., the length. */
3473 generate_strlen_builtin_using_rawmemchr (loop_p loop
, tree reduction_var
,
3474 tree base
, tree load_type
,
3475 tree start_len
, location_t loc
)
3477 gimple_seq seq
= NULL
;
3479 tree start
= force_gimple_operand (base
, &seq
, true, NULL_TREE
);
3480 tree zero
= build_zero_cst (load_type
);
3481 gimple
*fn_call
= gimple_build_call_internal (IFN_RAWMEMCHR
, 2, start
, zero
);
3482 tree end
= make_ssa_name (TREE_TYPE (base
));
3483 gimple_call_set_lhs (fn_call
, end
);
3484 gimple_set_location (fn_call
, loc
);
3485 gimple_seq_add_stmt (&seq
, fn_call
);
3487 /* Determine the number of elements between START and END by
3488 evaluating (END - START) / sizeof (*START). */
3489 tree diff
= make_ssa_name (ptrdiff_type_node
);
3490 gimple
*diff_stmt
= gimple_build_assign (diff
, POINTER_DIFF_EXPR
, end
, start
);
3491 gimple_seq_add_stmt (&seq
, diff_stmt
);
3492 /* Let SIZE be the size of each character. */
3493 tree size
= gimple_convert (&seq
, ptrdiff_type_node
,
3494 TYPE_SIZE_UNIT (load_type
));
3495 tree count
= make_ssa_name (ptrdiff_type_node
);
3496 gimple
*count_stmt
= gimple_build_assign (count
, TRUNC_DIV_EXPR
, diff
, size
);
3497 gimple_seq_add_stmt (&seq
, count_stmt
);
3499 generate_strlen_builtin_1 (loop
, seq
, reduction_var
, count
,
3500 TYPE_MODE (load_type
),
3504 /* Return true if we can count at least as many characters by taking pointer
3505 difference as we can count via reduction_var without an overflow. Thus
3506 compute 2^n < (2^(m-1) / s) where n = TYPE_PRECISION (reduction_var_type),
3507 m = TYPE_PRECISION (ptrdiff_type_node), and s = size of each character. */
3509 reduction_var_overflows_first (tree reduction_var_type
, tree load_type
)
3511 widest_int n2
= wi::lshift (1, TYPE_PRECISION (reduction_var_type
));;
3512 widest_int m2
= wi::lshift (1, TYPE_PRECISION (ptrdiff_type_node
) - 1);
3513 widest_int s
= wi::to_widest (TYPE_SIZE_UNIT (load_type
));
3514 return wi::ltu_p (n2
, wi::udiv_trunc (m2
, s
));
3518 determine_reduction_stmt_1 (const loop_p loop
, const basic_block
*bbs
)
3520 gimple
*reduction_stmt
= NULL
;
3522 for (unsigned i
= 0, ninsns
= 0; i
< loop
->num_nodes
; ++i
)
3524 basic_block bb
= bbs
[i
];
3526 for (gphi_iterator bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
);
3527 gsi_next_nondebug (&bsi
))
3529 gphi
*phi
= bsi
.phi ();
3530 if (virtual_operand_p (gimple_phi_result (phi
)))
3532 if (stmt_has_scalar_dependences_outside_loop (loop
, phi
))
3536 reduction_stmt
= phi
;
3540 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);
3541 gsi_next_nondebug (&bsi
), ++ninsns
)
3543 /* Bail out early for loops which are unlikely to match. */
3546 gimple
*stmt
= gsi_stmt (bsi
);
3547 if (gimple_clobber_p (stmt
))
3549 if (gimple_code (stmt
) == GIMPLE_LABEL
)
3551 if (gimple_has_volatile_ops (stmt
))
3553 if (stmt_has_scalar_dependences_outside_loop (loop
, stmt
))
3557 reduction_stmt
= stmt
;
3562 return reduction_stmt
;
3565 /* If LOOP has a single non-volatile reduction statement, then return a pointer
3566 to it. Otherwise return NULL. */
3568 determine_reduction_stmt (const loop_p loop
)
3570 basic_block
*bbs
= get_loop_body (loop
);
3571 gimple
*reduction_stmt
= determine_reduction_stmt_1 (loop
, bbs
);
3573 return reduction_stmt
;
3576 /* Transform loops which mimic the effects of builtins rawmemchr or strlen and
3577 replace them accordingly. For example, a loop of the form
3579 for (; *p != 42; ++p);
3583 p = rawmemchr<MODE> (p, 42);
3585 under the assumption that rawmemchr is available for a particular MODE.
3589 for (i = 42; s[i]; ++i);
3591 which is replaced by
3593 i = (int)strlen (&s[42]) + 42;
3595 for some character array S. In case array S is not of type character array
3598 i = (int)(rawmemchr<MODE> (&s[42], 0) - &s[42]) + 42;
3600 assuming that rawmemchr is available for a particular MODE. */
3603 loop_distribution::transform_reduction_loop (loop_p loop
)
3605 gimple
*reduction_stmt
;
3606 data_reference_p load_dr
= NULL
, store_dr
= NULL
;
3608 edge e
= single_exit (loop
);
3609 gcond
*cond
= safe_dyn_cast
<gcond
*> (*gsi_last_bb (e
->src
));
3612 /* Ensure loop condition is an (in)equality test and loop is exited either if
3613 the inequality test fails or the equality test succeeds. */
3614 if (!(e
->flags
& EDGE_FALSE_VALUE
&& gimple_cond_code (cond
) == NE_EXPR
)
3615 && !(e
->flags
& EDGE_TRUE_VALUE
&& gimple_cond_code (cond
) == EQ_EXPR
))
3617 /* A limitation of the current implementation is that we only support
3618 constant patterns in (in)equality tests. */
3619 tree pattern
= gimple_cond_rhs (cond
);
3620 if (TREE_CODE (pattern
) != INTEGER_CST
)
3623 reduction_stmt
= determine_reduction_stmt (loop
);
3625 /* A limitation of the current implementation is that we require a reduction
3626 statement. Therefore, loops without a reduction statement as in the
3627 following are not recognized:
3629 void foo (void) { for (; *p; ++p); } */
3630 if (reduction_stmt
== NULL
)
3633 /* Reduction variables are guaranteed to be SSA names. */
3635 switch (gimple_code (reduction_stmt
))
3639 reduction_var
= gimple_get_lhs (reduction_stmt
);
3642 /* Bail out e.g. for GIMPLE_CALL. */
3646 struct graph
*rdg
= build_rdg (loop
, NULL
);
3649 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3651 "Loop %d not transformed: failed to build the RDG.\n",
3656 auto_bitmap partition_stmts
;
3657 bitmap_set_range (partition_stmts
, 0, rdg
->n_vertices
);
3658 find_single_drs (loop
, rdg
, partition_stmts
, &store_dr
, &load_dr
);
3661 /* Bail out if there is no single load. */
3662 if (load_dr
== NULL
)
3665 /* Reaching this point we have a loop with a single reduction variable,
3666 a single load, and an optional single store. */
3668 tree load_ref
= DR_REF (load_dr
);
3669 tree load_type
= TREE_TYPE (load_ref
);
3670 tree load_access_base
= build_fold_addr_expr (load_ref
);
3671 tree load_access_size
= TYPE_SIZE_UNIT (load_type
);
3672 affine_iv load_iv
, reduction_iv
;
3674 if (!INTEGRAL_TYPE_P (load_type
)
3675 || !type_has_mode_precision_p (load_type
))
3678 /* We already ensured that the loop condition tests for (in)equality where the
3679 rhs is a constant pattern. Now ensure that the lhs is the result of the
3681 if (gimple_cond_lhs (cond
) != gimple_assign_lhs (DR_STMT (load_dr
)))
3684 /* Bail out if no affine induction variable with constant step can be
3686 if (!simple_iv (loop
, loop
, load_access_base
, &load_iv
, false))
3689 /* Bail out if memory accesses are not consecutive or not growing. */
3690 if (!operand_equal_p (load_iv
.step
, load_access_size
, 0))
3693 if (!simple_iv (loop
, loop
, reduction_var
, &reduction_iv
, false))
3696 /* Handle rawmemchr like loops. */
3697 if (operand_equal_p (load_iv
.base
, reduction_iv
.base
)
3698 && operand_equal_p (load_iv
.step
, reduction_iv
.step
))
3702 /* Ensure that we store to X and load from X+I where I>0. */
3703 if (TREE_CODE (load_iv
.base
) != POINTER_PLUS_EXPR
3704 || !integer_onep (TREE_OPERAND (load_iv
.base
, 1)))
3706 tree ptr_base
= TREE_OPERAND (load_iv
.base
, 0);
3707 if (TREE_CODE (ptr_base
) != SSA_NAME
)
3709 gimple
*def
= SSA_NAME_DEF_STMT (ptr_base
);
3710 if (!gimple_assign_single_p (def
)
3711 || gimple_assign_rhs1 (def
) != DR_REF (store_dr
))
3713 /* Ensure that the reduction value is stored. */
3714 if (gimple_assign_rhs1 (DR_STMT (store_dr
)) != reduction_var
)
3717 /* Bail out if target does not provide rawmemchr for a certain mode. */
3718 machine_mode mode
= TYPE_MODE (load_type
);
3719 if (direct_optab_handler (rawmemchr_optab
, mode
) == CODE_FOR_nothing
)
3721 location_t loc
= gimple_location (DR_STMT (load_dr
));
3722 generate_rawmemchr_builtin (loop
, reduction_var
, store_dr
, load_iv
.base
,
3727 /* Handle strlen like loops. */
3728 if (store_dr
== NULL
3729 && integer_zerop (pattern
)
3730 && INTEGRAL_TYPE_P (TREE_TYPE (reduction_var
))
3731 && TREE_CODE (reduction_iv
.base
) == INTEGER_CST
3732 && TREE_CODE (reduction_iv
.step
) == INTEGER_CST
3733 && integer_onep (reduction_iv
.step
))
3735 location_t loc
= gimple_location (DR_STMT (load_dr
));
3736 tree reduction_var_type
= TREE_TYPE (reduction_var
);
3737 /* While determining the length of a string an overflow might occur.
3738 If an overflow only occurs in the loop implementation and not in the
3739 strlen implementation, then either the overflow is undefined or the
3740 truncated result of strlen equals the one of the loop. Otherwise if
3741 an overflow may also occur in the strlen implementation, then
3742 replacing a loop by a call to strlen is sound whenever we ensure that
3743 if an overflow occurs in the strlen implementation, then also an
3744 overflow occurs in the loop implementation which is undefined. It
3745 seems reasonable to relax this and assume that the strlen
3746 implementation cannot overflow in case sizetype is big enough in the
3747 sense that an overflow can only happen for string objects which are
3748 bigger than half of the address space; at least for 32-bit targets and
3751 For strlen which makes use of rawmemchr the maximal length of a string
3752 which can be determined without an overflow is PTRDIFF_MAX / S where
3753 each character has size S. Since an overflow for ptrdiff type is
3754 undefined we have to make sure that if an overflow occurs, then an
3755 overflow occurs in the loop implementation, too, and this is
3756 undefined, too. Similar as before we relax this and assume that no
3757 string object is larger than half of the address space; at least for
3758 32-bit targets and up. */
3759 if (TYPE_MODE (load_type
) == TYPE_MODE (char_type_node
)
3760 && TYPE_PRECISION (load_type
) == TYPE_PRECISION (char_type_node
)
3761 && ((TYPE_PRECISION (sizetype
) >= TYPE_PRECISION (ptr_type_node
) - 1
3762 && TYPE_PRECISION (ptr_type_node
) >= 32)
3763 || (TYPE_OVERFLOW_UNDEFINED (reduction_var_type
)
3764 && TYPE_PRECISION (reduction_var_type
) <= TYPE_PRECISION (sizetype
)))
3765 && builtin_decl_implicit (BUILT_IN_STRLEN
))
3766 generate_strlen_builtin (loop
, reduction_var
, load_iv
.base
,
3767 reduction_iv
.base
, loc
);
3768 else if (direct_optab_handler (rawmemchr_optab
, TYPE_MODE (load_type
))
3770 && ((TYPE_PRECISION (ptrdiff_type_node
) == TYPE_PRECISION (ptr_type_node
)
3771 && TYPE_PRECISION (ptrdiff_type_node
) >= 32)
3772 || (TYPE_OVERFLOW_UNDEFINED (reduction_var_type
)
3773 && reduction_var_overflows_first (reduction_var_type
, load_type
))))
3774 generate_strlen_builtin_using_rawmemchr (loop
, reduction_var
,
3777 reduction_iv
.base
, loc
);
3786 /* Given innermost LOOP, return the outermost enclosing loop that forms a
3787 perfect loop nest. */
3790 prepare_perfect_loop_nest (class loop
*loop
)
3792 class loop
*outer
= loop_outer (loop
);
3793 tree niters
= number_of_latch_executions (loop
);
3795 /* TODO: We only support the innermost 3-level loop nest distribution
3796 because of compilation time issue for now. This should be relaxed
3797 in the future. Note we only allow 3-level loop nest distribution
3798 when parallelizing loops. */
3799 while ((loop
->inner
== NULL
3800 || (loop
->inner
->inner
== NULL
&& flag_tree_parallelize_loops
> 1))
3801 && loop_outer (outer
)
3802 && outer
->inner
== loop
&& loop
->next
== NULL
3803 && single_exit (outer
)
3804 && !chrec_contains_symbols_defined_in_loop (niters
, outer
->num
)
3805 && (niters
= number_of_latch_executions (outer
)) != NULL_TREE
3806 && niters
!= chrec_dont_know
)
3809 outer
= loop_outer (loop
);
3817 loop_distribution::execute (function
*fun
)
3819 bool changed
= false;
3821 control_dependences
*cd
= NULL
;
3822 auto_vec
<loop_p
> loops_to_be_destroyed
;
3824 if (number_of_loops (fun
) <= 1)
3827 bb_top_order_init ();
3829 FOR_ALL_BB_FN (bb
, fun
)
3831 gimple_stmt_iterator gsi
;
3832 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3833 gimple_set_uid (gsi_stmt (gsi
), -1);
3834 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3835 gimple_set_uid (gsi_stmt (gsi
), -1);
3838 /* We can at the moment only distribute non-nested loops, thus restrict
3839 walking to innermost loops. */
3840 for (auto loop
: loops_list (cfun
, LI_ONLY_INNERMOST
))
3842 /* Don't distribute multiple exit edges loop, or cold loop when
3843 not doing pattern detection. */
3844 if (!single_exit (loop
)
3845 || (!flag_tree_loop_distribute_patterns
3846 && !optimize_loop_for_speed_p (loop
)))
3849 /* If niters is unknown don't distribute loop but rather try to transform
3850 it to a call to a builtin. */
3851 tree niters
= number_of_latch_executions (loop
);
3852 if (niters
== NULL_TREE
|| niters
== chrec_dont_know
)
3854 datarefs_vec
.create (20);
3855 if (flag_tree_loop_distribute_patterns
3856 && transform_reduction_loop (loop
))
3859 loops_to_be_destroyed
.safe_push (loop
);
3860 if (dump_enabled_p ())
3862 dump_user_location_t loc
= find_loop_location (loop
);
3863 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
,
3864 loc
, "Loop %d transformed into a builtin.\n",
3868 free_data_refs (datarefs_vec
);
3872 /* Get the perfect loop nest for distribution. */
3873 loop
= prepare_perfect_loop_nest (loop
);
3874 for (; loop
; loop
= loop
->inner
)
3876 auto_vec
<gimple
*> work_list
;
3877 if (!find_seed_stmts_for_distribution (loop
, &work_list
))
3880 const char *str
= loop
->inner
? " nest" : "";
3881 dump_user_location_t loc
= find_loop_location (loop
);
3884 calculate_dominance_info (CDI_DOMINATORS
);
3885 calculate_dominance_info (CDI_POST_DOMINATORS
);
3886 cd
= new control_dependences ();
3887 free_dominance_info (CDI_POST_DOMINATORS
);
3891 int nb_generated_loops
, nb_generated_calls
;
3892 bool only_patterns
= !optimize_loop_for_speed_p (loop
)
3893 || !flag_tree_loop_distribution
;
3894 /* do not try to distribute loops that are not expected to iterate. */
3897 HOST_WIDE_INT iterations
= estimated_loop_iterations_int (loop
);
3899 iterations
= likely_max_loop_iterations_int (loop
);
3901 only_patterns
= true;
3904 = distribute_loop (loop
, work_list
, cd
, &nb_generated_calls
,
3905 &destroy_p
, only_patterns
);
3907 loops_to_be_destroyed
.safe_push (loop
);
3909 if (nb_generated_loops
+ nb_generated_calls
> 0)
3912 if (dump_enabled_p ())
3913 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
,
3914 loc
, "Loop%s %d distributed: split to %d loops "
3915 "and %d library calls.\n", str
, loop
->num
,
3916 nb_generated_loops
, nb_generated_calls
);
3921 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3922 fprintf (dump_file
, "Loop%s %d not distributed.\n", str
, loop
->num
);
3929 if (bb_top_order_index
!= NULL
)
3930 bb_top_order_destroy ();
3934 /* Destroy loop bodies that could not be reused. Do this late as we
3935 otherwise can end up refering to stale data in control dependences. */
3938 FOR_EACH_VEC_ELT (loops_to_be_destroyed
, i
, loop
)
3939 destroy_loop (loop
);
3941 /* Cached scalar evolutions now may refer to wrong or non-existing
3944 mark_virtual_operands_for_renaming (fun
);
3945 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
3948 checking_verify_loop_structure ();
3950 return changed
? TODO_cleanup_cfg
: 0;
3954 /* Distribute all loops in the current function. */
3958 const pass_data pass_data_loop_distribution
=
3960 GIMPLE_PASS
, /* type */
3962 OPTGROUP_LOOP
, /* optinfo_flags */
3963 TV_TREE_LOOP_DISTRIBUTION
, /* tv_id */
3964 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3965 0, /* properties_provided */
3966 0, /* properties_destroyed */
3967 0, /* todo_flags_start */
3968 0, /* todo_flags_finish */
3971 class pass_loop_distribution
: public gimple_opt_pass
3974 pass_loop_distribution (gcc::context
*ctxt
)
3975 : gimple_opt_pass (pass_data_loop_distribution
, ctxt
)
3978 /* opt_pass methods: */
3979 bool gate (function
*) final override
3981 return flag_tree_loop_distribution
3982 || flag_tree_loop_distribute_patterns
;
3985 unsigned int execute (function
*) final override
;
3987 }; // class pass_loop_distribution
3990 pass_loop_distribution::execute (function
*fun
)
3992 return loop_distribution ().execute (fun
);
3998 make_pass_loop_distribution (gcc::context
*ctxt
)
4000 return new pass_loop_distribution (ctxt
);