1 | /* IR-agnostic target query functions relating to optabs |
2 | Copyright (C) 2001-2023 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 |
7 | it under the terms of the GNU General Public License as published by |
8 | the Free Software Foundation; either version 3, or (at your option) |
9 | any later version. |
10 | |
11 | GCC is distributed in the hope that it will be useful, |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | GNU General Public License 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 GCC_OPTABS_QUERY_H |
21 | #define GCC_OPTABS_QUERY_H |
22 | |
23 | #include "insn-opinit.h" |
24 | #include "target.h" |
25 | |
26 | /* Return true if OP is a conversion optab. */ |
27 | |
28 | inline bool |
29 | convert_optab_p (optab op) |
30 | { |
31 | return op > unknown_optab && op <= LAST_CONV_OPTAB; |
32 | } |
33 | |
34 | /* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing |
35 | if the target does not have such an insn. */ |
36 | |
37 | inline enum insn_code |
38 | optab_handler (optab op, machine_mode mode) |
39 | { |
40 | unsigned scode = (op << 20) | mode; |
41 | gcc_assert (op > LAST_CONV_OPTAB); |
42 | return raw_optab_handler (scode); |
43 | } |
44 | |
45 | /* Return the insn used to perform conversion OP from mode FROM_MODE |
46 | to mode TO_MODE; return CODE_FOR_nothing if the target does not have |
47 | such an insn. */ |
48 | |
49 | inline enum insn_code |
50 | convert_optab_handler (convert_optab op, machine_mode to_mode, |
51 | machine_mode from_mode) |
52 | { |
53 | unsigned scode = (op << 20) | (from_mode << 10) | to_mode; |
54 | gcc_assert (convert_optab_p (op)); |
55 | return raw_optab_handler (scode); |
56 | } |
57 | |
58 | enum insn_code convert_optab_handler (convert_optab, machine_mode, |
59 | machine_mode, optimization_type); |
60 | |
61 | /* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing |
62 | if the target does not have such an insn. */ |
63 | |
64 | inline enum insn_code |
65 | direct_optab_handler (direct_optab op, machine_mode mode) |
66 | { |
67 | return optab_handler (op, mode); |
68 | } |
69 | |
70 | enum insn_code direct_optab_handler (convert_optab, machine_mode, |
71 | optimization_type); |
72 | |
73 | /* Return true if UNOPTAB is for a trapping-on-overflow operation. */ |
74 | |
75 | inline bool |
76 | trapv_unoptab_p (optab unoptab) |
77 | { |
78 | return (unoptab == negv_optab |
79 | || unoptab == absv_optab); |
80 | } |
81 | |
82 | /* Return true if BINOPTAB is for a trapping-on-overflow operation. */ |
83 | |
84 | inline bool |
85 | trapv_binoptab_p (optab binoptab) |
86 | { |
87 | return (binoptab == addv_optab |
88 | || binoptab == subv_optab |
89 | || binoptab == smulv_optab); |
90 | } |
91 | |
92 | /* Return insn code for a comparison operator with VMODE |
93 | resultin MASK_MODE, unsigned if UNS is true. */ |
94 | |
95 | inline enum insn_code |
96 | get_vec_cmp_icode (machine_mode vmode, machine_mode mask_mode, bool uns) |
97 | { |
98 | optab tab = uns ? vec_cmpu_optab : vec_cmp_optab; |
99 | return convert_optab_handler (op: tab, to_mode: vmode, from_mode: mask_mode); |
100 | } |
101 | |
102 | /* Return insn code for a comparison operator with VMODE |
103 | resultin MASK_MODE (only for EQ/NE). */ |
104 | |
105 | inline enum insn_code |
106 | get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode) |
107 | { |
108 | return convert_optab_handler (op: vec_cmpeq_optab, to_mode: vmode, from_mode: mask_mode); |
109 | } |
110 | |
111 | /* Return insn code for a conditional operator with a comparison in |
112 | mode CMODE, unsigned if UNS is true, resulting in a value of mode VMODE. */ |
113 | |
114 | inline enum insn_code |
115 | get_vcond_icode (machine_mode vmode, machine_mode cmode, bool uns) |
116 | { |
117 | enum insn_code icode = CODE_FOR_nothing; |
118 | if (uns) |
119 | icode = convert_optab_handler (op: vcondu_optab, to_mode: vmode, from_mode: cmode); |
120 | else |
121 | icode = convert_optab_handler (op: vcond_optab, to_mode: vmode, from_mode: cmode); |
122 | return icode; |
123 | } |
124 | |
125 | /* Return insn code for a conditional operator with a mask mode |
126 | MMODE resulting in a value of mode VMODE. */ |
127 | |
128 | inline enum insn_code |
129 | get_vcond_mask_icode (machine_mode vmode, machine_mode mmode) |
130 | { |
131 | return convert_optab_handler (op: vcond_mask_optab, to_mode: vmode, from_mode: mmode); |
132 | } |
133 | |
134 | /* Return insn code for a conditional operator with a comparison in |
135 | mode CMODE (only EQ/NE), resulting in a value of mode VMODE. */ |
136 | |
137 | inline enum insn_code |
138 | get_vcond_eq_icode (machine_mode vmode, machine_mode cmode) |
139 | { |
140 | return convert_optab_handler (op: vcondeq_optab, to_mode: vmode, from_mode: cmode); |
141 | } |
142 | |
143 | /* Enumerates the possible extraction_insn operations. */ |
144 | enum { EP_insv, EP_extv, EP_extzv }; |
145 | |
146 | /* Describes an instruction that inserts or extracts a bitfield. */ |
147 | class |
148 | { |
149 | public: |
150 | /* The code of the instruction. */ |
151 | enum insn_code ; |
152 | |
153 | /* The mode that the structure operand should have. This is byte_mode |
154 | when using the legacy insv, extv and extzv patterns to access memory. |
155 | If no mode is given, the structure is a BLKmode memory. */ |
156 | opt_scalar_int_mode ; |
157 | |
158 | /* The mode of the field to be inserted or extracted, and by extension |
159 | the mode of the insertion or extraction itself. */ |
160 | scalar_int_mode ; |
161 | |
162 | /* The mode of the field's bit position. This is only important |
163 | when the position is variable rather than constant. */ |
164 | scalar_int_mode ; |
165 | }; |
166 | |
167 | bool (extraction_insn *, |
168 | enum extraction_pattern, |
169 | unsigned HOST_WIDE_INT, machine_mode); |
170 | bool (extraction_insn *, |
171 | enum extraction_pattern, |
172 | HOST_WIDE_INT, HOST_WIDE_INT, machine_mode); |
173 | |
174 | enum insn_code can_extend_p (machine_mode, machine_mode, int); |
175 | enum insn_code can_float_p (machine_mode, machine_mode, int); |
176 | enum insn_code can_fix_p (machine_mode, machine_mode, int, bool *); |
177 | bool can_conditionally_move_p (machine_mode mode); |
178 | opt_machine_mode qimode_for_vec_perm (machine_mode); |
179 | bool selector_fits_mode_p (machine_mode, const vec_perm_indices &); |
180 | bool can_vec_perm_var_p (machine_mode); |
181 | bool can_vec_perm_const_p (machine_mode, machine_mode, |
182 | const vec_perm_indices &, bool = true); |
183 | /* Find a widening optab even if it doesn't widen as much as we want. */ |
184 | #define find_widening_optab_handler(A, B, C) \ |
185 | find_widening_optab_handler_and_mode (A, B, C, NULL) |
186 | enum insn_code find_widening_optab_handler_and_mode (optab, machine_mode, |
187 | machine_mode, |
188 | machine_mode *); |
189 | int can_mult_highpart_p (machine_mode, bool); |
190 | bool can_compare_and_swap_p (machine_mode, bool); |
191 | bool can_atomic_exchange_p (machine_mode, bool); |
192 | bool can_atomic_load_p (machine_mode); |
193 | bool lshift_cheap_p (bool); |
194 | bool supports_vec_gather_load_p (machine_mode = E_VOIDmode); |
195 | bool supports_vec_scatter_store_p (machine_mode = E_VOIDmode); |
196 | bool (machine_mode, machine_mode); |
197 | |
198 | /* Version of find_widening_optab_handler_and_mode that operates on |
199 | specific mode types. */ |
200 | |
201 | template<typename T> |
202 | inline enum insn_code |
203 | find_widening_optab_handler_and_mode (optab op, const T &to_mode, |
204 | const T &from_mode, T *found_mode) |
205 | { |
206 | machine_mode tmp; |
207 | enum insn_code icode = find_widening_optab_handler_and_mode |
208 | (op, machine_mode (to_mode), machine_mode (from_mode), &tmp); |
209 | if (icode != CODE_FOR_nothing && found_mode) |
210 | *found_mode = as_a <T> (tmp); |
211 | return icode; |
212 | } |
213 | |
214 | #endif |
215 | |