Branch data Line data Source code
1 : : /* Schedule GIMPLE vector statements.
2 : : Copyright (C) 2020-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : GCC is free software; you can redistribute it and/or modify it
7 : : under the terms of the GNU General Public License as published by the
8 : : Free Software Foundation; either version 3, or (at your option) any
9 : : later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful, but WITHOUT
12 : : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : : for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "rtl.h"
25 : : #include "tree.h"
26 : : #include "gimple.h"
27 : : #include "tree-pass.h"
28 : : #include "ssa.h"
29 : : #include "expmed.h"
30 : : #include "optabs-tree.h"
31 : : #include "tree-eh.h"
32 : : #include "gimple-iterator.h"
33 : : #include "gimplify-me.h"
34 : : #include "gimplify.h"
35 : : #include "tree-cfg.h"
36 : : #include "bitmap.h"
37 : : #include "tree-ssa-dce.h"
38 : : #include "memmodel.h"
39 : : #include "optabs.h"
40 : : #include "gimple-fold.h"
41 : : #include "internal-fn.h"
42 : :
43 : : /* Expand all ARRAY_REF(VIEW_CONVERT_EXPR) gimple assignments into calls to
44 : : internal function based on vector type of selected expansion.
45 : :
46 : : For vec_set:
47 : :
48 : : VIEW_CONVERT_EXPR<int[4]>(u)[_1] = i_4(D);
49 : : =>
50 : : _7 = u;
51 : : _8 = .VEC_SET (_7, i_4(D), _1);
52 : : u = _8;
53 : :
54 : : For vec_extract:
55 : :
56 : : _3 = VIEW_CONVERT_EXPR<intD.1[4]>(vD.2208)[idx_2(D)];
57 : : =>
58 : : _4 = vD.2208;
59 : : _3 = .VEC_EXTRACT (_4, idx_2(D)); */
60 : :
61 : : static bool
62 : 83753384 : gimple_expand_vec_set_extract_expr (struct function *fun,
63 : : gimple_stmt_iterator *gsi)
64 : : {
65 : 83753384 : gcall *new_stmt = NULL;
66 : 83753384 : gassign *ass_stmt = NULL;
67 : 83753384 : bool cfg_changed = false;
68 : :
69 : : /* Only consider code == GIMPLE_ASSIGN. */
70 : 113502882 : gassign *stmt = dyn_cast<gassign *> (gsi_stmt (*gsi));
71 : 29749620 : if (!stmt)
72 : : return false;
73 : :
74 : 29749620 : bool is_extract = false;
75 : :
76 : 29749620 : tree lhs = gimple_assign_lhs (stmt);
77 : 29749620 : tree rhs = gimple_assign_rhs1 (stmt);
78 : 29749620 : tree val, ref;
79 : 29749620 : if (TREE_CODE (lhs) == ARRAY_REF)
80 : : {
81 : : /* Assume it is a vec_set. */
82 : : val = rhs;
83 : : ref = lhs;
84 : : }
85 : 29213355 : else if (TREE_CODE (rhs) == ARRAY_REF)
86 : : {
87 : : /* vec_extract. */
88 : : is_extract = true;
89 : : val = lhs;
90 : : ref = rhs;
91 : : }
92 : : else
93 : : return false;
94 : :
95 : 1057709 : tree op0 = TREE_OPERAND (ref, 0);
96 : 30445 : if (TREE_CODE (op0) == VIEW_CONVERT_EXPR && DECL_P (TREE_OPERAND (op0, 0))
97 : 26166 : && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
98 : 1077449 : && TYPE_MODE (TREE_TYPE (ref))
99 : 9870 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))))
100 : : {
101 : 9866 : tree pos = TREE_OPERAND (ref, 1);
102 : :
103 : 9866 : tree view_op0 = TREE_OPERAND (op0, 0);
104 : 9866 : machine_mode outermode = TYPE_MODE (TREE_TYPE (view_op0));
105 : 9866 : machine_mode extract_mode = TYPE_MODE (TREE_TYPE (ref));
106 : :
107 : 9866 : if ((auto_var_in_fn_p (view_op0, fun->decl)
108 : 1287 : || (VAR_P (view_op0) && DECL_HARD_REGISTER (view_op0)))
109 : 8589 : && !TREE_ADDRESSABLE (view_op0)
110 : 16742 : && ((!is_extract && can_vec_set_var_idx_p (outermode))
111 : : || (is_extract
112 : 6737 : && can_vec_extract_var_idx_p (outermode, extract_mode))))
113 : : {
114 : 122 : location_t loc = gimple_location (stmt);
115 : 122 : tree var_src = make_ssa_name (TREE_TYPE (view_op0));
116 : :
117 : 122 : ass_stmt = gimple_build_assign (var_src, view_op0);
118 : 244 : gimple_set_vuse (ass_stmt, gimple_vuse (stmt));
119 : 122 : gimple_set_location (ass_stmt, loc);
120 : 122 : gsi_insert_before (gsi, ass_stmt, GSI_SAME_STMT);
121 : :
122 : 122 : if (!is_extract)
123 : : {
124 : 122 : tree var_dst = make_ssa_name (TREE_TYPE (view_op0));
125 : :
126 : 122 : new_stmt = gimple_build_call_internal (IFN_VEC_SET, 3, var_src,
127 : : val, pos);
128 : :
129 : 122 : gimple_call_set_lhs (new_stmt, var_dst);
130 : 122 : gimple_set_location (new_stmt, loc);
131 : 122 : gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
132 : :
133 : 122 : ass_stmt = gimple_build_assign (view_op0, var_dst);
134 : 122 : gimple_set_location (ass_stmt, loc);
135 : 122 : gimple_move_vops (ass_stmt, stmt);
136 : 122 : gsi_insert_before (gsi, ass_stmt, GSI_SAME_STMT);
137 : :
138 : 122 : basic_block bb = gimple_bb (stmt);
139 : 122 : if (gsi_remove (gsi, true)
140 : 122 : && gimple_purge_dead_eh_edges (bb))
141 : : cfg_changed = true;
142 : 122 : *gsi = gsi_for_stmt (ass_stmt);
143 : : }
144 : : else
145 : : {
146 : 0 : new_stmt
147 : 0 : = gimple_build_call_internal (IFN_VEC_EXTRACT, 2, var_src, pos);
148 : 0 : gimple_call_set_lhs (new_stmt, lhs);
149 : :
150 : 0 : gsi_replace (gsi, new_stmt, true);
151 : 0 : cfg_changed = true;
152 : : }
153 : : }
154 : : }
155 : :
156 : : return cfg_changed;
157 : : }
158 : :
159 : : /* Expand all VEC_COND_EXPR gimple assignments into calls to internal
160 : : function based on type of selected expansion. */
161 : :
162 : : static gimple *
163 : 83753384 : gimple_expand_vec_cond_expr (struct function *fun, gimple_stmt_iterator *gsi,
164 : : hash_map<tree, unsigned int> *vec_cond_ssa_name_uses)
165 : : {
166 : 83753384 : tree lhs, op0a = NULL_TREE, op0b = NULL_TREE;
167 : 83753384 : enum tree_code code;
168 : 83753384 : enum tree_code tcode;
169 : 83753384 : machine_mode cmp_op_mode;
170 : 83753384 : bool unsignedp;
171 : 83753384 : enum insn_code icode;
172 : 83753384 : imm_use_iterator imm_iter;
173 : :
174 : : /* Only consider code == GIMPLE_ASSIGN. */
175 : 83753384 : gassign *stmt = dyn_cast<gassign *> (gsi_stmt (*gsi));
176 : 83753384 : if (!stmt)
177 : : return NULL;
178 : :
179 : 29755386 : code = gimple_assign_rhs_code (stmt);
180 : 29755386 : if (code != VEC_COND_EXPR)
181 : : return NULL;
182 : :
183 : 14918 : tree op0 = gimple_assign_rhs1 (stmt);
184 : 14918 : tree op1 = gimple_assign_rhs2 (stmt);
185 : 14918 : tree op2 = gimple_assign_rhs3 (stmt);
186 : 14918 : lhs = gimple_assign_lhs (stmt);
187 : 14918 : machine_mode mode = TYPE_MODE (TREE_TYPE (lhs));
188 : :
189 : : /* Lower mask typed, non-vector mode VEC_COND_EXPRs to bitwise operations.
190 : : Those can end up generated by folding and at least for integer mode masks
191 : : we cannot expect vcond expanders to exist. We lower a ? b : c
192 : : to (b & a) | (c & ~a). */
193 : 29836 : if (VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (lhs))
194 : 14919 : && !VECTOR_MODE_P (mode))
195 : : {
196 : 0 : gcc_assert (types_compatible_p (TREE_TYPE (op0), TREE_TYPE (op1)));
197 : 0 : gimple_seq stmts = NULL;
198 : 0 : tree type = TREE_TYPE (lhs);
199 : 0 : location_t loc = gimple_location (stmt);
200 : 0 : tree tem0 = gimple_build (&stmts, loc, BIT_AND_EXPR, type, op1, op0);
201 : 0 : tree tem1 = gimple_build (&stmts, loc, BIT_NOT_EXPR, type, op0);
202 : 0 : tree tem2 = gimple_build (&stmts, loc, BIT_AND_EXPR, type, op2, tem1);
203 : 0 : tree tem3 = gimple_build (&stmts, loc, BIT_IOR_EXPR, type, tem0, tem2);
204 : 0 : gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
205 : 0 : return gimple_build_assign (lhs, tem3);
206 : : }
207 : :
208 : 14918 : bool can_compute_op0 = true;
209 : 14918 : gcc_assert (!COMPARISON_CLASS_P (op0));
210 : 14918 : if (TREE_CODE (op0) == SSA_NAME)
211 : : {
212 : 14885 : unsigned int used_vec_cond_exprs = 0;
213 : 14885 : unsigned int *slot = vec_cond_ssa_name_uses->get (op0);
214 : 14885 : if (slot)
215 : 374 : used_vec_cond_exprs = *slot;
216 : : else
217 : : {
218 : 14511 : gimple *use_stmt;
219 : 29876 : FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, op0)
220 : : {
221 : 15365 : gassign *assign = dyn_cast<gassign *> (use_stmt);
222 : 15365 : if (assign != NULL
223 : 15332 : && gimple_assign_rhs_code (assign) == VEC_COND_EXPR
224 : 30250 : && gimple_assign_rhs1 (assign) == op0)
225 : 14885 : used_vec_cond_exprs++;
226 : 14511 : }
227 : 14511 : vec_cond_ssa_name_uses->put (op0, used_vec_cond_exprs);
228 : : }
229 : :
230 : 14885 : gassign *def_stmt = dyn_cast<gassign *> (SSA_NAME_DEF_STMT (op0));
231 : 14885 : if (def_stmt)
232 : : {
233 : 14881 : tcode = gimple_assign_rhs_code (def_stmt);
234 : 14881 : op0a = gimple_assign_rhs1 (def_stmt);
235 : 14881 : op0b = gimple_assign_rhs2 (def_stmt);
236 : :
237 : 14881 : tree op0_type = TREE_TYPE (op0);
238 : 14881 : tree op0a_type = TREE_TYPE (op0a);
239 : 14881 : if (TREE_CODE_CLASS (tcode) == tcc_comparison)
240 : 12351 : can_compute_op0 = expand_vec_cmp_expr_p (op0a_type, op0_type,
241 : : tcode);
242 : :
243 : 12351 : if (can_compute_op0
244 : 14881 : && TYPE_MODE (TREE_TYPE (lhs)) == TYPE_MODE (TREE_TYPE (op0)))
245 : : {
246 : : /* Assuming c = x CMP y. */
247 : 10976 : bool op1_minus_onep = integer_minus_onep (op1);
248 : 10976 : bool op2_zerop = integer_zerop (op2);
249 : 10976 : tree vtype = TREE_TYPE (lhs);
250 : 10976 : machine_mode vmode = TYPE_MODE (vtype);
251 : : /* Try to fold r = c ? -1 : 0 to r = c. */
252 : 10976 : if (op1_minus_onep && op2_zerop)
253 : : {
254 : 2846 : tree conv_op = build1 (VIEW_CONVERT_EXPR, vtype, op0);
255 : 9152 : return gimple_build_assign (lhs, conv_op);
256 : : }
257 : : /* Try to fold r = c ? -1 : z to r = c | z, or
258 : : r = c ? c : z. */
259 : 8130 : if (op1_minus_onep)
260 : : {
261 : 20 : tree conv_op = build1 (VIEW_CONVERT_EXPR, vtype, op0);
262 : 20 : tree new_op1 = make_ssa_name (vtype);
263 : 20 : gassign *new_stmt = gimple_build_assign (new_op1, conv_op);
264 : 20 : gsi_insert_seq_before (gsi, new_stmt, GSI_SAME_STMT);
265 : 20 : if (optab_handler (ior_optab, vmode) != CODE_FOR_nothing)
266 : : /* r = c | z */
267 : 20 : return gimple_build_assign (lhs, BIT_IOR_EXPR, new_op1,
268 : 20 : op2);
269 : : /* r = c ? c : z */
270 : : op1 = new_op1;
271 : : }
272 : : /* Try to fold r = c ? z : 0 to r = c & z, or
273 : : r = c ? z : c. */
274 : 8110 : else if (op2_zerop)
275 : : {
276 : 6286 : tree conv_op = build1 (VIEW_CONVERT_EXPR, vtype, op0);
277 : 6286 : tree new_op2 = make_ssa_name (vtype);
278 : 6286 : gassign *new_stmt = gimple_build_assign (new_op2, conv_op);
279 : 6286 : gsi_insert_seq_before (gsi, new_stmt, GSI_SAME_STMT);
280 : 6286 : if (optab_handler (and_optab, vmode) != CODE_FOR_nothing)
281 : : /* r = c | z */
282 : 6286 : return gimple_build_assign (lhs, BIT_AND_EXPR, new_op2,
283 : 6286 : op1);
284 : : /* r = c ? z : c */
285 : : op2 = new_op2;
286 : : }
287 : 1824 : bool op1_zerop = integer_zerop (op1);
288 : 1824 : bool op2_minus_onep = integer_minus_onep (op2);
289 : : /* Try to fold r = c ? 0 : z to r = .BIT_ANDN (z, c). */
290 : 1824 : if (op1_zerop
291 : 1824 : && (direct_internal_fn_supported_p (IFN_BIT_ANDN, vtype,
292 : : OPTIMIZE_FOR_BOTH)))
293 : : {
294 : 0 : tree conv_op = build1 (VIEW_CONVERT_EXPR, vtype, op0);
295 : 0 : tree new_op = make_ssa_name (vtype);
296 : 0 : gassign *new_stmt = gimple_build_assign (new_op, conv_op);
297 : 0 : gsi_insert_seq_before (gsi, new_stmt, GSI_SAME_STMT);
298 : 0 : return gimple_build_call_internal (IFN_BIT_ANDN, 2, op2,
299 : 0 : new_op);
300 : : }
301 : : /* Try to fold r = c ? z : -1 to r = .BIT_IORN (z, c). */
302 : 1824 : else if (op2_minus_onep
303 : 1824 : && (direct_internal_fn_supported_p (IFN_BIT_IORN, vtype,
304 : : OPTIMIZE_FOR_BOTH)))
305 : : {
306 : 0 : tree conv_op = build1 (VIEW_CONVERT_EXPR, vtype, op0);
307 : 0 : tree new_op = make_ssa_name (vtype);
308 : 0 : gassign *new_stmt = gimple_build_assign (new_op, conv_op);
309 : 0 : gsi_insert_seq_before (gsi, new_stmt, GSI_SAME_STMT);
310 : 0 : return gimple_build_call_internal (IFN_BIT_IORN, 2, op1,
311 : 0 : new_op);
312 : : }
313 : : }
314 : :
315 : : /* When the compare has EH we do not want to forward it when
316 : : it has multiple uses and in general because of the complication
317 : : with EH redirection. */
318 : 5729 : if (stmt_can_throw_internal (fun, def_stmt))
319 : 5 : tcode = TREE_CODE (op0);
320 : :
321 : : /* If we can compute op0 and have multiple uses, keep the SSA
322 : : name and use vcond_mask. */
323 : 5724 : else if (can_compute_op0
324 : 5724 : && used_vec_cond_exprs >= 2
325 : 6389 : && (get_vcond_mask_icode (mode, TYPE_MODE (op0_type))
326 : : != CODE_FOR_nothing))
327 : 665 : tcode = TREE_CODE (op0);
328 : : }
329 : : else
330 : 4 : tcode = TREE_CODE (op0);
331 : : }
332 : : else
333 : 33 : tcode = TREE_CODE (op0);
334 : :
335 : 5766 : if (TREE_CODE_CLASS (tcode) != tcc_comparison)
336 : : {
337 : 1923 : gcc_assert (VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (op0)));
338 : 1923 : if (get_vcond_mask_icode (mode, TYPE_MODE (TREE_TYPE (op0)))
339 : : != CODE_FOR_nothing)
340 : 1923 : return gimple_build_call_internal (IFN_VCOND_MASK, 3, op0, op1, op2);
341 : : /* Fake op0 < 0. */
342 : : else
343 : : {
344 : 0 : gcc_assert (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (op0)))
345 : : == MODE_VECTOR_INT);
346 : 0 : op0a = op0;
347 : 0 : op0b = build_zero_cst (TREE_TYPE (op0));
348 : 0 : tcode = LT_EXPR;
349 : : }
350 : : }
351 : 3843 : cmp_op_mode = TYPE_MODE (TREE_TYPE (op0a));
352 : 3843 : unsignedp = TYPE_UNSIGNED (TREE_TYPE (op0a));
353 : :
354 : 11529 : gcc_assert (known_eq (GET_MODE_NUNITS (mode),
355 : : GET_MODE_NUNITS (cmp_op_mode)));
356 : :
357 : 3843 : icode = get_vcond_icode (mode, cmp_op_mode, unsignedp);
358 : : /* Some targets do not have vcondeq and only vcond with NE/EQ
359 : : but not vcondu, so make sure to also try vcond here as
360 : : vcond_icode_p would canonicalize the optab query to. */
361 : 3843 : if (icode == CODE_FOR_nothing
362 : 3843 : && (tcode == NE_EXPR || tcode == EQ_EXPR)
363 : 5154 : && ((icode = get_vcond_icode (mode, cmp_op_mode, !unsignedp))
364 : : != CODE_FOR_nothing))
365 : : unsignedp = !unsignedp;
366 : 3843 : if (icode == CODE_FOR_nothing)
367 : : {
368 : 3843 : if (tcode == LT_EXPR
369 : 867 : && op0a == op0)
370 : : {
371 : : /* A VEC_COND_EXPR condition could be folded from EQ_EXPR/NE_EXPR
372 : : into a constant when only get_vcond_eq_icode is supported.
373 : : Try changing it to NE_EXPR. */
374 : 0 : tcode = NE_EXPR;
375 : : }
376 : 3843 : if ((tcode == EQ_EXPR || tcode == NE_EXPR)
377 : 5154 : && direct_internal_fn_supported_p (IFN_VCONDEQ, TREE_TYPE (lhs),
378 : 1311 : TREE_TYPE (op0a),
379 : : OPTIMIZE_FOR_BOTH))
380 : : {
381 : 0 : tree tcode_tree = build_int_cst (integer_type_node, tcode);
382 : 0 : return gimple_build_call_internal (IFN_VCONDEQ, 5, op0a, op0b, op1,
383 : 0 : op2, tcode_tree);
384 : : }
385 : :
386 : 3843 : gcc_assert (VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (op0))
387 : : && can_compute_op0
388 : : && (get_vcond_mask_icode (mode, TYPE_MODE (TREE_TYPE (op0)))
389 : : != CODE_FOR_nothing));
390 : 3843 : return gimple_build_call_internal (IFN_VCOND_MASK, 3, op0, op1, op2);
391 : : }
392 : :
393 : 0 : tree tcode_tree = build_int_cst (integer_type_node, tcode);
394 : 0 : return gimple_build_call_internal (unsignedp ? IFN_VCONDU : IFN_VCOND,
395 : 0 : 5, op0a, op0b, op1, op2, tcode_tree);
396 : : }
397 : :
398 : : /* Duplicate COND_EXPR condition defs of STMT located in BB when they are
399 : : comparisons so RTL expansion with the help of TER
400 : : can perform better if conversion. */
401 : : static void
402 : 490952 : maybe_duplicate_comparison (gassign *stmt, basic_block bb)
403 : : {
404 : 490952 : imm_use_iterator imm_iter;
405 : 490952 : use_operand_p use_p;
406 : 490952 : auto_vec<gassign *, 4> cond_exprs;
407 : 490952 : tree lhs = gimple_assign_lhs (stmt);
408 : 490952 : unsigned cnt = 0;
409 : :
410 : : /* This is should not be used for -O0 nor it is not useful
411 : : when ter is turned off. */
412 : 490952 : if (!optimize || !flag_tree_ter)
413 : : return;
414 : :
415 : 788762 : FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
416 : : {
417 : 405900 : if (is_gimple_debug (USE_STMT (use_p)))
418 : 10053 : continue;
419 : 395847 : cnt++;
420 : : /* Add the use statement if it was a cond_expr. */
421 : 395847 : if (gimple_bb (USE_STMT (use_p)) == bb
422 : 354514 : && is_gimple_assign (USE_STMT (use_p))
423 : 337109 : && gimple_assign_rhs_code (USE_STMT (use_p)) == COND_EXPR
424 : 405939 : && gimple_assign_rhs1_ptr (USE_STMT (use_p)) == use_p->use)
425 : 9702 : cond_exprs.safe_push (as_a <gassign *> (USE_STMT (use_p)));
426 : : }
427 : :
428 : : /* If the comparison has 0 or 1 uses, no reason to do anything. */
429 : 382862 : if (cnt <= 1)
430 : : return;
431 : :
432 : : /* If we only use the expression inside cond_exprs in that BB, we don't
433 : : need to duplicate for one of them so pop the top. */
434 : 18974 : if (cond_exprs.length () == cnt)
435 : 132 : cond_exprs.pop();
436 : :
437 : 19343 : while (!cond_exprs.is_empty())
438 : : {
439 : 369 : auto old_top = cond_exprs.pop();
440 : 369 : gassign *copy = as_a <gassign *> (gimple_copy (stmt));
441 : 369 : tree new_def = duplicate_ssa_name (lhs, copy);
442 : 369 : gimple_assign_set_lhs (copy, new_def);
443 : 369 : auto gsi2 = gsi_for_stmt (old_top);
444 : 369 : gsi_insert_before (&gsi2, copy, GSI_SAME_STMT);
445 : 369 : gimple_assign_set_rhs1 (old_top, new_def);
446 : 369 : update_stmt (old_top);
447 : : }
448 : 490952 : }
449 : :
450 : :
451 : : namespace {
452 : :
453 : : const pass_data pass_data_gimple_isel =
454 : : {
455 : : GIMPLE_PASS, /* type */
456 : : "isel", /* name */
457 : : OPTGROUP_VEC, /* optinfo_flags */
458 : : TV_NONE, /* tv_id */
459 : : PROP_cfg, /* properties_required */
460 : : 0, /* properties_provided */
461 : : 0, /* properties_destroyed */
462 : : 0, /* todo_flags_start */
463 : : TODO_update_ssa, /* todo_flags_finish */
464 : : };
465 : :
466 : : class pass_gimple_isel : public gimple_opt_pass
467 : : {
468 : : public:
469 : 273196 : pass_gimple_isel (gcc::context *ctxt)
470 : 546392 : : gimple_opt_pass (pass_data_gimple_isel, ctxt)
471 : : {}
472 : :
473 : : /* opt_pass methods: */
474 : 1422113 : bool gate (function *) final override
475 : : {
476 : 1422113 : return true;
477 : : }
478 : :
479 : : unsigned int execute (function *fun) final override;
480 : : }; // class pass_gimple_isel
481 : :
482 : :
483 : : /* Iterate all gimple statements and perform pre RTL expansion
484 : : GIMPLE massaging to improve instruction selection. */
485 : :
486 : : unsigned int
487 : 1422108 : pass_gimple_isel::execute (struct function *fun)
488 : : {
489 : 1422108 : gimple_stmt_iterator gsi;
490 : 1422108 : basic_block bb;
491 : 1422108 : hash_map<tree, unsigned int> vec_cond_ssa_name_uses;
492 : 1422108 : auto_bitmap dce_ssa_names;
493 : 1422108 : bool cfg_changed = false;
494 : :
495 : 15823333 : FOR_EACH_BB_FN (bb, fun)
496 : : {
497 : 112555834 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
498 : : {
499 : : /* Pre-expand VEC_COND_EXPRs to .VCOND* internal function
500 : : calls mapping to supported optabs. */
501 : 83753384 : gimple *g = gimple_expand_vec_cond_expr (fun, &gsi,
502 : : &vec_cond_ssa_name_uses);
503 : 83753384 : if (g != NULL)
504 : : {
505 : 14918 : tree lhs = gimple_assign_lhs (gsi_stmt (gsi));
506 : 14918 : gimple_set_lhs (g, lhs);
507 : 14918 : gsi_replace (&gsi, g, false);
508 : : }
509 : :
510 : : /* Recognize .VEC_SET and .VEC_EXTRACT patterns. */
511 : 83753384 : cfg_changed |= gimple_expand_vec_set_extract_expr (fun, &gsi);
512 : 83753384 : if (gsi_end_p (gsi))
513 : : break;
514 : :
515 : 83753384 : gassign *stmt = dyn_cast <gassign *> (*gsi);
516 : 83753384 : if (!stmt)
517 : 54003764 : continue;
518 : :
519 : 29749620 : tree_code code = gimple_assign_rhs_code (stmt);
520 : 29749620 : if (TREE_CODE_CLASS (code) == tcc_comparison)
521 : 490952 : maybe_duplicate_comparison (stmt, bb);
522 : : }
523 : : }
524 : :
525 : 1436619 : for (auto it = vec_cond_ssa_name_uses.begin ();
526 : 1451130 : it != vec_cond_ssa_name_uses.end (); ++it)
527 : 14511 : bitmap_set_bit (dce_ssa_names, SSA_NAME_VERSION ((*it).first));
528 : :
529 : 1422108 : simple_dce_from_worklist (dce_ssa_names);
530 : :
531 : 2844216 : return cfg_changed ? TODO_cleanup_cfg : 0;
532 : 1422108 : }
533 : :
534 : : } // anon namespace
535 : :
536 : : gimple_opt_pass *
537 : 273196 : make_pass_gimple_isel (gcc::context *ctxt)
538 : : {
539 : 273196 : return new pass_gimple_isel (ctxt);
540 : : }
541 : :
|
