]>
Commit | Line | Data |
---|---|---|
e78d8e51 | 1 | /* Definitions for code generation pass of GNU compiler. |
d9221e01 | 2 | Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
e78d8e51 | 3 | |
40803cd5 | 4 | This file is part of GCC. |
e78d8e51 | 5 | |
40803cd5 | 6 | GCC is free software; you can redistribute it and/or modify |
e78d8e51 ZW |
7 | it under the terms of the GNU General Public License as published by |
8 | the Free Software Foundation; either version 2, or (at your option) | |
9 | any later version. | |
10 | ||
40803cd5 | 11 | GCC is distributed in the hope that it will be useful, |
e78d8e51 ZW |
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 | |
40803cd5 | 17 | along with GCC; see the file COPYING. If not, write to |
e78d8e51 ZW |
18 | the Free Software Foundation, 59 Temple Place - Suite 330, |
19 | Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #ifndef GCC_OPTABS_H | |
22 | #define GCC_OPTABS_H | |
23 | ||
24 | #include "insn-codes.h" | |
25 | ||
26 | /* Optabs are tables saying how to generate insn bodies | |
27 | for various machine modes and numbers of operands. | |
28 | Each optab applies to one operation. | |
29 | For example, add_optab applies to addition. | |
30 | ||
31 | The insn_code slot is the enum insn_code that says how to | |
32 | generate an insn for this operation on a particular machine mode. | |
33 | It is CODE_FOR_nothing if there is no such insn on the target machine. | |
34 | ||
35 | The `lib_call' slot is the name of the library function that | |
36 | can be used to perform the operation. | |
37 | ||
38 | A few optabs, such as move_optab and cmp_optab, are used | |
39 | by special code. */ | |
40 | ||
85363ca0 ZW |
41 | struct optab_handlers GTY(()) |
42 | { | |
43 | enum insn_code insn_code; | |
44 | rtx libfunc; | |
45 | }; | |
46 | ||
e2500fed | 47 | struct optab GTY(()) |
e78d8e51 ZW |
48 | { |
49 | enum rtx_code code; | |
85363ca0 | 50 | struct optab_handlers handlers[NUM_MACHINE_MODES]; |
e2500fed GK |
51 | }; |
52 | typedef struct optab * optab; | |
e78d8e51 | 53 | |
85363ca0 ZW |
54 | /* A convert_optab is for some sort of conversion operation between |
55 | modes. The first array index is the destination mode, the second | |
56 | is the source mode. */ | |
57 | struct convert_optab GTY(()) | |
58 | { | |
59 | enum rtx_code code; | |
60 | struct optab_handlers handlers[NUM_MACHINE_MODES][NUM_MACHINE_MODES]; | |
61 | }; | |
62 | typedef struct convert_optab *convert_optab; | |
63 | ||
e78d8e51 ZW |
64 | /* Given an enum insn_code, access the function to construct |
65 | the body of that kind of insn. */ | |
85363ca0 | 66 | #define GEN_FCN(CODE) (insn_data[CODE].genfun) |
e78d8e51 ZW |
67 | |
68 | /* Enumeration of valid indexes into optab_table. */ | |
69 | enum optab_index | |
70 | { | |
71 | OTI_add, | |
72 | OTI_addv, | |
73 | OTI_sub, | |
74 | OTI_subv, | |
75 | ||
76 | /* Signed and fp multiply */ | |
77 | OTI_smul, | |
78 | OTI_smulv, | |
79 | /* Signed multiply, return high word */ | |
80 | OTI_smul_highpart, | |
81 | OTI_umul_highpart, | |
82 | /* Signed multiply with result one machine mode wider than args */ | |
83 | OTI_smul_widen, | |
84 | OTI_umul_widen, | |
85 | ||
86 | /* Signed divide */ | |
87 | OTI_sdiv, | |
88 | OTI_sdivv, | |
89 | /* Signed divide-and-remainder in one */ | |
90 | OTI_sdivmod, | |
91 | OTI_udiv, | |
92 | OTI_udivmod, | |
93 | /* Signed remainder */ | |
94 | OTI_smod, | |
95 | OTI_umod, | |
5ae27cfa UB |
96 | /* Floating point remainder functions */ |
97 | OTI_fmod, | |
98 | OTI_drem, | |
e78d8e51 ZW |
99 | /* Convert float to integer in float fmt */ |
100 | OTI_ftrunc, | |
101 | ||
102 | /* Logical and */ | |
103 | OTI_and, | |
104 | /* Logical or */ | |
105 | OTI_ior, | |
106 | /* Logical xor */ | |
107 | OTI_xor, | |
108 | ||
109 | /* Arithmetic shift left */ | |
110 | OTI_ashl, | |
111 | /* Logical shift right */ | |
0c20a65f | 112 | OTI_lshr, |
e78d8e51 ZW |
113 | /* Arithmetic shift right */ |
114 | OTI_ashr, | |
115 | /* Rotate left */ | |
116 | OTI_rotl, | |
117 | /* Rotate right */ | |
118 | OTI_rotr, | |
119 | /* Signed and floating-point minimum value */ | |
120 | OTI_smin, | |
121 | /* Signed and floating-point maximum value */ | |
122 | OTI_smax, | |
123 | /* Unsigned minimum value */ | |
124 | OTI_umin, | |
125 | /* Unsigned maximum value */ | |
126 | OTI_umax, | |
b5e01d4b RS |
127 | /* Power */ |
128 | OTI_pow, | |
129 | /* Arc tangent of y/x */ | |
130 | OTI_atan2, | |
e78d8e51 ZW |
131 | |
132 | /* Move instruction. */ | |
133 | OTI_mov, | |
134 | /* Move, preserving high part of register. */ | |
135 | OTI_movstrict, | |
136 | ||
137 | /* Unary operations */ | |
138 | /* Negation */ | |
139 | OTI_neg, | |
140 | OTI_negv, | |
141 | /* Abs value */ | |
142 | OTI_abs, | |
143 | OTI_absv, | |
144 | /* Bitwise not */ | |
145 | OTI_one_cmpl, | |
2928cd7a | 146 | /* Bit scanning and counting */ |
e78d8e51 | 147 | OTI_ffs, |
2928cd7a RH |
148 | OTI_clz, |
149 | OTI_ctz, | |
150 | OTI_popcount, | |
151 | OTI_parity, | |
e78d8e51 ZW |
152 | /* Square root */ |
153 | OTI_sqrt, | |
6c7cf1f0 UB |
154 | /* Sine-Cosine */ |
155 | OTI_sincos, | |
e78d8e51 ZW |
156 | /* Sine */ |
157 | OTI_sin, | |
c56122d8 UB |
158 | /* Inverse sine */ |
159 | OTI_asin, | |
e78d8e51 ZW |
160 | /* Cosine */ |
161 | OTI_cos, | |
c56122d8 UB |
162 | /* Inverse cosine */ |
163 | OTI_acos, | |
e7b489c8 RS |
164 | /* Exponential */ |
165 | OTI_exp, | |
a251102e UB |
166 | /* Base-10 Exponential */ |
167 | OTI_exp10, | |
168 | /* Base-2 Exponential */ | |
169 | OTI_exp2, | |
7a8e07c7 UB |
170 | /* Exponential - 1*/ |
171 | OTI_expm1, | |
88b28a31 UB |
172 | /* Radix-independent exponent */ |
173 | OTI_logb, | |
174 | OTI_ilogb, | |
e7b489c8 RS |
175 | /* Natural Logarithm */ |
176 | OTI_log, | |
3b8e0c91 UB |
177 | /* Base-10 Logarithm */ |
178 | OTI_log10, | |
179 | /* Base-2 Logarithm */ | |
180 | OTI_log2, | |
c2fcfa4f UB |
181 | /* logarithm of 1 plus argument */ |
182 | OTI_log1p, | |
4977bab6 ZW |
183 | /* Rounding functions */ |
184 | OTI_floor, | |
185 | OTI_ceil, | |
edeacc14 | 186 | OTI_btrunc, |
4977bab6 ZW |
187 | OTI_round, |
188 | OTI_nearbyint, | |
edeacc14 | 189 | OTI_rint, |
82d397c7 RS |
190 | /* Tangent */ |
191 | OTI_tan, | |
192 | /* Inverse tangent */ | |
193 | OTI_atan, | |
e78d8e51 ZW |
194 | |
195 | /* Compare insn; two operands. */ | |
196 | OTI_cmp, | |
197 | /* Used only for libcalls for unsigned comparisons. */ | |
198 | OTI_ucmp, | |
199 | /* tst insn; compare one operand against 0 */ | |
200 | OTI_tst, | |
201 | ||
c9034561 ZW |
202 | /* Floating point comparison optabs - used primarily for libfuncs */ |
203 | OTI_eq, | |
204 | OTI_ne, | |
205 | OTI_gt, | |
206 | OTI_ge, | |
207 | OTI_lt, | |
208 | OTI_le, | |
209 | OTI_unord, | |
210 | ||
e78d8e51 ZW |
211 | /* String length */ |
212 | OTI_strlen, | |
213 | ||
214 | /* Combined compare & jump/store flags/move operations. */ | |
215 | OTI_cbranch, | |
216 | OTI_cmov, | |
217 | OTI_cstore, | |
0c20a65f | 218 | |
e78d8e51 ZW |
219 | /* Push instruction. */ |
220 | OTI_push, | |
221 | ||
068f5dea JH |
222 | /* Conditional add instruction. */ |
223 | OTI_addcc, | |
224 | ||
997404de JH |
225 | /* Set specified field of vector operand. */ |
226 | OTI_vec_set, | |
227 | /* Extract specified field of vector operand. */ | |
228 | OTI_vec_extract, | |
229 | /* Initialize vector operand. */ | |
230 | OTI_vec_init, | |
7ccf35ed DN |
231 | /* Extract specified elements from vectors, for vector store. */ |
232 | OTI_vec_realign_store, | |
233 | /* Extract specified elements from vectors, for vector load. */ | |
234 | OTI_vec_realign_load, | |
997404de | 235 | |
e78d8e51 ZW |
236 | OTI_MAX |
237 | }; | |
238 | ||
e2500fed | 239 | extern GTY(()) optab optab_table[OTI_MAX]; |
e78d8e51 ZW |
240 | |
241 | #define add_optab (optab_table[OTI_add]) | |
242 | #define sub_optab (optab_table[OTI_sub]) | |
243 | #define smul_optab (optab_table[OTI_smul]) | |
244 | #define addv_optab (optab_table[OTI_addv]) | |
245 | #define subv_optab (optab_table[OTI_subv]) | |
246 | #define smul_highpart_optab (optab_table[OTI_smul_highpart]) | |
247 | #define umul_highpart_optab (optab_table[OTI_umul_highpart]) | |
248 | #define smul_widen_optab (optab_table[OTI_smul_widen]) | |
249 | #define umul_widen_optab (optab_table[OTI_umul_widen]) | |
250 | #define sdiv_optab (optab_table[OTI_sdiv]) | |
251 | #define smulv_optab (optab_table[OTI_smulv]) | |
252 | #define sdivv_optab (optab_table[OTI_sdivv]) | |
253 | #define sdivmod_optab (optab_table[OTI_sdivmod]) | |
254 | #define udiv_optab (optab_table[OTI_udiv]) | |
255 | #define udivmod_optab (optab_table[OTI_udivmod]) | |
256 | #define smod_optab (optab_table[OTI_smod]) | |
257 | #define umod_optab (optab_table[OTI_umod]) | |
5ae27cfa UB |
258 | #define fmod_optab (optab_table[OTI_fmod]) |
259 | #define drem_optab (optab_table[OTI_drem]) | |
e78d8e51 ZW |
260 | #define ftrunc_optab (optab_table[OTI_ftrunc]) |
261 | #define and_optab (optab_table[OTI_and]) | |
262 | #define ior_optab (optab_table[OTI_ior]) | |
263 | #define xor_optab (optab_table[OTI_xor]) | |
264 | #define ashl_optab (optab_table[OTI_ashl]) | |
265 | #define lshr_optab (optab_table[OTI_lshr]) | |
266 | #define ashr_optab (optab_table[OTI_ashr]) | |
267 | #define rotl_optab (optab_table[OTI_rotl]) | |
268 | #define rotr_optab (optab_table[OTI_rotr]) | |
269 | #define smin_optab (optab_table[OTI_smin]) | |
270 | #define smax_optab (optab_table[OTI_smax]) | |
271 | #define umin_optab (optab_table[OTI_umin]) | |
272 | #define umax_optab (optab_table[OTI_umax]) | |
b5e01d4b RS |
273 | #define pow_optab (optab_table[OTI_pow]) |
274 | #define atan2_optab (optab_table[OTI_atan2]) | |
e78d8e51 ZW |
275 | |
276 | #define mov_optab (optab_table[OTI_mov]) | |
277 | #define movstrict_optab (optab_table[OTI_movstrict]) | |
278 | ||
279 | #define neg_optab (optab_table[OTI_neg]) | |
280 | #define negv_optab (optab_table[OTI_negv]) | |
281 | #define abs_optab (optab_table[OTI_abs]) | |
282 | #define absv_optab (optab_table[OTI_absv]) | |
283 | #define one_cmpl_optab (optab_table[OTI_one_cmpl]) | |
284 | #define ffs_optab (optab_table[OTI_ffs]) | |
2928cd7a RH |
285 | #define clz_optab (optab_table[OTI_clz]) |
286 | #define ctz_optab (optab_table[OTI_ctz]) | |
287 | #define popcount_optab (optab_table[OTI_popcount]) | |
288 | #define parity_optab (optab_table[OTI_parity]) | |
e78d8e51 | 289 | #define sqrt_optab (optab_table[OTI_sqrt]) |
6c7cf1f0 | 290 | #define sincos_optab (optab_table[OTI_sincos]) |
e78d8e51 | 291 | #define sin_optab (optab_table[OTI_sin]) |
c56122d8 | 292 | #define asin_optab (optab_table[OTI_asin]) |
e78d8e51 | 293 | #define cos_optab (optab_table[OTI_cos]) |
c56122d8 | 294 | #define acos_optab (optab_table[OTI_acos]) |
e7b489c8 | 295 | #define exp_optab (optab_table[OTI_exp]) |
a251102e UB |
296 | #define exp10_optab (optab_table[OTI_exp10]) |
297 | #define exp2_optab (optab_table[OTI_exp2]) | |
7a8e07c7 | 298 | #define expm1_optab (optab_table[OTI_expm1]) |
88b28a31 UB |
299 | #define logb_optab (optab_table[OTI_logb]) |
300 | #define ilogb_optab (optab_table[OTI_ilogb]) | |
e7b489c8 | 301 | #define log_optab (optab_table[OTI_log]) |
3b8e0c91 UB |
302 | #define log10_optab (optab_table[OTI_log10]) |
303 | #define log2_optab (optab_table[OTI_log2]) | |
c2fcfa4f | 304 | #define log1p_optab (optab_table[OTI_log1p]) |
4977bab6 ZW |
305 | #define floor_optab (optab_table[OTI_floor]) |
306 | #define ceil_optab (optab_table[OTI_ceil]) | |
edeacc14 | 307 | #define btrunc_optab (optab_table[OTI_btrunc]) |
4977bab6 ZW |
308 | #define round_optab (optab_table[OTI_round]) |
309 | #define nearbyint_optab (optab_table[OTI_nearbyint]) | |
edeacc14 | 310 | #define rint_optab (optab_table[OTI_rint]) |
82d397c7 RS |
311 | #define tan_optab (optab_table[OTI_tan]) |
312 | #define atan_optab (optab_table[OTI_atan]) | |
e78d8e51 ZW |
313 | |
314 | #define cmp_optab (optab_table[OTI_cmp]) | |
315 | #define ucmp_optab (optab_table[OTI_ucmp]) | |
316 | #define tst_optab (optab_table[OTI_tst]) | |
317 | ||
c9034561 ZW |
318 | #define eq_optab (optab_table[OTI_eq]) |
319 | #define ne_optab (optab_table[OTI_ne]) | |
320 | #define gt_optab (optab_table[OTI_gt]) | |
321 | #define ge_optab (optab_table[OTI_ge]) | |
322 | #define lt_optab (optab_table[OTI_lt]) | |
323 | #define le_optab (optab_table[OTI_le]) | |
324 | #define unord_optab (optab_table[OTI_unord]) | |
325 | ||
e78d8e51 ZW |
326 | #define strlen_optab (optab_table[OTI_strlen]) |
327 | ||
328 | #define cbranch_optab (optab_table[OTI_cbranch]) | |
329 | #define cmov_optab (optab_table[OTI_cmov]) | |
330 | #define cstore_optab (optab_table[OTI_cstore]) | |
331 | #define push_optab (optab_table[OTI_push]) | |
068f5dea | 332 | #define addcc_optab (optab_table[OTI_addcc]) |
e78d8e51 | 333 | |
997404de JH |
334 | #define vec_set_optab (optab_table[OTI_vec_set]) |
335 | #define vec_extract_optab (optab_table[OTI_vec_extract]) | |
336 | #define vec_init_optab (optab_table[OTI_vec_init]) | |
7ccf35ed DN |
337 | #define vec_realign_store_optab (optab_table[OTI_vec_realign_store]) |
338 | #define vec_realign_load_optab (optab_table[OTI_vec_realign_load]) | |
997404de | 339 | |
85363ca0 ZW |
340 | /* Conversion optabs have their own table and indexes. */ |
341 | enum convert_optab_index | |
342 | { | |
343 | CTI_sext, | |
344 | CTI_zext, | |
345 | CTI_trunc, | |
346 | ||
347 | CTI_sfix, | |
348 | CTI_ufix, | |
349 | ||
350 | CTI_sfixtrunc, | |
351 | CTI_ufixtrunc, | |
352 | ||
353 | CTI_sfloat, | |
354 | CTI_ufloat, | |
355 | ||
356 | CTI_MAX | |
357 | }; | |
358 | ||
359 | extern GTY(()) convert_optab convert_optab_table[CTI_MAX]; | |
e78d8e51 | 360 | |
85363ca0 ZW |
361 | #define sext_optab (convert_optab_table[CTI_sext]) |
362 | #define zext_optab (convert_optab_table[CTI_zext]) | |
363 | #define trunc_optab (convert_optab_table[CTI_trunc]) | |
364 | #define sfix_optab (convert_optab_table[CTI_sfix]) | |
365 | #define ufix_optab (convert_optab_table[CTI_ufix]) | |
366 | #define sfixtrunc_optab (convert_optab_table[CTI_sfixtrunc]) | |
367 | #define ufixtrunc_optab (convert_optab_table[CTI_ufixtrunc]) | |
368 | #define sfloat_optab (convert_optab_table[CTI_sfloat]) | |
369 | #define ufloat_optab (convert_optab_table[CTI_ufloat]) | |
e78d8e51 ZW |
370 | |
371 | /* These arrays record the insn_code of insns that may be needed to | |
372 | perform input and output reloads of special objects. They provide a | |
373 | place to pass a scratch register. */ | |
374 | extern enum insn_code reload_in_optab[NUM_MACHINE_MODES]; | |
375 | extern enum insn_code reload_out_optab[NUM_MACHINE_MODES]; | |
376 | ||
377 | /* Contains the optab used for each rtx code. */ | |
17211ab5 | 378 | extern GTY(()) optab code_to_optab[NUM_RTX_CODE + 1]; |
e78d8e51 | 379 | |
e78d8e51 | 380 | \f |
0c20a65f | 381 | typedef rtx (*rtxfun) (rtx); |
e78d8e51 | 382 | |
454ff5cb | 383 | /* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) |
e78d8e51 ZW |
384 | gives the gen_function to make a branch to test that condition. */ |
385 | ||
386 | extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; | |
387 | ||
454ff5cb | 388 | /* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) |
e78d8e51 ZW |
389 | gives the insn code to make a store-condition insn |
390 | to test that condition. */ | |
391 | ||
392 | extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; | |
393 | ||
394 | #ifdef HAVE_conditional_move | |
395 | /* Indexed by the machine mode, gives the insn code to make a conditional | |
396 | move insn. */ | |
397 | ||
398 | extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; | |
399 | #endif | |
400 | ||
7ce67fbe DP |
401 | /* Indexed by the machine mode, gives the insn code for vector conditional |
402 | operation. */ | |
403 | ||
404 | extern enum insn_code vcond_gen_code[NUM_MACHINE_MODES]; | |
405 | extern enum insn_code vcondu_gen_code[NUM_MACHINE_MODES]; | |
406 | ||
e78d8e51 | 407 | /* This array records the insn_code of insns to perform block moves. */ |
70128ad9 | 408 | extern enum insn_code movmem_optab[NUM_MACHINE_MODES]; |
e78d8e51 ZW |
409 | |
410 | /* This array records the insn_code of insns to perform block clears. */ | |
70128ad9 | 411 | extern enum insn_code clrmem_optab[NUM_MACHINE_MODES]; |
118355a0 ZW |
412 | |
413 | /* These arrays record the insn_code of two different kinds of insns | |
414 | to perform block compares. */ | |
415 | extern enum insn_code cmpstr_optab[NUM_MACHINE_MODES]; | |
416 | extern enum insn_code cmpmem_optab[NUM_MACHINE_MODES]; | |
e78d8e51 ZW |
417 | |
418 | /* Define functions given in optabs.c. */ | |
419 | ||
7ccf35ed DN |
420 | extern rtx expand_ternary_op (enum machine_mode mode, optab ternary_optab, |
421 | rtx op0, rtx op1, rtx op2, rtx target, | |
422 | int unsignedp); | |
423 | ||
e78d8e51 | 424 | /* Expand a binary operation given optab and rtx operands. */ |
0c20a65f AJ |
425 | extern rtx expand_binop (enum machine_mode, optab, rtx, rtx, rtx, int, |
426 | enum optab_methods); | |
e78d8e51 ZW |
427 | |
428 | /* Expand a binary operation with both signed and unsigned forms. */ | |
0c20a65f AJ |
429 | extern rtx sign_expand_binop (enum machine_mode, optab, optab, rtx, rtx, |
430 | rtx, int, enum optab_methods); | |
e78d8e51 | 431 | |
6c7cf1f0 UB |
432 | /* Generate code to perform an operation on one operand with two results. */ |
433 | extern int expand_twoval_unop (optab, rtx, rtx, rtx, int); | |
434 | ||
e78d8e51 | 435 | /* Generate code to perform an operation on two operands with two results. */ |
0c20a65f | 436 | extern int expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int); |
e78d8e51 | 437 | |
b3f8d95d MM |
438 | /* Generate code to perform an operation on two operands with two |
439 | results, using a library function. */ | |
5906d013 | 440 | extern bool expand_twoval_binop_libfunc (optab, rtx, rtx, rtx, rtx, |
b3f8d95d MM |
441 | enum rtx_code); |
442 | ||
e78d8e51 | 443 | /* Expand a unary arithmetic operation given optab rtx operand. */ |
0c20a65f | 444 | extern rtx expand_unop (enum machine_mode, optab, rtx, rtx, int); |
e78d8e51 ZW |
445 | |
446 | /* Expand the absolute value operation. */ | |
0c20a65f AJ |
447 | extern rtx expand_abs_nojump (enum machine_mode, rtx, rtx, int); |
448 | extern rtx expand_abs (enum machine_mode, rtx, rtx, int, int); | |
e78d8e51 | 449 | |
e78d8e51 ZW |
450 | /* Generate an instruction with a given INSN_CODE with an output and |
451 | an input. */ | |
0c20a65f | 452 | extern void emit_unop_insn (int, rtx, rtx, enum rtx_code); |
e78d8e51 ZW |
453 | |
454 | /* Emit code to perform a series of operations on a multi-word quantity, one | |
455 | word at a time. */ | |
0c20a65f | 456 | extern rtx emit_no_conflict_block (rtx, rtx, rtx, rtx, rtx); |
e78d8e51 | 457 | |
e78d8e51 | 458 | /* Emit one rtl insn to compare two rtx's. */ |
0c20a65f AJ |
459 | extern void emit_cmp_insn (rtx, rtx, enum rtx_code, rtx, enum machine_mode, |
460 | int); | |
e78d8e51 ZW |
461 | |
462 | /* The various uses that a comparison can have; used by can_compare_p: | |
463 | jumps, conditional moves, store flag operations. */ | |
464 | enum can_compare_purpose | |
465 | { | |
466 | ccp_jump, | |
467 | ccp_cmov, | |
468 | ccp_store_flag | |
469 | }; | |
470 | ||
26277d41 PB |
471 | /* Return the optab used for computing the given operation on the type |
472 | given by the second argument. */ | |
473 | extern optab optab_for_tree_code (enum tree_code, tree); | |
474 | ||
e78d8e51 ZW |
475 | /* Nonzero if a compare of mode MODE can be done straightforwardly |
476 | (without splitting it into pieces). */ | |
0c20a65f AJ |
477 | extern int can_compare_p (enum rtx_code, enum machine_mode, |
478 | enum can_compare_purpose); | |
e78d8e51 | 479 | |
0c20a65f AJ |
480 | extern rtx prepare_operand (int, rtx, int, enum machine_mode, |
481 | enum machine_mode, int); | |
e78d8e51 ZW |
482 | |
483 | /* Return the INSN_CODE to use for an extend operation. */ | |
0c20a65f | 484 | extern enum insn_code can_extend_p (enum machine_mode, enum machine_mode, int); |
e78d8e51 ZW |
485 | |
486 | /* Generate the body of an insn to extend Y (with mode MFROM) | |
487 | into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ | |
0c20a65f AJ |
488 | extern rtx gen_extend_insn (rtx, rtx, enum machine_mode, |
489 | enum machine_mode, int); | |
e78d8e51 ZW |
490 | |
491 | /* Initialize the tables that control conversion between fixed and | |
492 | floating values. */ | |
0c20a65f AJ |
493 | extern void init_fixtab (void); |
494 | extern void init_floattab (void); | |
e78d8e51 | 495 | |
c15c90bb ZW |
496 | /* Call this to reset the function entry for one optab. */ |
497 | extern void set_optab_libfunc (optab, enum machine_mode, const char *); | |
85363ca0 ZW |
498 | extern void set_conv_libfunc (convert_optab, enum machine_mode, |
499 | enum machine_mode, const char *); | |
c15c90bb | 500 | |
e78d8e51 | 501 | /* Generate code for a FLOAT_EXPR. */ |
0c20a65f | 502 | extern void expand_float (rtx, rtx, int); |
e78d8e51 ZW |
503 | |
504 | /* Generate code for a FIX_EXPR. */ | |
0c20a65f | 505 | extern void expand_fix (rtx, rtx, int); |
e78d8e51 | 506 | |
7ce67fbe DP |
507 | /* Return tree if target supports vector operatiosn for COND_EXPR. */ |
508 | bool expand_vec_cond_expr_p (tree, enum machine_mode); | |
509 | ||
510 | /* Generate code for VEC_COND_EXPR. */ | |
511 | extern rtx expand_vec_cond_expr (tree, rtx); | |
512 | ||
e78d8e51 | 513 | #endif /* GCC_OPTABS_H */ |