1 /* Definitions for code generation pass of GNU compiler. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 3 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING. If not, write to 19 the Free Software Foundation, 51 Franklin Street, Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22 #ifndef GCC_OPTABS_H 23 #define GCC_OPTABS_H 24 25 #include "insn-codes.h" 26 27 /* Optabs are tables saying how to generate insn bodies 28 for various machine modes and numbers of operands. 29 Each optab applies to one operation. 30 For example, add_optab applies to addition. 31 32 The insn_code slot is the enum insn_code that says how to 33 generate an insn for this operation on a particular machine mode. 34 It is CODE_FOR_nothing if there is no such insn on the target machine. 35 36 The `lib_call' slot is the name of the library function that 37 can be used to perform the operation. 38 39 A few optabs, such as move_optab and cmp_optab, are used 40 by special code. */ 41 42 struct optab_handlers GTY(()) 43 { 44 enum insn_code insn_code; 45 rtx libfunc; 46 }; 47 48 struct optab GTY(()) 49 { 50 enum rtx_code code; 51 struct optab_handlers handlers[NUM_MACHINE_MODES]; 52 }; 53 typedef struct optab * optab; 54 55 /* A convert_optab is for some sort of conversion operation between 56 modes. The first array index is the destination mode, the second 57 is the source mode. */ 58 struct convert_optab GTY(()) 59 { 60 enum rtx_code code; 61 struct optab_handlers handlers[NUM_MACHINE_MODES][NUM_MACHINE_MODES]; 62 }; 63 typedef struct convert_optab *convert_optab; 64 65 /* Given an enum insn_code, access the function to construct 66 the body of that kind of insn. */ 67 #define GEN_FCN(CODE) (insn_data[CODE].genfun) 68 69 /* Enumeration of valid indexes into optab_table. */ 70 enum optab_index 71 { 72 OTI_add, 73 OTI_addv, 74 OTI_sub, 75 OTI_subv, 76 77 /* Signed and fp multiply */ 78 OTI_smul, 79 OTI_smulv, 80 /* Signed multiply, return high word */ 81 OTI_smul_highpart, 82 OTI_umul_highpart, 83 /* Signed multiply with result one machine mode wider than args */ 84 OTI_smul_widen, 85 OTI_umul_widen, 86 /* Widening multiply of one unsigned and one signed operand. */ 87 OTI_usmul_widen, 88 89 /* Signed divide */ 90 OTI_sdiv, 91 OTI_sdivv, 92 /* Signed divide-and-remainder in one */ 93 OTI_sdivmod, 94 OTI_udiv, 95 OTI_udivmod, 96 /* Signed remainder */ 97 OTI_smod, 98 OTI_umod, 99 /* Floating point remainder functions */ 100 OTI_fmod, 101 OTI_drem, 102 /* Convert float to integer in float fmt */ 103 OTI_ftrunc, 104 105 /* Logical and */ 106 OTI_and, 107 /* Logical or */ 108 OTI_ior, 109 /* Logical xor */ 110 OTI_xor, 111 112 /* Arithmetic shift left */ 113 OTI_ashl, 114 /* Logical shift right */ 115 OTI_lshr, 116 /* Arithmetic shift right */ 117 OTI_ashr, 118 /* Rotate left */ 119 OTI_rotl, 120 /* Rotate right */ 121 OTI_rotr, 122 /* Signed and floating-point minimum value */ 123 OTI_smin, 124 /* Signed and floating-point maximum value */ 125 OTI_smax, 126 /* Unsigned minimum value */ 127 OTI_umin, 128 /* Unsigned maximum value */ 129 OTI_umax, 130 /* Power */ 131 OTI_pow, 132 /* Arc tangent of y/x */ 133 OTI_atan2, 134 135 /* Move instruction. */ 136 OTI_mov, 137 /* Move, preserving high part of register. */ 138 OTI_movstrict, 139 /* Move, with a misaligned memory. */ 140 OTI_movmisalign, 141 142 /* Unary operations */ 143 /* Negation */ 144 OTI_neg, 145 OTI_negv, 146 /* Abs value */ 147 OTI_abs, 148 OTI_absv, 149 /* Bitwise not */ 150 OTI_one_cmpl, 151 /* Bit scanning and counting */ 152 OTI_ffs, 153 OTI_clz, 154 OTI_ctz, 155 OTI_popcount, 156 OTI_parity, 157 /* Square root */ 158 OTI_sqrt, 159 /* Sine-Cosine */ 160 OTI_sincos, 161 /* Sine */ 162 OTI_sin, 163 /* Inverse sine */ 164 OTI_asin, 165 /* Cosine */ 166 OTI_cos, 167 /* Inverse cosine */ 168 OTI_acos, 169 /* Exponential */ 170 OTI_exp, 171 /* Base-10 Exponential */ 172 OTI_exp10, 173 /* Base-2 Exponential */ 174 OTI_exp2, 175 /* Exponential - 1*/ 176 OTI_expm1, 177 /* Load exponent of a floating point number */ 178 OTI_ldexp, 179 /* Radix-independent exponent */ 180 OTI_logb, 181 OTI_ilogb, 182 /* Natural Logarithm */ 183 OTI_log, 184 /* Base-10 Logarithm */ 185 OTI_log10, 186 /* Base-2 Logarithm */ 187 OTI_log2, 188 /* logarithm of 1 plus argument */ 189 OTI_log1p, 190 /* Rounding functions */ 191 OTI_floor, 192 OTI_lfloor, 193 OTI_ceil, 194 OTI_lceil, 195 OTI_btrunc, 196 OTI_round, 197 OTI_nearbyint, 198 OTI_rint, 199 OTI_lrint, 200 /* Tangent */ 201 OTI_tan, 202 /* Inverse tangent */ 203 OTI_atan, 204 /* Copy sign */ 205 OTI_copysign, 206 207 /* Compare insn; two operands. */ 208 OTI_cmp, 209 /* Used only for libcalls for unsigned comparisons. */ 210 OTI_ucmp, 211 /* tst insn; compare one operand against 0 */ 212 OTI_tst, 213 214 /* Floating point comparison optabs - used primarily for libfuncs */ 215 OTI_eq, 216 OTI_ne, 217 OTI_gt, 218 OTI_ge, 219 OTI_lt, 220 OTI_le, 221 OTI_unord, 222 223 /* String length */ 224 OTI_strlen, 225 226 /* Combined compare & jump/store flags/move operations. */ 227 OTI_cbranch, 228 OTI_cmov, 229 OTI_cstore, 230 231 /* Push instruction. */ 232 OTI_push, 233 234 /* Conditional add instruction. */ 235 OTI_addcc, 236 237 /* Reduction operations on a vector operand. */ 238 OTI_reduc_smax, 239 OTI_reduc_umax, 240 OTI_reduc_smin, 241 OTI_reduc_umin, 242 OTI_reduc_splus, 243 OTI_reduc_uplus, 244 245 /* Summation, with result machine mode one or more wider than args. */ 246 OTI_ssum_widen, 247 OTI_usum_widen, 248 249 /* Dot product, with result machine mode one or more wider than args. */ 250 OTI_sdot_prod, 251 OTI_udot_prod, 252 253 /* Set specified field of vector operand. */ 254 OTI_vec_set, 255 /* Extract specified field of vector operand. */ 256 OTI_vec_extract, 257 /* Initialize vector operand. */ 258 OTI_vec_init, 259 /* Whole vector shift. The shift amount is in bits. */ 260 OTI_vec_shl, 261 OTI_vec_shr, 262 /* Extract specified elements from vectors, for vector load. */ 263 OTI_vec_realign_load, 264 265 /* Perform a raise to the power of integer. */ 266 OTI_powi, 267 268 OTI_MAX 269 }; 270 271 extern GTY(()) optab optab_table[OTI_MAX]; 272 273 #define add_optab (optab_table[OTI_add]) 274 #define sub_optab (optab_table[OTI_sub]) 275 #define smul_optab (optab_table[OTI_smul]) 276 #define addv_optab (optab_table[OTI_addv]) 277 #define subv_optab (optab_table[OTI_subv]) 278 #define smul_highpart_optab (optab_table[OTI_smul_highpart]) 279 #define umul_highpart_optab (optab_table[OTI_umul_highpart]) 280 #define smul_widen_optab (optab_table[OTI_smul_widen]) 281 #define umul_widen_optab (optab_table[OTI_umul_widen]) 282 #define usmul_widen_optab (optab_table[OTI_usmul_widen]) 283 #define sdiv_optab (optab_table[OTI_sdiv]) 284 #define smulv_optab (optab_table[OTI_smulv]) 285 #define sdivv_optab (optab_table[OTI_sdivv]) 286 #define sdivmod_optab (optab_table[OTI_sdivmod]) 287 #define udiv_optab (optab_table[OTI_udiv]) 288 #define udivmod_optab (optab_table[OTI_udivmod]) 289 #define smod_optab (optab_table[OTI_smod]) 290 #define umod_optab (optab_table[OTI_umod]) 291 #define fmod_optab (optab_table[OTI_fmod]) 292 #define drem_optab (optab_table[OTI_drem]) 293 #define ftrunc_optab (optab_table[OTI_ftrunc]) 294 #define and_optab (optab_table[OTI_and]) 295 #define ior_optab (optab_table[OTI_ior]) 296 #define xor_optab (optab_table[OTI_xor]) 297 #define ashl_optab (optab_table[OTI_ashl]) 298 #define lshr_optab (optab_table[OTI_lshr]) 299 #define ashr_optab (optab_table[OTI_ashr]) 300 #define rotl_optab (optab_table[OTI_rotl]) 301 #define rotr_optab (optab_table[OTI_rotr]) 302 #define smin_optab (optab_table[OTI_smin]) 303 #define smax_optab (optab_table[OTI_smax]) 304 #define umin_optab (optab_table[OTI_umin]) 305 #define umax_optab (optab_table[OTI_umax]) 306 #define pow_optab (optab_table[OTI_pow]) 307 #define atan2_optab (optab_table[OTI_atan2]) 308 309 #define mov_optab (optab_table[OTI_mov]) 310 #define movstrict_optab (optab_table[OTI_movstrict]) 311 #define movmisalign_optab (optab_table[OTI_movmisalign]) 312 313 #define neg_optab (optab_table[OTI_neg]) 314 #define negv_optab (optab_table[OTI_negv]) 315 #define abs_optab (optab_table[OTI_abs]) 316 #define absv_optab (optab_table[OTI_absv]) 317 #define one_cmpl_optab (optab_table[OTI_one_cmpl]) 318 #define ffs_optab (optab_table[OTI_ffs]) 319 #define clz_optab (optab_table[OTI_clz]) 320 #define ctz_optab (optab_table[OTI_ctz]) 321 #define popcount_optab (optab_table[OTI_popcount]) 322 #define parity_optab (optab_table[OTI_parity]) 323 #define sqrt_optab (optab_table[OTI_sqrt]) 324 #define sincos_optab (optab_table[OTI_sincos]) 325 #define sin_optab (optab_table[OTI_sin]) 326 #define asin_optab (optab_table[OTI_asin]) 327 #define cos_optab (optab_table[OTI_cos]) 328 #define acos_optab (optab_table[OTI_acos]) 329 #define exp_optab (optab_table[OTI_exp]) 330 #define exp10_optab (optab_table[OTI_exp10]) 331 #define exp2_optab (optab_table[OTI_exp2]) 332 #define expm1_optab (optab_table[OTI_expm1]) 333 #define ldexp_optab (optab_table[OTI_ldexp]) 334 #define logb_optab (optab_table[OTI_logb]) 335 #define ilogb_optab (optab_table[OTI_ilogb]) 336 #define log_optab (optab_table[OTI_log]) 337 #define log10_optab (optab_table[OTI_log10]) 338 #define log2_optab (optab_table[OTI_log2]) 339 #define log1p_optab (optab_table[OTI_log1p]) 340 #define floor_optab (optab_table[OTI_floor]) 341 #define lfloor_optab (optab_table[OTI_lfloor]) 342 #define ceil_optab (optab_table[OTI_ceil]) 343 #define lceil_optab (optab_table[OTI_lceil]) 344 #define btrunc_optab (optab_table[OTI_btrunc]) 345 #define round_optab (optab_table[OTI_round]) 346 #define nearbyint_optab (optab_table[OTI_nearbyint]) 347 #define rint_optab (optab_table[OTI_rint]) 348 #define lrint_optab (optab_table[OTI_lrint]) 349 #define tan_optab (optab_table[OTI_tan]) 350 #define atan_optab (optab_table[OTI_atan]) 351 #define copysign_optab (optab_table[OTI_copysign]) 352 353 #define cmp_optab (optab_table[OTI_cmp]) 354 #define ucmp_optab (optab_table[OTI_ucmp]) 355 #define tst_optab (optab_table[OTI_tst]) 356 357 #define eq_optab (optab_table[OTI_eq]) 358 #define ne_optab (optab_table[OTI_ne]) 359 #define gt_optab (optab_table[OTI_gt]) 360 #define ge_optab (optab_table[OTI_ge]) 361 #define lt_optab (optab_table[OTI_lt]) 362 #define le_optab (optab_table[OTI_le]) 363 #define unord_optab (optab_table[OTI_unord]) 364 365 #define strlen_optab (optab_table[OTI_strlen]) 366 367 #define cbranch_optab (optab_table[OTI_cbranch]) 368 #define cmov_optab (optab_table[OTI_cmov]) 369 #define cstore_optab (optab_table[OTI_cstore]) 370 #define push_optab (optab_table[OTI_push]) 371 #define addcc_optab (optab_table[OTI_addcc]) 372 373 #define reduc_smax_optab (optab_table[OTI_reduc_smax]) 374 #define reduc_umax_optab (optab_table[OTI_reduc_umax]) 375 #define reduc_smin_optab (optab_table[OTI_reduc_smin]) 376 #define reduc_umin_optab (optab_table[OTI_reduc_umin]) 377 #define reduc_splus_optab (optab_table[OTI_reduc_splus]) 378 #define reduc_uplus_optab (optab_table[OTI_reduc_uplus]) 379 380 #define ssum_widen_optab (optab_table[OTI_ssum_widen]) 381 #define usum_widen_optab (optab_table[OTI_usum_widen]) 382 #define sdot_prod_optab (optab_table[OTI_sdot_prod]) 383 #define udot_prod_optab (optab_table[OTI_udot_prod]) 384 385 #define vec_set_optab (optab_table[OTI_vec_set]) 386 #define vec_extract_optab (optab_table[OTI_vec_extract]) 387 #define vec_init_optab (optab_table[OTI_vec_init]) 388 #define vec_shl_optab (optab_table[OTI_vec_shl]) 389 #define vec_shr_optab (optab_table[OTI_vec_shr]) 390 #define vec_realign_load_optab (optab_table[OTI_vec_realign_load]) 391 392 #define powi_optab (optab_table[OTI_powi]) 393 394 /* Conversion optabs have their own table and indexes. */ 395 enum convert_optab_index 396 { 397 COI_sext, 398 COI_zext, 399 COI_trunc, 400 401 COI_sfix, 402 COI_ufix, 403 404 COI_sfixtrunc, 405 COI_ufixtrunc, 406 407 COI_sfloat, 408 COI_ufloat, 409 410 COI_MAX 411 }; 412 413 extern GTY(()) convert_optab convert_optab_table[COI_MAX]; 414 415 #define sext_optab (convert_optab_table[COI_sext]) 416 #define zext_optab (convert_optab_table[COI_zext]) 417 #define trunc_optab (convert_optab_table[COI_trunc]) 418 #define sfix_optab (convert_optab_table[COI_sfix]) 419 #define ufix_optab (convert_optab_table[COI_ufix]) 420 #define sfixtrunc_optab (convert_optab_table[COI_sfixtrunc]) 421 #define ufixtrunc_optab (convert_optab_table[COI_ufixtrunc]) 422 #define sfloat_optab (convert_optab_table[COI_sfloat]) 423 #define ufloat_optab (convert_optab_table[COI_ufloat]) 424 425 /* These arrays record the insn_code of insns that may be needed to 426 perform input and output reloads of special objects. They provide a 427 place to pass a scratch register. */ 428 extern enum insn_code reload_in_optab[NUM_MACHINE_MODES]; 429 extern enum insn_code reload_out_optab[NUM_MACHINE_MODES]; 430 431 /* Contains the optab used for each rtx code. */ 432 extern GTY(()) optab code_to_optab[NUM_RTX_CODE + 1]; 433 434 435 typedef rtx (*rtxfun) (rtx); 436 437 /* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) 438 gives the gen_function to make a branch to test that condition. */ 439 440 extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; 441 442 /* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...) 443 gives the insn code to make a store-condition insn 444 to test that condition. */ 445 446 extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; 447 448 #ifdef HAVE_conditional_move 449 /* Indexed by the machine mode, gives the insn code to make a conditional 450 move insn. */ 451 452 extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; 453 #endif 454 455 /* Indexed by the machine mode, gives the insn code for vector conditional 456 operation. */ 457 458 extern enum insn_code vcond_gen_code[NUM_MACHINE_MODES]; 459 extern enum insn_code vcondu_gen_code[NUM_MACHINE_MODES]; 460 461 /* This array records the insn_code of insns to perform block moves. */ 462 extern enum insn_code movmem_optab[NUM_MACHINE_MODES]; 463 464 /* This array records the insn_code of insns to perform block sets. */ 465 extern enum insn_code setmem_optab[NUM_MACHINE_MODES]; 466 467 /* These arrays record the insn_code of two different kinds of insns 468 to perform block compares. */ 469 extern enum insn_code cmpstr_optab[NUM_MACHINE_MODES]; 470 extern enum insn_code cmpstrn_optab[NUM_MACHINE_MODES]; 471 extern enum insn_code cmpmem_optab[NUM_MACHINE_MODES]; 472 473 /* Synchronization primitives. This first set is atomic operation for 474 which we don't care about the resulting value. */ 475 extern enum insn_code sync_add_optab[NUM_MACHINE_MODES]; 476 extern enum insn_code sync_sub_optab[NUM_MACHINE_MODES]; 477 extern enum insn_code sync_ior_optab[NUM_MACHINE_MODES]; 478 extern enum insn_code sync_and_optab[NUM_MACHINE_MODES]; 479 extern enum insn_code sync_xor_optab[NUM_MACHINE_MODES]; 480 extern enum insn_code sync_nand_optab[NUM_MACHINE_MODES]; 481 482 /* This second set is atomic operations in which we return the value 483 that existed in memory before the operation. */ 484 extern enum insn_code sync_old_add_optab[NUM_MACHINE_MODES]; 485 extern enum insn_code sync_old_sub_optab[NUM_MACHINE_MODES]; 486 extern enum insn_code sync_old_ior_optab[NUM_MACHINE_MODES]; 487 extern enum insn_code sync_old_and_optab[NUM_MACHINE_MODES]; 488 extern enum insn_code sync_old_xor_optab[NUM_MACHINE_MODES]; 489 extern enum insn_code sync_old_nand_optab[NUM_MACHINE_MODES]; 490 491 /* This third set is atomic operations in which we return the value 492 that resulted after performing the operation. */ 493 extern enum insn_code sync_new_add_optab[NUM_MACHINE_MODES]; 494 extern enum insn_code sync_new_sub_optab[NUM_MACHINE_MODES]; 495 extern enum insn_code sync_new_ior_optab[NUM_MACHINE_MODES]; 496 extern enum insn_code sync_new_and_optab[NUM_MACHINE_MODES]; 497 extern enum insn_code sync_new_xor_optab[NUM_MACHINE_MODES]; 498 extern enum insn_code sync_new_nand_optab[NUM_MACHINE_MODES]; 499 500 /* Atomic compare and swap. */ 501 extern enum insn_code sync_compare_and_swap[NUM_MACHINE_MODES]; 502 extern enum insn_code sync_compare_and_swap_cc[NUM_MACHINE_MODES]; 503 504 /* Atomic exchange with acquire semantics. */ 505 extern enum insn_code sync_lock_test_and_set[NUM_MACHINE_MODES]; 506 507 /* Atomic clear with release semantics. */ 508 extern enum insn_code sync_lock_release[NUM_MACHINE_MODES]; 509 510 /* Define functions given in optabs.c. */ 511 512 extern rtx expand_widen_pattern_expr (tree exp, rtx op0, rtx op1, rtx wide_op, 513 rtx target, int unsignedp); 514 515 extern rtx expand_ternary_op (enum machine_mode mode, optab ternary_optab, 516 rtx op0, rtx op1, rtx op2, rtx target, 517 int unsignedp); 518 519 /* Expand a binary operation given optab and rtx operands. */ 520 extern rtx expand_binop (enum machine_mode, optab, rtx, rtx, rtx, int, 521 enum optab_methods); 522 523 extern bool force_expand_binop (enum machine_mode, optab, rtx, rtx, rtx, int, 524 enum optab_methods); 525 526 /* Expand a binary operation with both signed and unsigned forms. */ 527 extern rtx sign_expand_binop (enum machine_mode, optab, optab, rtx, rtx, 528 rtx, int, enum optab_methods); 529 530 /* Generate code to perform an operation on one operand with two results. */ 531 extern int expand_twoval_unop (optab, rtx, rtx, rtx, int); 532 533 /* Generate code to perform an operation on two operands with two results. */ 534 extern int expand_twoval_binop (optab, rtx, rtx, rtx, rtx, int); 535 536 /* Generate code to perform an operation on two operands with two 537 results, using a library function. */ 538 extern bool expand_twoval_binop_libfunc (optab, rtx, rtx, rtx, rtx, 539 enum rtx_code); 540 541 /* Expand a unary arithmetic operation given optab rtx operand. */ 542 extern rtx expand_unop (enum machine_mode, optab, rtx, rtx, int); 543 544 /* Expand the absolute value operation. */ 545 extern rtx expand_abs_nojump (enum machine_mode, rtx, rtx, int); 546 extern rtx expand_abs (enum machine_mode, rtx, rtx, int, int); 547 548 /* Expand the copysign operation. */ 549 extern rtx expand_copysign (rtx, rtx, rtx); 550 551 /* Generate an instruction with a given INSN_CODE with an output and 552 an input. */ 553 extern void emit_unop_insn (int, rtx, rtx, enum rtx_code); 554 555 /* Emit code to perform a series of operations on a multi-word quantity, one 556 word at a time. */ 557 extern rtx emit_no_conflict_block (rtx, rtx, rtx, rtx, rtx); 558 559 /* Emit one rtl insn to compare two rtx's. */ 560 extern void emit_cmp_insn (rtx, rtx, enum rtx_code, rtx, enum machine_mode, 561 int); 562 563 /* The various uses that a comparison can have; used by can_compare_p: 564 jumps, conditional moves, store flag operations. */ 565 enum can_compare_purpose 566 { 567 ccp_jump, 568 ccp_cmov, 569 ccp_store_flag 570 }; 571 572 /* Return the optab used for computing the given operation on the type 573 given by the second argument. */ 574 extern optab optab_for_tree_code (enum tree_code, tree); 575 576 /* Nonzero if a compare of mode MODE can be done straightforwardly 577 (without splitting it into pieces). */ 578 extern int can_compare_p (enum rtx_code, enum machine_mode, 579 enum can_compare_purpose); 580 581 /* Return the INSN_CODE to use for an extend operation. */ 582 extern enum insn_code can_extend_p (enum machine_mode, enum machine_mode, int); 583 584 /* Generate the body of an insn to extend Y (with mode MFROM) 585 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ 586 extern rtx gen_extend_insn (rtx, rtx, enum machine_mode, 587 enum machine_mode, int); 588 589 /* Call this to reset the function entry for one optab. */ 590 extern void set_optab_libfunc (optab, enum machine_mode, const char *); 591 extern void set_conv_libfunc (convert_optab, enum machine_mode, 592 enum machine_mode, const char *); 593 594 /* Generate code for a FLOAT_EXPR. */ 595 extern void expand_float (rtx, rtx, int); 596 597 /* Generate code for a FIX_EXPR. */ 598 extern void expand_fix (rtx, rtx, int); 599 600 /* Return tree if target supports vector operations for COND_EXPR. */ 601 bool expand_vec_cond_expr_p (tree, enum machine_mode); 602 603 /* Generate code for VEC_COND_EXPR. */ 604 extern rtx expand_vec_cond_expr (tree, rtx); 605 606 /* Generate code for VEC_LSHIFT_EXPR and VEC_RSHIFT_EXPR. */ 607 extern rtx expand_vec_shift_expr (tree, rtx); 608 609 #endif /* GCC_OPTABS_H */ 610