]>
Commit | Line | Data |
---|---|---|
947ed59a | 1 | /* IR-agnostic target query functions relating to optabs |
aad93da1 | 2 | Copyright (C) 2001-2017 Free Software Foundation, Inc. |
947ed59a | 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" | |
282dc861 | 24 | #include "target.h" |
947ed59a | 25 | |
d2a1b453 | 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 | ||
947ed59a | 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 << 16) | 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 << 16) | (from_mode << 8) | to_mode; | |
d2a1b453 | 54 | gcc_assert (convert_optab_p (op)); |
947ed59a | 55 | return raw_optab_handler (scode); |
56 | } | |
57 | ||
acdfe9e0 | 58 | enum insn_code convert_optab_handler (convert_optab, machine_mode, |
59 | machine_mode, optimization_type); | |
60 | ||
947ed59a | 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 | ||
acdfe9e0 | 70 | enum insn_code direct_optab_handler (convert_optab, machine_mode, |
71 | optimization_type); | |
72 | ||
947ed59a | 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 | ||
dab48979 | 92 | /* Return insn code for a comparison operator with VMODE |
93 | resultin MASK_MODE, unsigned if UNS is true. */ | |
94 | ||
95 | static 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 (tab, vmode, mask_mode); | |
100 | } | |
101 | ||
6a2e2a85 | 102 | /* Return insn code for a comparison operator with VMODE |
103 | resultin MASK_MODE (only for EQ/NE). */ | |
104 | ||
105 | static inline enum insn_code | |
106 | get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode) | |
107 | { | |
108 | return convert_optab_handler (vec_cmpeq_optab, vmode, mask_mode); | |
109 | } | |
110 | ||
947ed59a | 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 (vcondu_optab, vmode, cmode); | |
120 | else | |
121 | icode = convert_optab_handler (vcond_optab, vmode, cmode); | |
122 | return icode; | |
123 | } | |
124 | ||
b602a8ec | 125 | /* Return insn code for a conditional operator with a mask mode |
126 | MMODE resulting in a value of mode VMODE. */ | |
127 | ||
128 | static inline enum insn_code | |
129 | get_vcond_mask_icode (machine_mode vmode, machine_mode mmode) | |
130 | { | |
131 | return convert_optab_handler (vcond_mask_optab, vmode, mmode); | |
132 | } | |
133 | ||
6a2e2a85 | 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 | static inline enum insn_code | |
138 | get_vcond_eq_icode (machine_mode vmode, machine_mode cmode) | |
139 | { | |
140 | return convert_optab_handler (vcondeq_optab, vmode, cmode); | |
141 | } | |
142 | ||
947ed59a | 143 | /* Enumerates the possible extraction_insn operations. */ |
144 | enum extraction_pattern { EP_insv, EP_extv, EP_extzv }; | |
145 | ||
146 | /* Describes an instruction that inserts or extracts a bitfield. */ | |
147 | struct extraction_insn | |
148 | { | |
149 | /* The code of the instruction. */ | |
150 | enum insn_code icode; | |
151 | ||
152 | /* The mode that the structure operand should have. This is byte_mode | |
54fea56d | 153 | when using the legacy insv, extv and extzv patterns to access memory. |
154 | If no mode is given, the structure is a BLKmode memory. */ | |
155 | opt_scalar_int_mode struct_mode; | |
947ed59a | 156 | |
157 | /* The mode of the field to be inserted or extracted, and by extension | |
158 | the mode of the insertion or extraction itself. */ | |
54fea56d | 159 | scalar_int_mode field_mode; |
947ed59a | 160 | |
161 | /* The mode of the field's bit position. This is only important | |
162 | when the position is variable rather than constant. */ | |
54fea56d | 163 | scalar_int_mode pos_mode; |
947ed59a | 164 | }; |
165 | ||
166 | bool get_best_reg_extraction_insn (extraction_insn *, | |
167 | enum extraction_pattern, | |
168 | unsigned HOST_WIDE_INT, machine_mode); | |
169 | bool get_best_mem_extraction_insn (extraction_insn *, | |
170 | enum extraction_pattern, | |
171 | HOST_WIDE_INT, HOST_WIDE_INT, machine_mode); | |
172 | ||
173 | enum insn_code can_extend_p (machine_mode, machine_mode, int); | |
174 | enum insn_code can_float_p (machine_mode, machine_mode, int); | |
175 | enum insn_code can_fix_p (machine_mode, machine_mode, int, bool *); | |
176 | bool can_conditionally_move_p (machine_mode mode); | |
282dc861 | 177 | bool can_vec_perm_p (machine_mode, bool, vec_perm_indices *); |
947ed59a | 178 | /* Find a widening optab even if it doesn't widen as much as we want. */ |
d2a1b453 | 179 | #define find_widening_optab_handler(A, B, C) \ |
180 | find_widening_optab_handler_and_mode (A, B, C, NULL) | |
947ed59a | 181 | enum insn_code find_widening_optab_handler_and_mode (optab, machine_mode, |
d2a1b453 | 182 | machine_mode, |
947ed59a | 183 | machine_mode *); |
184 | int can_mult_highpart_p (machine_mode, bool); | |
f636f094 | 185 | bool can_vec_mask_load_store_p (machine_mode, machine_mode, bool); |
947ed59a | 186 | bool can_compare_and_swap_p (machine_mode, bool); |
187 | bool can_atomic_exchange_p (machine_mode, bool); | |
d5f5fa27 | 188 | bool can_atomic_load_p (machine_mode); |
947ed59a | 189 | bool lshift_cheap_p (bool); |
190 | ||
d2a1b453 | 191 | /* Version of find_widening_optab_handler_and_mode that operates on |
192 | specific mode types. */ | |
193 | ||
194 | template<typename T> | |
195 | inline enum insn_code | |
196 | find_widening_optab_handler_and_mode (optab op, const T &to_mode, | |
197 | const T &from_mode, T *found_mode) | |
198 | { | |
199 | machine_mode tmp; | |
200 | enum insn_code icode = find_widening_optab_handler_and_mode | |
201 | (op, machine_mode (to_mode), machine_mode (from_mode), &tmp); | |
202 | if (icode != CODE_FOR_nothing && found_mode) | |
203 | *found_mode = as_a <T> (tmp); | |
204 | return icode; | |
205 | } | |
206 | ||
947ed59a | 207 | #endif |