GCC Middle and Back End API Reference
expmed.h
Go to the documentation of this file.
1/* Target-dependent costs for expmed.cc.
2 Copyright (C) 1987-2024 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along 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
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. */
43
44bool 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
58struct 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
97{
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. */
107};
108
109/* The entry for our multiplication cache/hash table. */
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. */
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. */
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
142
146
147/* Target-dependent globals. */
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. */
153
154 /* True if x_alg_hash might already have been used. */
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. */
163
164 /* Cost of various pieces of RTL. */
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. */
182};
183
185#if SWITCHABLE_TARGET
186extern 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
193inline struct alg_hash_entry *
195{
196 return &this_target_expmed->x_alg_hash[idx];
197}
198
199/* Return true if the x_alg_hash field might have been used. */
200
201inline bool
203{
204 return this_target_expmed->x_alg_hash_used_p;
205}
206
207/* Set whether the x_alg_hash field might have been used. */
208
209inline void
211{
212 this_target_expmed->x_alg_hash_used_p = usedp;
213}
214
215/* Compute an index into the cost arrays by mode class. */
216
217inline int
219{
220 switch (GET_MODE_CLASS (mode))
221 {
222 case MODE_INT:
223 return mode - MIN_MODE_INT;
224 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. */
229 break;
230 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. */
235 break;
236 default:
237 break;
238 }
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
246inline bool *
248 machine_mode mode)
249{
250 int idx = expmed_mode_index (mode);
251 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
257inline int *
259 machine_mode mode)
260{
261 int idx = expmed_mode_index (mode);
262 return &costs->cost[speed][idx];
263}
264
265/* Subroutine of {set_,}sdiv_pow2_cheap. Not to be used otherwise. */
266
267inline bool *
268sdiv_pow2_cheap_ptr (bool speed, machine_mode mode)
269{
270 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
277inline void
278set_sdiv_pow2_cheap (bool speed, machine_mode mode, bool cheap_p)
279{
281}
282
283/* Return whether a signed division by a power of 2 is cheap in MODE
284 when optimizing for SPEED. */
285
286inline bool
287sdiv_pow2_cheap (bool speed, machine_mode mode)
288{
289 return *sdiv_pow2_cheap_ptr (speed, mode);
290}
291
292/* Subroutine of {set_,}smod_pow2_cheap. Not to be used otherwise. */
293
294inline bool *
295smod_pow2_cheap_ptr (bool speed, machine_mode mode)
296{
297 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
304inline void
305set_smod_pow2_cheap (bool speed, machine_mode mode, bool cheap)
306{
307 *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
313inline bool
314smod_pow2_cheap (bool speed, machine_mode mode)
315{
316 return *smod_pow2_cheap_ptr (speed, mode);
317}
318
319/* Subroutine of {set_,}zero_cost. Not to be used otherwise. */
320
321inline int *
323{
324 return &this_target_expmed->x_zero_cost[speed];
325}
326
327/* Set the COST of loading zero when optimizing for SPEED. */
328
329inline void
331{
333}
334
335/* Return the COST of loading zero when optimizing for SPEED. */
336
337inline int
339{
340 return *zero_cost_ptr (speed);
341}
342
343/* Subroutine of {set_,}add_cost. Not to be used otherwise. */
344
345inline int *
346add_cost_ptr (bool speed, machine_mode mode)
347{
348 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
353inline void
354set_add_cost (bool speed, machine_mode mode, int cost)
355{
357}
358
359/* Return the cost of computing an add in MODE when optimizing for SPEED. */
360
361inline int
362add_cost (bool speed, machine_mode mode)
363{
364 return *add_cost_ptr (speed, mode);
365}
366
367/* Subroutine of {set_,}neg_cost. Not to be used otherwise. */
368
369inline int *
370neg_cost_ptr (bool speed, machine_mode mode)
371{
372 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
377inline void
378set_neg_cost (bool speed, machine_mode mode, int cost)
379{
381}
382
383/* Return the cost of computing a negation in MODE when optimizing for
384 SPEED. */
385
386inline int
387neg_cost (bool speed, machine_mode mode)
388{
389 return *neg_cost_ptr (speed, mode);
390}
391
392/* Subroutine of {set_,}shift_cost. Not to be used otherwise. */
393
394inline int *
395shift_cost_ptr (bool speed, machine_mode mode, int bits)
396{
398 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
403inline void
404set_shift_cost (bool speed, machine_mode mode, int bits, int cost)
405{
406 *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
412inline int
413shift_cost (bool speed, machine_mode mode, int bits)
414{
415 return *shift_cost_ptr (speed, mode, bits);
416}
417
418/* Subroutine of {set_,}shiftadd_cost. Not to be used otherwise. */
419
420inline int *
421shiftadd_cost_ptr (bool speed, machine_mode mode, int bits)
422{
424 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
430inline void
431set_shiftadd_cost (bool speed, machine_mode mode, int bits, int cost)
432{
433 *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
439inline int
440shiftadd_cost (bool speed, machine_mode mode, int bits)
441{
442 return *shiftadd_cost_ptr (speed, mode, bits);
443}
444
445/* Subroutine of {set_,}shiftsub0_cost. Not to be used otherwise. */
446
447inline int *
448shiftsub0_cost_ptr (bool speed, machine_mode mode, int bits)
449{
451 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
457inline void
458set_shiftsub0_cost (bool speed, machine_mode mode, int bits, int cost)
459{
460 *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
466inline int
467shiftsub0_cost (bool speed, machine_mode mode, int bits)
468{
469 return *shiftsub0_cost_ptr (speed, mode, bits);
470}
471
472/* Subroutine of {set_,}shiftsub1_cost. Not to be used otherwise. */
473
474inline int *
475shiftsub1_cost_ptr (bool speed, machine_mode mode, int bits)
476{
478 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
484inline void
485set_shiftsub1_cost (bool speed, machine_mode mode, int bits, int cost)
486{
487 *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
493inline int
494shiftsub1_cost (bool speed, machine_mode mode, int bits)
495{
496 return *shiftsub1_cost_ptr (speed, mode, bits);
497}
498
499/* Subroutine of {set_,}mul_cost. Not to be used otherwise. */
500
501inline int *
502mul_cost_ptr (bool speed, machine_mode mode)
503{
504 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
510inline void
511set_mul_cost (bool speed, machine_mode mode, int cost)
512{
514}
515
516/* Return the cost of doing a multiplication in MODE when optimizing
517 for SPEED. */
518
519inline int
520mul_cost (bool speed, machine_mode mode)
521{
522 return *mul_cost_ptr (speed, mode);
523}
524
525/* Subroutine of {set_,}sdiv_cost. Not to be used otherwise. */
526
527inline int *
528sdiv_cost_ptr (bool speed, machine_mode mode)
529{
530 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
536inline void
537set_sdiv_cost (bool speed, machine_mode mode, int cost)
538{
540}
541
542/* Return the cost of doing a signed division in MODE when optimizing
543 for SPEED. */
544
545inline int
546sdiv_cost (bool speed, machine_mode mode)
547{
548 return *sdiv_cost_ptr (speed, mode);
549}
550
551/* Subroutine of {set_,}udiv_cost. Not to be used otherwise. */
552
553inline int *
554udiv_cost_ptr (bool speed, machine_mode mode)
555{
556 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
562inline void
563set_udiv_cost (bool speed, machine_mode mode, int cost)
564{
566}
567
568/* Return the cost of doing an unsigned division in MODE when
569 optimizing for SPEED. */
570
571inline int
572udiv_cost (bool speed, machine_mode mode)
573{
574 return *udiv_cost_ptr (speed, mode);
575}
576
577/* Subroutine of {set_,}mul_widen_cost. Not to be used otherwise. */
578
579inline int *
580mul_widen_cost_ptr (bool speed, machine_mode mode)
581{
583
584 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
590inline void
591set_mul_widen_cost (bool speed, machine_mode mode, int cost)
592{
594}
595
596/* Return the cost for computing a widening multiplication in MODE when
597 optimizing for SPEED. */
598
599inline int
600mul_widen_cost (bool speed, machine_mode mode)
601{
602 return *mul_widen_cost_ptr (speed, mode);
603}
604
605/* Subroutine of {set_,}mul_highpart_cost. Not to be used otherwise. */
606
607inline int *
608mul_highpart_cost_ptr (bool speed, machine_mode mode)
609{
611 int m = mode - MIN_MODE_INT;
613
614 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
620inline void
621set_mul_highpart_cost (bool speed, machine_mode mode, int cost)
622{
624}
625
626/* Return the cost for computing the high part of a multiplication in MODE
627 when optimizing for SPEED. */
628
629inline int
630mul_highpart_cost (bool speed, machine_mode mode)
631{
633}
634
635/* Subroutine of {set_,}convert_cost. Not to be used otherwise. */
636
637inline int *
638convert_cost_ptr (machine_mode to_mode, machine_mode from_mode,
639 bool speed)
640{
643
646
647 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
653inline void
654set_convert_cost (machine_mode to_mode, machine_mode from_mode,
655 bool speed, int cost)
656{
658}
659
660/* Return the cost for converting from FROM_MODE to TO_MODE when optimizing
661 for SPEED. */
662
663inline int
664convert_cost (machine_mode to_mode, machine_mode from_mode,
665 bool speed)
666{
668}
669
670extern int mult_by_coeff_cost (HOST_WIDE_INT, machine_mode, bool);
671extern 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. */
678extern rtx negate_rtx (machine_mode, rtx);
679
680/* Arguments MODE, RTX: return an rtx for the flipping of that value.
681 May emit insns. */
682extern rtx flip_storage_order (machine_mode, rtx);
683
684/* Expand a logical AND operation. */
685extern rtx expand_and (machine_mode, rtx, rtx, rtx);
686
687/* Emit a store-flag operation. */
688extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, machine_mode,
689 int, int);
690
691/* Like emit_store_flag, but always succeeds. */
693 machine_mode, int, int);
694
695extern void canonicalize_comparison (machine_mode, enum rtx_code *, rtx *);
696
697/* Choose a minimal N + 1 bit approximation to 1/D that can be used to
698 replace division by D, and put the least significant N bits of the result
699 in *MULTIPLIER_PTR and return the most significant bit. */
700extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int,
701 int, unsigned HOST_WIDE_INT *,
702 int *, int *);
703
704#ifdef TREE_CODE
705extern rtx expand_variable_shift (enum tree_code, machine_mode,
706 rtx, tree, rtx, int);
707extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rtx,
708 int);
709extern rtx maybe_expand_shift (enum tree_code, machine_mode, rtx, int, rtx,
710 int);
711#ifdef GCC_OPTABS_H
712extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx,
713 rtx, int, enum optab_methods = OPTAB_LIB_WIDEN);
714#endif
715#endif
716
719 machine_mode, rtx, bool, bool);
721 machine_mode, machine_mode, bool, rtx *);
722extern rtx extract_low_bits (machine_mode, machine_mode, rtx);
723extern rtx expand_mult (machine_mode, rtx, rtx, rtx, int, bool = false);
725 rtx, int);
726
727#endif // EXPMED_H
Definition machmode.h:427
union tree_node * tree
Definition coretypes.h:97
#define MAX_BITS_PER_WORD
Definition defaults.h:1015
rtx expand_divmod(int rem_flag, enum tree_code code, machine_mode mode, rtx op0, rtx op1, rtx target, int unsignedp, enum optab_methods methods)
Definition expmed.cc:4234
rtx maybe_expand_shift(enum tree_code code, machine_mode mode, rtx shifted, int amount, rtx target, int unsignedp)
Definition expmed.cc:2715
rtx expand_variable_shift(enum tree_code code, machine_mode mode, rtx shifted, tree amount, rtx target, int unsignedp)
Definition expmed.cc:2730
rtx expand_shift(enum tree_code code, machine_mode mode, rtx shifted, poly_int64 amount, rtx target, int unsignedp)
Definition expmed.cc:2704
int convert_cost(machine_mode to_mode, machine_mode from_mode, bool speed)
Definition expmed.h:664
void set_alg_hash_used_p(bool usedp)
Definition expmed.h:210
unsigned HOST_WIDE_INT choose_multiplier(unsigned HOST_WIDE_INT, int, int, unsigned HOST_WIDE_INT *, int *, int *)
Definition expmed.cc:3709
bool * sdiv_pow2_cheap_ptr(bool speed, machine_mode mode)
Definition expmed.h:268
rtx flip_storage_order(machine_mode, rtx)
Definition expmed.cc:388
int shiftsub0_cost(bool speed, machine_mode mode, int bits)
Definition expmed.h:467
#define this_target_expmed
Definition expmed.h:188
int * shiftsub1_cost_ptr(bool speed, machine_mode mode, int bits)
Definition expmed.h:475
int neg_cost(bool speed, machine_mode mode)
Definition expmed.h:387
int shift_cost(bool speed, machine_mode mode, int bits)
Definition expmed.h:413
rtx expand_and(machine_mode, rtx, rtx, rtx)
Definition expmed.cc:5486
int mul_highpart_cost(bool speed, machine_mode mode)
Definition expmed.h:630
void set_mul_widen_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:591
int * mul_highpart_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:608
void set_udiv_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:563
int mul_widen_cost(bool speed, machine_mode mode)
Definition expmed.h:600
void set_smod_pow2_cheap(bool speed, machine_mode mode, bool cheap)
Definition expmed.h:305
int udiv_cost(bool speed, machine_mode mode)
Definition expmed.h:572
rtx negate_rtx(machine_mode, rtx)
Definition expmed.cc:339
int * sdiv_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:528
int * shiftsub0_cost_ptr(bool speed, machine_mode mode, int bits)
Definition expmed.h:448
int zero_cost(bool speed)
Definition expmed.h:338
rtx emit_store_flag_force(rtx, enum rtx_code, rtx, rtx, machine_mode, int, int)
Definition expmed.cc:6179
void set_mul_highpart_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:621
void set_zero_cost(bool speed, int cost)
Definition expmed.h:330
int * neg_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:370
void set_convert_cost(machine_mode to_mode, machine_mode from_mode, bool speed, int cost)
Definition expmed.h:654
int sdiv_cost(bool speed, machine_mode mode)
Definition expmed.h:546
void set_sdiv_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:537
int * shiftadd_cost_ptr(bool speed, machine_mode mode, int bits)
Definition expmed.h:421
void set_sdiv_pow2_cheap(bool speed, machine_mode mode, bool cheap_p)
Definition expmed.h:278
bool sdiv_pow2_cheap(bool speed, machine_mode mode)
Definition expmed.h:287
void set_mul_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:511
void set_shiftadd_cost(bool speed, machine_mode mode, int bits, int cost)
Definition expmed.h:431
int * add_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:346
int * mul_widen_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:580
rtx expand_mult_highpart_adjust(scalar_int_mode, rtx, rtx, rtx, rtx, int)
Definition expmed.cc:3803
rtx expand_mult(machine_mode, rtx, rtx, rtx, int, bool=false)
Definition expmed.cc:3467
mult_variant
Definition expmed.h:42
@ add_variant
Definition expmed.h:42
@ negate_variant
Definition expmed.h:42
@ basic_variant
Definition expmed.h:42
rtx emit_cstore(rtx target, enum insn_code icode, enum rtx_code code, machine_mode mode, machine_mode compare_mode, int unsignedp, rtx x, rtx y, int normalizep, machine_mode target_mode)
Definition expmed.cc:5504
void store_bit_field(rtx, poly_uint64, poly_uint64, poly_uint64, poly_uint64, machine_mode, rtx, bool, bool)
Definition expmed.cc:1125
#define NUM_ALG_HASH_ENTRIES
Definition expmed.h:133
#define NUM_MODE_IP_INT
Definition expmed.h:136
int * zero_cost_ptr(bool speed)
Definition expmed.h:322
int * mul_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:502
bool * smod_pow2_cheap_ptr(bool speed, machine_mode mode)
Definition expmed.h:295
int expmed_mode_index(machine_mode mode)
Definition expmed.h:218
int add_cost(bool speed, machine_mode mode)
Definition expmed.h:362
void set_shift_cost(bool speed, machine_mode mode, int bits, int cost)
Definition expmed.h:404
struct target_expmed default_target_expmed
Definition expmed.cc:48
alg_code
Definition expmed.h:25
@ alg_add_t_m2
Definition expmed.h:29
@ alg_sub_factor
Definition expmed.h:32
@ alg_zero
Definition expmed.h:27
@ alg_unknown
Definition expmed.h:26
@ alg_impossible
Definition expmed.h:35
@ alg_sub_t_m2
Definition expmed.h:30
@ alg_shift
Definition expmed.h:28
@ alg_add_factor
Definition expmed.h:31
@ alg_m
Definition expmed.h:28
@ alg_sub_t2_m
Definition expmed.h:34
@ alg_add_t2_m
Definition expmed.h:33
int * convert_cost_ptr(machine_mode to_mode, machine_mode from_mode, bool speed)
Definition expmed.h:638
int shiftsub1_cost(bool speed, machine_mode mode, int bits)
Definition expmed.h:494
rtx extract_low_bits(machine_mode, machine_mode, rtx)
Definition expmed.cc:2410
void set_neg_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:378
int mult_by_coeff_cost(HOST_WIDE_INT, machine_mode, bool)
Definition expmed.cc:3621
void set_add_cost(bool speed, machine_mode mode, int cost)
Definition expmed.h:354
bool choose_mult_variant(machine_mode, HOST_WIDE_INT, struct algorithm *, enum mult_variant *, int)
Definition expmed.cc:3227
int mul_cost(bool speed, machine_mode mode)
Definition expmed.h:520
void set_shiftsub1_cost(bool speed, machine_mode mode, int bits, int cost)
Definition expmed.h:485
void set_shiftsub0_cost(bool speed, machine_mode mode, int bits, int cost)
Definition expmed.h:458
int * shift_cost_ptr(bool speed, machine_mode mode, int bits)
Definition expmed.h:395
int shiftadd_cost(bool speed, machine_mode mode, int bits)
Definition expmed.h:440
#define NUM_MODE_IPV_INT
Definition expmed.h:137
bool smod_pow2_cheap(bool speed, machine_mode mode)
Definition expmed.h:314
rtx emit_store_flag(rtx, enum rtx_code, rtx, rtx, machine_mode, int, int)
Definition expmed.cc:6031
void canonicalize_comparison(machine_mode, enum rtx_code *, rtx *)
Definition expmed.cc:6311
int * udiv_cost_ptr(bool speed, machine_mode mode)
Definition expmed.h:554
struct alg_hash_entry * alg_hash_entry_ptr(int idx)
Definition expmed.h:194
rtx extract_bit_field(rtx, poly_uint64, poly_uint64, int, rtx, machine_mode, machine_mode, bool, rtx *)
Definition expmed.cc:2111
int * expmed_op_cost_ptr(struct expmed_op_costs *costs, bool speed, machine_mode mode)
Definition expmed.h:258
bool * expmed_op_cheap_ptr(struct expmed_op_cheap *eoc, bool speed, machine_mode mode)
Definition expmed.h:247
bool alg_hash_used_p(void)
Definition expmed.h:202
tree_code
Definition genmatch.cc:347
T * ggc_alloc(ALONE_CXX_MEM_STAT_INFO)
Definition ggc.h:184
#define GET_MODE_CLASS(MODE)
Definition machmode.h:105
optab_methods
Definition optabs.h:177
@ OPTAB_LIB_WIDEN
Definition optabs.h:181
rtx_code
Definition rtl.h:48
Definition expmed.h:110
unsigned HOST_WIDE_INT t
Definition expmed.h:112
machine_mode mode
Definition expmed.h:115
struct mult_cost cost
Definition expmed.h:123
enum alg_code alg
Definition expmed.h:118
bool speed
Definition expmed.h:126
Definition expmed.h:97
short ops
Definition expmed.h:99
enum alg_code op[MAX_BITS_PER_WORD]
Definition expmed.h:105
struct mult_cost cost
Definition expmed.h:98
char log[MAX_BITS_PER_WORD]
Definition expmed.h:106
Definition ira-costs.cc:54
int cost[1]
Definition ira-costs.cc:58
Definition expmed.h:139
bool cheap[2][NUM_MODE_IPV_INT]
Definition expmed.h:140
Definition expmed.h:143
int cost[2][NUM_MODE_IPV_INT]
Definition expmed.h:144
Definition expmed.h:58
short cost
Definition expmed.h:59
short latency
Definition expmed.h:60
Definition rtl.h:311
Definition expmed.h:148
int x_shift_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD]
Definition expmed.h:168
struct alg_hash_entry x_alg_hash[NUM_ALG_HASH_ENTRIES]
Definition expmed.h:152
int x_convert_cost[2][NUM_MODE_IP_INT][NUM_MODE_IP_INT]
Definition expmed.h:181
struct expmed_op_costs x_sdiv_cost
Definition expmed.h:173
struct expmed_op_cheap x_sdiv_pow2_cheap
Definition expmed.h:161
int x_shiftadd_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD]
Definition expmed.h:169
int x_mul_highpart_cost[2][NUM_MODE_INT]
Definition expmed.h:176
int x_zero_cost[2]
Definition expmed.h:165
struct expmed_op_costs x_add_cost
Definition expmed.h:166
bool x_alg_hash_used_p
Definition expmed.h:155
int x_shiftsub1_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD]
Definition expmed.h:171
struct expmed_op_costs x_mul_cost
Definition expmed.h:172
struct expmed_op_cheap x_smod_pow2_cheap
Definition expmed.h:162
struct expmed_op_costs x_neg_cost
Definition expmed.h:167
int x_mul_widen_cost[2][NUM_MODE_INT]
Definition expmed.h:175
int x_shiftsub0_cost[2][NUM_MODE_IPV_INT][MAX_BITS_PER_WORD]
Definition expmed.h:170
struct expmed_op_costs x_udiv_cost
Definition expmed.h:174
#define gcc_assert(EXPR)
Definition system.h:821
#define gcc_unreachable()
Definition system.h:848
#define IN_RANGE(VALUE, LOWER, UPPER)
Definition system.h:320
const T2 & y
Definition wide-int.h:3870