Line data Source code
1 : /* Target-dependent costs for expmed.cc.
2 : Copyright (C) 1987-2026 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 under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : 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 : #ifndef EXPMED_H
21 : #define EXPMED_H 1
22 :
23 : #include "insn-codes.h"
24 :
25 : enum alg_code {
26 : alg_unknown,
27 : alg_zero,
28 : alg_m, alg_shift,
29 : alg_add_t_m2,
30 : alg_sub_t_m2,
31 : alg_add_factor,
32 : alg_sub_factor,
33 : alg_add_t2_m,
34 : alg_sub_t2_m,
35 : alg_impossible
36 : };
37 :
38 : /* Indicates the type of fixup needed after a constant multiplication.
39 : BASIC_VARIANT means no fixup is needed, NEGATE_VARIANT means that
40 : the result should be negated, and ADD_VARIANT means that the
41 : multiplicand should be added to the result. */
42 : enum mult_variant {basic_variant, negate_variant, add_variant};
43 :
44 : bool choose_mult_variant (machine_mode, HOST_WIDE_INT,
45 : struct algorithm *, enum mult_variant *, int);
46 :
47 : /* This structure holds the "cost" of a multiply sequence. The
48 : "cost" field holds the total rtx_cost of every operator in the
49 : synthetic multiplication sequence, hence cost(a op b) is defined
50 : as rtx_cost(op) + cost(a) + cost(b), where cost(leaf) is zero.
51 : The "latency" field holds the minimum possible latency of the
52 : synthetic multiply, on a hypothetical infinitely parallel CPU.
53 : This is the critical path, or the maximum height, of the expression
54 : tree which is the sum of rtx_costs on the most expensive path from
55 : any leaf to the root. Hence latency(a op b) is defined as zero for
56 : leaves and rtx_cost(op) + max(latency(a), latency(b)) otherwise. */
57 :
58 : struct mult_cost {
59 : short cost; /* Total rtx_cost of the multiplication sequence. */
60 : short latency; /* The latency of the multiplication sequence. */
61 : };
62 :
63 : /* This macro is used to compare a pointer to a mult_cost against an
64 : single integer "rtx_cost" value. This is equivalent to the macro
65 : CHEAPER_MULT_COST(X,Z) where Z = {Y,Y}. */
66 : #define MULT_COST_LESS(X,Y) ((X)->cost < (Y) \
67 : || ((X)->cost == (Y) && (X)->latency < (Y)))
68 :
69 : /* This macro is used to compare two pointers to mult_costs against
70 : each other. The macro returns true if X is cheaper than Y.
71 : Currently, the cheaper of two mult_costs is the one with the
72 : lower "cost". If "cost"s are tied, the lower latency is cheaper. */
73 : #define CHEAPER_MULT_COST(X,Y) ((X)->cost < (Y)->cost \
74 : || ((X)->cost == (Y)->cost \
75 : && (X)->latency < (Y)->latency))
76 :
77 : /* This structure records a sequence of operations.
78 : `ops' is the number of operations recorded.
79 : `cost' is their total cost.
80 : The operations are stored in `op' and the corresponding
81 : logarithms of the integer coefficients in `log'.
82 :
83 : These are the operations:
84 : alg_zero total := 0;
85 : alg_m total := multiplicand;
86 : alg_shift total := total * coeff
87 : alg_add_t_m2 total := total + multiplicand * coeff;
88 : alg_sub_t_m2 total := total - multiplicand * coeff;
89 : alg_add_factor total := total * coeff + total;
90 : alg_sub_factor total := total * coeff - total;
91 : alg_add_t2_m total := total * coeff + multiplicand;
92 : alg_sub_t2_m total := total * coeff - multiplicand;
93 :
94 : The first operand must be either alg_zero or alg_m. */
95 :
96 : struct algorithm
97 : {
98 : struct mult_cost cost;
99 : short ops;
100 : /* The size of the OP and LOG fields are not directly related to the
101 : word size, but the worst-case algorithms will be if we have few
102 : consecutive ones or zeros, i.e., a multiplicand like 10101010101...
103 : In that case we will generate shift-by-2, add, shift-by-2, add,...,
104 : in total wordsize operations. */
105 : enum alg_code op[MAX_BITS_PER_WORD];
106 : char log[MAX_BITS_PER_WORD];
107 : };
108 :
109 : /* The entry for our multiplication cache/hash table. */
110 : struct alg_hash_entry {
111 : /* The number we are multiplying by. */
112 : unsigned HOST_WIDE_INT t;
113 :
114 : /* The mode in which we are multiplying something by T. */
115 : machine_mode mode;
116 :
117 : /* The best multiplication algorithm for t. */
118 : enum alg_code alg;
119 :
120 : /* The cost of multiplication if ALG_CODE is not alg_impossible.
121 : Otherwise, the cost within which multiplication by T is
122 : impossible. */
123 : struct mult_cost cost;
124 :
125 : /* Optimized for speed? */
126 : bool speed;
127 : };
128 :
129 : /* The number of cache/hash entries. */
130 : #if HOST_BITS_PER_WIDE_INT == 64
131 : #define NUM_ALG_HASH_ENTRIES 1031
132 : #else
133 : #define NUM_ALG_HASH_ENTRIES 307
134 : #endif
135 :
136 : #define NUM_MODE_IP_INT (NUM_MODE_INT + NUM_MODE_PARTIAL_INT)
137 : #define NUM_MODE_IPV_INT (NUM_MODE_IP_INT + NUM_MODE_VECTOR_INT)
138 :
139 : struct expmed_op_cheap {
140 : bool cheap[2][NUM_MODE_IPV_INT];
141 : };
142 :
143 : struct expmed_op_costs {
144 : int cost[2][NUM_MODE_IPV_INT];
145 : };
146 :
147 : /* Target-dependent globals. */
148 : struct target_expmed {
149 : /* Each entry of ALG_HASH caches alg_code for some integer. This is
150 : actually a hash table. If we have a collision, that the older
151 : entry is kicked out. */
152 : struct alg_hash_entry x_alg_hash[NUM_ALG_HASH_ENTRIES];
153 :
154 : /* True if x_alg_hash might already have been used. */
155 : bool x_alg_hash_used_p;
156 :
157 : /* Nonzero means divides or modulus operations are relatively cheap for
158 : powers of two, so don't use branches; emit the operation instead.
159 : Usually, this will mean that the MD file will emit non-branch
160 : sequences. */
161 : struct expmed_op_cheap x_sdiv_pow2_cheap;
162 : struct expmed_op_cheap x_smod_pow2_cheap;
163 :
164 : /* Cost of various pieces of RTL. */
165 : int x_zero_cost[2];
166 : struct expmed_op_costs x_add_cost;
167 : struct expmed_op_costs x_neg_cost;
168 : int x_shift_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD];
169 : int x_shiftadd_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD];
170 : int x_shiftsub0_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD];
171 : int x_shiftsub1_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD];
172 : struct expmed_op_costs x_mul_cost;
173 : struct expmed_op_costs x_sdiv_cost;
174 : struct expmed_op_costs x_udiv_cost;
175 : int x_mul_widen_cost[2][NUM_MODE_INT];
176 : int x_mul_highpart_cost[2][NUM_MODE_INT];
177 :
178 : /* Conversion costs are only defined between two scalar integer modes
179 : of different sizes. The first machine mode is the destination mode,
180 : and the second is the source mode. */
181 : int x_convert_cost[2][NUM_MODE_IP_INT][NUM_MODE_IP_INT];
182 : };
183 :
184 : extern struct target_expmed default_target_expmed;
185 : #if SWITCHABLE_TARGET
186 : extern struct target_expmed *this_target_expmed;
187 : #else
188 : #define this_target_expmed (&default_target_expmed)
189 : #endif
190 :
191 : /* Return a pointer to the alg_hash_entry at IDX. */
192 :
193 : inline struct alg_hash_entry *
194 17523195 : alg_hash_entry_ptr (int idx)
195 : {
196 17523195 : return &this_target_expmed->x_alg_hash[idx];
197 : }
198 :
199 : /* Return true if the x_alg_hash field might have been used. */
200 :
201 : inline bool
202 213440 : alg_hash_used_p (void)
203 : {
204 213440 : return this_target_expmed->x_alg_hash_used_p;
205 : }
206 :
207 : /* Set whether the x_alg_hash field might have been used. */
208 :
209 : inline void
210 212397 : set_alg_hash_used_p (bool usedp)
211 : {
212 212397 : this_target_expmed->x_alg_hash_used_p = usedp;
213 212397 : }
214 :
215 : /* Compute an index into the cost arrays by mode class. */
216 :
217 : inline int
218 2590613431 : expmed_mode_index (machine_mode mode)
219 : {
220 2590613431 : switch (GET_MODE_CLASS (mode))
221 : {
222 656955463 : case MODE_INT:
223 656955463 : return mode - MIN_MODE_INT;
224 209171200 : case MODE_PARTIAL_INT:
225 : /* If there are no partial integer modes, help the compiler
226 : to figure out this will never happen. See PR59934. */
227 209171200 : if (MIN_MODE_PARTIAL_INT != VOIDmode)
228 209171200 : return mode - MIN_MODE_PARTIAL_INT + NUM_MODE_INT;
229 : break;
230 1724486768 : case MODE_VECTOR_INT:
231 : /* If there are no vector integer modes, help the compiler
232 : to figure out this will never happen. See PR59934. */
233 1724486768 : if (MIN_MODE_VECTOR_INT != VOIDmode)
234 1724486768 : return mode - MIN_MODE_VECTOR_INT + NUM_MODE_IP_INT;
235 : break;
236 0 : default:
237 0 : break;
238 : }
239 0 : gcc_unreachable ();
240 : }
241 :
242 : /* Return a pointer to a boolean contained in EOC indicating whether
243 : a particular operation performed in MODE is cheap when optimizing
244 : for SPEED. */
245 :
246 : inline bool *
247 35027060 : expmed_op_cheap_ptr (struct expmed_op_cheap *eoc, bool speed,
248 : machine_mode mode)
249 : {
250 35049960 : int idx = expmed_mode_index (mode);
251 35027060 : return &eoc->cheap[speed][idx];
252 : }
253 :
254 : /* Return a pointer to a cost contained in COSTS when a particular
255 : operation is performed in MODE when optimizing for SPEED. */
256 :
257 : inline int *
258 188300637 : expmed_op_cost_ptr (struct expmed_op_costs *costs, bool speed,
259 : machine_mode mode)
260 : {
261 212782053 : int idx = expmed_mode_index (mode);
262 188244072 : return &costs->cost[speed][idx];
263 : }
264 :
265 : /* Subroutine of {set_,}sdiv_pow2_cheap. Not to be used otherwise. */
266 :
267 : inline bool *
268 17522297 : sdiv_pow2_cheap_ptr (bool speed, machine_mode mode)
269 : {
270 17542514 : return expmed_op_cheap_ptr (&this_target_expmed->x_sdiv_pow2_cheap,
271 : speed, mode);
272 : }
273 :
274 : /* Set whether a signed division by a power of 2 is cheap in MODE
275 : when optimizing for SPEED. */
276 :
277 : inline void
278 17502080 : set_sdiv_pow2_cheap (bool speed, machine_mode mode, bool cheap_p)
279 : {
280 17502080 : *sdiv_pow2_cheap_ptr (speed, mode) = cheap_p;
281 : }
282 :
283 : /* Return whether a signed division by a power of 2 is cheap in MODE
284 : when optimizing for SPEED. */
285 :
286 : inline bool
287 20217 : sdiv_pow2_cheap (bool speed, machine_mode mode)
288 : {
289 20217 : return *sdiv_pow2_cheap_ptr (speed, mode);
290 : }
291 :
292 : /* Subroutine of {set_,}smod_pow2_cheap. Not to be used otherwise. */
293 :
294 : inline bool *
295 17504763 : smod_pow2_cheap_ptr (bool speed, machine_mode mode)
296 : {
297 17507446 : return expmed_op_cheap_ptr (&this_target_expmed->x_smod_pow2_cheap,
298 : speed, mode);
299 : }
300 :
301 : /* Set whether a signed modulo by a power of 2 is CHEAP in MODE when
302 : optimizing for SPEED. */
303 :
304 : inline void
305 17502080 : set_smod_pow2_cheap (bool speed, machine_mode mode, bool cheap)
306 : {
307 17502080 : *smod_pow2_cheap_ptr (speed, mode) = cheap;
308 : }
309 :
310 : /* Return whether a signed modulo by a power of 2 is cheap in MODE
311 : when optimizing for SPEED. */
312 :
313 : inline bool
314 2683 : smod_pow2_cheap (bool speed, machine_mode mode)
315 : {
316 2683 : return *smod_pow2_cheap_ptr (speed, mode);
317 : }
318 :
319 : /* Subroutine of {set_,}zero_cost. Not to be used otherwise. */
320 :
321 : inline int *
322 983110 : zero_cost_ptr (bool speed)
323 : {
324 983110 : return &this_target_expmed->x_zero_cost[speed];
325 : }
326 :
327 : /* Set the COST of loading zero when optimizing for SPEED. */
328 :
329 : inline void
330 426880 : set_zero_cost (bool speed, int cost)
331 : {
332 426880 : *zero_cost_ptr (speed) = cost;
333 : }
334 :
335 : /* Return the COST of loading zero when optimizing for SPEED. */
336 :
337 : inline int
338 556230 : zero_cost (bool speed)
339 : {
340 556230 : return *zero_cost_ptr (speed);
341 : }
342 :
343 : /* Subroutine of {set_,}add_cost. Not to be used otherwise. */
344 :
345 : inline int *
346 115287641 : add_cost_ptr (bool speed, machine_mode mode)
347 : {
348 230391210 : return expmed_op_cost_ptr (&this_target_expmed->x_add_cost, speed, mode);
349 : }
350 :
351 : /* Set the COST of computing an add in MODE when optimizing for SPEED. */
352 :
353 : inline void
354 17502080 : set_add_cost (bool speed, machine_mode mode, int cost)
355 : {
356 17502080 : *add_cost_ptr (speed, mode) = cost;
357 : }
358 :
359 : /* Return the cost of computing an add in MODE when optimizing for SPEED. */
360 :
361 : inline int
362 97785561 : add_cost (bool speed, machine_mode mode)
363 : {
364 62781401 : return *add_cost_ptr (speed, mode);
365 : }
366 :
367 : /* Subroutine of {set_,}neg_cost. Not to be used otherwise. */
368 :
369 : inline int *
370 20133662 : neg_cost_ptr (bool speed, machine_mode mode)
371 : {
372 40262762 : return expmed_op_cost_ptr (&this_target_expmed->x_neg_cost, speed, mode);
373 : }
374 :
375 : /* Set the COST of computing a negation in MODE when optimizing for SPEED. */
376 :
377 : inline void
378 17502080 : set_neg_cost (bool speed, machine_mode mode, int cost)
379 : {
380 17502080 : *neg_cost_ptr (speed, mode) = cost;
381 : }
382 :
383 : /* Return the cost of computing a negation in MODE when optimizing for
384 : SPEED. */
385 :
386 : inline int
387 2631582 : neg_cost (bool speed, machine_mode mode)
388 : {
389 2631582 : return *neg_cost_ptr (speed, mode);
390 : }
391 :
392 : /* Subroutine of {set_,}shift_cost. Not to be used otherwise. */
393 :
394 : inline int *
395 599360559 : shift_cost_ptr (bool speed, machine_mode mode, int bits)
396 : {
397 1170129267 : int midx = expmed_mode_index (mode);
398 599313521 : return &this_target_expmed->x_shift_cost[speed][midx][bits];
399 : }
400 :
401 : /* Set the COST of doing a shift in MODE by BITS when optimizing for SPEED. */
402 :
403 : inline void
404 587386880 : set_shift_cost (bool speed, machine_mode mode, int bits, int cost)
405 : {
406 587386880 : *shift_cost_ptr (speed, mode, bits) = cost;
407 : }
408 :
409 : /* Return the cost of doing a shift in MODE by BITS when optimizing for
410 : SPEED. */
411 :
412 : inline int
413 1003652 : shift_cost (bool speed, machine_mode mode, int bits)
414 : {
415 11926641 : return *shift_cost_ptr (speed, mode, bits);
416 : }
417 :
418 : /* Subroutine of {set_,}shiftadd_cost. Not to be used otherwise. */
419 :
420 : inline int *
421 592408661 : shiftadd_cost_ptr (bool speed, machine_mode mode, int bits)
422 : {
423 1165525269 : int midx = expmed_mode_index (mode);
424 592408661 : return &this_target_expmed->x_shiftadd_cost[speed][midx][bits];
425 : }
426 :
427 : /* Set the COST of doing a shift in MODE by BITS followed by an add when
428 : optimizing for SPEED. */
429 :
430 : inline void
431 587386880 : set_shiftadd_cost (bool speed, machine_mode mode, int bits, int cost)
432 : {
433 587386880 : *shiftadd_cost_ptr (speed, mode, bits) = cost;
434 : }
435 :
436 : /* Return the cost of doing a shift in MODE by BITS followed by an add
437 : when optimizing for SPEED. */
438 :
439 : inline int
440 5021781 : shiftadd_cost (bool speed, machine_mode mode, int bits)
441 : {
442 5021781 : return *shiftadd_cost_ptr (speed, mode, bits);
443 : }
444 :
445 : /* Subroutine of {set_,}shiftsub0_cost. Not to be used otherwise. */
446 :
447 : inline int *
448 590343491 : shiftsub0_cost_ptr (bool speed, machine_mode mode, int bits)
449 : {
450 1162094275 : int midx = expmed_mode_index (mode);
451 590343491 : return &this_target_expmed->x_shiftsub0_cost[speed][midx][bits];
452 : }
453 :
454 : /* Set the COST of doing a shift in MODE by BITS and then subtracting a
455 : value when optimizing for SPEED. */
456 :
457 : inline void
458 587386880 : set_shiftsub0_cost (bool speed, machine_mode mode, int bits, int cost)
459 : {
460 587386880 : *shiftsub0_cost_ptr (speed, mode, bits) = cost;
461 : }
462 :
463 : /* Return the cost of doing a shift in MODE by BITS and then subtracting
464 : a value when optimizing for SPEED. */
465 :
466 : inline int
467 2956611 : shiftsub0_cost (bool speed, machine_mode mode, int bits)
468 : {
469 2956611 : return *shiftsub0_cost_ptr (speed, mode, bits);
470 : }
471 :
472 : /* Subroutine of {set_,}shiftsub1_cost. Not to be used otherwise. */
473 :
474 : inline int *
475 588268141 : shiftsub1_cost_ptr (bool speed, machine_mode mode, int bits)
476 : {
477 1158152941 : int midx = expmed_mode_index (mode);
478 588268141 : return &this_target_expmed->x_shiftsub1_cost[speed][midx][bits];
479 : }
480 :
481 : /* Set the COST of subtracting a shift in MODE by BITS from a value when
482 : optimizing for SPEED. */
483 :
484 : inline void
485 587386880 : set_shiftsub1_cost (bool speed, machine_mode mode, int bits, int cost)
486 : {
487 587386880 : *shiftsub1_cost_ptr (speed, mode, bits) = cost;
488 : }
489 :
490 : /* Return the cost of subtracting a shift in MODE by BITS from a value
491 : when optimizing for SPEED. */
492 :
493 : inline int
494 881261 : shiftsub1_cost (bool speed, machine_mode mode, int bits)
495 : {
496 881261 : return *shiftsub1_cost_ptr (speed, mode, bits);
497 : }
498 :
499 : /* Subroutine of {set_,}mul_cost. Not to be used otherwise. */
500 :
501 : inline int *
502 17646513 : mul_cost_ptr (bool speed, machine_mode mode)
503 : {
504 35292351 : return expmed_op_cost_ptr (&this_target_expmed->x_mul_cost, speed, mode);
505 : }
506 :
507 : /* Set the COST of doing a multiplication in MODE when optimizing for
508 : SPEED. */
509 :
510 : inline void
511 17502080 : set_mul_cost (bool speed, machine_mode mode, int cost)
512 : {
513 17502080 : *mul_cost_ptr (speed, mode) = cost;
514 : }
515 :
516 : /* Return the cost of doing a multiplication in MODE when optimizing
517 : for SPEED. */
518 :
519 : inline int
520 144433 : mul_cost (bool speed, machine_mode mode)
521 : {
522 144433 : return *mul_cost_ptr (speed, mode);
523 : }
524 :
525 : /* Subroutine of {set_,}sdiv_cost. Not to be used otherwise. */
526 :
527 : inline int *
528 17621815 : sdiv_cost_ptr (bool speed, machine_mode mode)
529 : {
530 35243630 : return expmed_op_cost_ptr (&this_target_expmed->x_sdiv_cost, speed, mode);
531 : }
532 :
533 : /* Set the COST of doing a signed division in MODE when optimizing
534 : for SPEED. */
535 :
536 : inline void
537 17502080 : set_sdiv_cost (bool speed, machine_mode mode, int cost)
538 : {
539 17502080 : *sdiv_cost_ptr (speed, mode) = cost;
540 : }
541 :
542 : /* Return the cost of doing a signed division in MODE when optimizing
543 : for SPEED. */
544 :
545 : inline int
546 119735 : sdiv_cost (bool speed, machine_mode mode)
547 : {
548 119735 : return *sdiv_cost_ptr (speed, mode);
549 : }
550 :
551 : /* Subroutine of {set_,}udiv_cost. Not to be used otherwise. */
552 :
553 : inline int *
554 17611006 : udiv_cost_ptr (bool speed, machine_mode mode)
555 : {
556 35222012 : return expmed_op_cost_ptr (&this_target_expmed->x_udiv_cost, speed, mode);
557 : }
558 :
559 : /* Set the COST of doing an unsigned division in MODE when optimizing
560 : for SPEED. */
561 :
562 : inline void
563 17502080 : set_udiv_cost (bool speed, machine_mode mode, int cost)
564 : {
565 17502080 : *udiv_cost_ptr (speed, mode) = cost;
566 : }
567 :
568 : /* Return the cost of doing an unsigned division in MODE when
569 : optimizing for SPEED. */
570 :
571 : inline int
572 108926 : udiv_cost (bool speed, machine_mode mode)
573 : {
574 108926 : return *udiv_cost_ptr (speed, mode);
575 : }
576 :
577 : /* Subroutine of {set_,}mul_widen_cost. Not to be used otherwise. */
578 :
579 : inline int *
580 2565217 : mul_widen_cost_ptr (bool speed, machine_mode mode)
581 : {
582 2565217 : gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
583 :
584 2565217 : return &this_target_expmed->x_mul_widen_cost[speed][mode - MIN_MODE_INT];
585 : }
586 :
587 : /* Set the COST for computing a widening multiplication in MODE when
588 : optimizing for SPEED. */
589 :
590 : inline void
591 2561280 : set_mul_widen_cost (bool speed, machine_mode mode, int cost)
592 : {
593 2561280 : *mul_widen_cost_ptr (speed, mode) = cost;
594 : }
595 :
596 : /* Return the cost for computing a widening multiplication in MODE when
597 : optimizing for SPEED. */
598 :
599 : inline int
600 3937 : mul_widen_cost (bool speed, machine_mode mode)
601 : {
602 3937 : return *mul_widen_cost_ptr (speed, mode);
603 : }
604 :
605 : /* Subroutine of {set_,}mul_highpart_cost. Not to be used otherwise. */
606 :
607 : inline int *
608 2631216 : mul_highpart_cost_ptr (bool speed, machine_mode mode)
609 : {
610 2631216 : gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
611 2631216 : int m = mode - MIN_MODE_INT;
612 2631216 : gcc_assert (m < NUM_MODE_INT);
613 :
614 2631216 : return &this_target_expmed->x_mul_highpart_cost[speed][m];
615 : }
616 :
617 : /* Set the COST for computing the high part of a multiplication in MODE
618 : when optimizing for SPEED. */
619 :
620 : inline void
621 2561280 : set_mul_highpart_cost (bool speed, machine_mode mode, int cost)
622 : {
623 2561280 : *mul_highpart_cost_ptr (speed, mode) = cost;
624 2561280 : }
625 :
626 : /* Return the cost for computing the high part of a multiplication in MODE
627 : when optimizing for SPEED. */
628 :
629 : inline int
630 69936 : mul_highpart_cost (bool speed, machine_mode mode)
631 : {
632 69936 : return *mul_highpart_cost_ptr (speed, mode);
633 : }
634 :
635 : /* Subroutine of {set_,}convert_cost. Not to be used otherwise. */
636 :
637 : inline int *
638 32569687 : convert_cost_ptr (machine_mode to_mode, machine_mode from_mode,
639 : bool speed)
640 : {
641 32569687 : int to_idx = expmed_mode_index (to_mode);
642 32569687 : int from_idx = expmed_mode_index (from_mode);
643 :
644 32569687 : gcc_assert (IN_RANGE (to_idx, 0, NUM_MODE_IP_INT - 1));
645 32569687 : gcc_assert (IN_RANGE (from_idx, 0, NUM_MODE_IP_INT - 1));
646 :
647 32569687 : return &this_target_expmed->x_convert_cost[speed][to_idx][from_idx];
648 : }
649 :
650 : /* Set the COST for converting from FROM_MODE to TO_MODE when optimizing
651 : for SPEED. */
652 :
653 : inline void
654 29881600 : set_convert_cost (machine_mode to_mode, machine_mode from_mode,
655 : bool speed, int cost)
656 : {
657 29881600 : *convert_cost_ptr (to_mode, from_mode, speed) = cost;
658 : }
659 :
660 : /* Return the cost for converting from FROM_MODE to TO_MODE when optimizing
661 : for SPEED. */
662 :
663 : inline int
664 2688087 : convert_cost (machine_mode to_mode, machine_mode from_mode,
665 : bool speed)
666 : {
667 2688087 : return *convert_cost_ptr (to_mode, from_mode, speed);
668 : }
669 :
670 : extern int mult_by_coeff_cost (HOST_WIDE_INT, machine_mode, bool);
671 : extern rtx emit_cstore (rtx target, enum insn_code icode, enum rtx_code code,
672 : machine_mode mode, machine_mode compare_mode,
673 : int unsignedp, rtx x, rtx y, int normalizep,
674 : machine_mode target_mode);
675 :
676 : /* Arguments MODE, RTX: return an rtx for the negation of that value.
677 : May emit insns. */
678 : extern rtx negate_rtx (machine_mode, rtx);
679 :
680 : /* Arguments MODE, RTX: return an rtx for the flipping of that value.
681 : May emit insns. */
682 : extern rtx flip_storage_order (machine_mode, rtx);
683 :
684 : /* Expand a logical AND operation. */
685 : extern rtx expand_and (machine_mode, rtx, rtx, rtx);
686 :
687 : /* Emit a store-flag operation. */
688 : extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, machine_mode,
689 : int, int);
690 :
691 : /* Like emit_store_flag, but always succeeds. */
692 : extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx,
693 : machine_mode, int, int);
694 :
695 : extern void canonicalize_comparison (machine_mode, enum rtx_code *, rtx *);
696 :
697 : /* Choose a minimal N + 1 bit approximation to 2**K / D that can be used to
698 : replace division by D, put the least significant N bits of the result in
699 : *MULTIPLIER_PTR, the value K - N in *POST_SHIFT_PTR, and return the most
700 : significant bit. */
701 : extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int,
702 : int, unsigned HOST_WIDE_INT *,
703 : int *);
704 :
705 : #ifdef TREE_CODE
706 : extern rtx expand_variable_shift (enum tree_code, machine_mode,
707 : rtx, tree, rtx, int);
708 : extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rtx,
709 : int);
710 : extern rtx maybe_expand_shift (enum tree_code, machine_mode, rtx, int, rtx,
711 : int);
712 : #ifdef GCC_OPTABS_H
713 : extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx,
714 : rtx, int, enum optab_methods = OPTAB_LIB_WIDEN);
715 : #endif
716 : #endif
717 :
718 : extern void store_bit_field (rtx, poly_uint64, poly_uint64,
719 : poly_uint64, poly_uint64,
720 : machine_mode, rtx, bool, bool);
721 : extern rtx extract_bit_field (rtx, poly_uint64, poly_uint64, int, rtx,
722 : machine_mode, machine_mode, bool, rtx *);
723 : extern rtx extract_low_bits (machine_mode, machine_mode, rtx);
724 : extern rtx expand_mult (machine_mode, rtx, rtx, rtx, int, bool = false);
725 : extern rtx expand_mult_highpart_adjust (scalar_int_mode, rtx, rtx, rtx,
726 : rtx, int);
727 : extern rtx expmed_mult_highpart_optab (scalar_int_mode, rtx, rtx, rtx,
728 : int, int);
729 : extern rtx expand_rotate_as_vec_perm (machine_mode, rtx, rtx, rtx);
730 :
731 : #endif // EXPMED_H
|
