1 /* Target-dependent costs for expmed.c. 2 Copyright (C) 1987-2015 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 it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option; any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 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 EXPMED_H 21 #define EXPMED_H 1 22 23 #include "insn-codes.h" 24 25 enum alg_code { 26 alg_unknown, 27 alg_zero, 28 alg_m, alg_shift, 29 alg_add_t_m2, 30 alg_sub_t_m2, 31 alg_add_factor, 32 alg_sub_factor, 33 alg_add_t2_m, 34 alg_sub_t2_m, 35 alg_impossible 36 }; 37 38 /* This structure holds the "cost" of a multiply sequence. The 39 "cost" field holds the total rtx_cost of every operator in the 40 synthetic multiplication sequence, hence cost(a op b) is defined 41 as rtx_cost(op) + cost(a) + cost(b), where cost(leaf) is zero. 42 The "latency" field holds the minimum possible latency of the 43 synthetic multiply, on a hypothetical infinitely parallel CPU. 44 This is the critical path, or the maximum height, of the expression 45 tree which is the sum of rtx_costs on the most expensive path from 46 any leaf to the root. Hence latency(a op b) is defined as zero for 47 leaves and rtx_cost(op) + max(latency(a), latency(b)) otherwise. */ 48 49 struct mult_cost { 50 short cost; /* Total rtx_cost of the multiplication sequence. */ 51 short latency; /* The latency of the multiplication sequence. */ 52 }; 53 54 /* This macro is used to compare a pointer to a mult_cost against an 55 single integer "rtx_cost" value. This is equivalent to the macro 56 CHEAPER_MULT_COST(X,Z) where Z = {Y,Y}. */ 57 #define MULT_COST_LESS(X,Y) ((X)->cost < (Y) \ 58 || ((X)->cost == (Y) && (X)->latency < (Y))) 59 60 /* This macro is used to compare two pointers to mult_costs against 61 each other. The macro returns true if X is cheaper than Y. 62 Currently, the cheaper of two mult_costs is the one with the 63 lower "cost". If "cost"s are tied, the lower latency is cheaper. */ 64 #define CHEAPER_MULT_COST(X,Y) ((X)->cost < (Y)->cost \ 65 || ((X)->cost == (Y)->cost \ 66 && (X)->latency < (Y)->latency)) 67 68 /* This structure records a sequence of operations. 69 `ops' is the number of operations recorded. 70 `cost' is their total cost. 71 The operations are stored in `op' and the corresponding 72 logarithms of the integer coefficients in `log'. 73 74 These are the operations: 75 alg_zero total := 0; 76 alg_m total := multiplicand; 77 alg_shift total := total * coeff 78 alg_add_t_m2 total := total + multiplicand * coeff; 79 alg_sub_t_m2 total := total - multiplicand * coeff; 80 alg_add_factor total := total * coeff + total; 81 alg_sub_factor total := total * coeff - total; 82 alg_add_t2_m total := total * coeff + multiplicand; 83 alg_sub_t2_m total := total * coeff - multiplicand; 84 85 The first operand must be either alg_zero or alg_m. */ 86 87 struct algorithm 88 { 89 struct mult_cost cost; 90 short ops; 91 /* The size of the OP and LOG fields are not directly related to the 92 word size, but the worst-case algorithms will be if we have few 93 consecutive ones or zeros, i.e., a multiplicand like 10101010101... 94 In that case we will generate shift-by-2, add, shift-by-2, add,..., 95 in total wordsize operations. */ 96 enum alg_code op[MAX_BITS_PER_WORD]; 97 char log[MAX_BITS_PER_WORD]; 98 }; 99 100 /* The entry for our multiplication cache/hash table. */ 101 struct alg_hash_entry { 102 /* The number we are multiplying by. */ 103 unsigned HOST_WIDE_INT t; 104 105 /* The mode in which we are multiplying something by T. */ 106 machine_mode mode; 107 108 /* The best multiplication algorithm for t. */ 109 enum alg_code alg; 110 111 /* The cost of multiplication if ALG_CODE is not alg_impossible. 112 Otherwise, the cost within which multiplication by T is 113 impossible. */ 114 struct mult_cost cost; 115 116 /* Optimized for speed? */ 117 bool speed; 118 }; 119 120 /* The number of cache/hash entries. */ 121 #if HOST_BITS_PER_WIDE_INT == 64 122 #define NUM_ALG_HASH_ENTRIES 1031 123 #else 124 #define NUM_ALG_HASH_ENTRIES 307 125 #endif 126 127 #define NUM_MODE_INT \ 128 (MAX_MODE_INT - MIN_MODE_INT + 1) 129 #define NUM_MODE_PARTIAL_INT \ 130 (MIN_MODE_PARTIAL_INT == VOIDmode ? 0 \ 131 : MAX_MODE_PARTIAL_INT - MIN_MODE_PARTIAL_INT + 1) 132 #define NUM_MODE_VECTOR_INT \ 133 (MIN_MODE_VECTOR_INT == VOIDmode ? 0 \ 134 : MAX_MODE_VECTOR_INT - MIN_MODE_VECTOR_INT + 1) 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 139 struct expmed_op_cheap { 140 bool cheap[2][NUM_MODE_IPV_INT]; 141 }; 142 143 struct expmed_op_costs { 144 int cost[2][NUM_MODE_IPV_INT]; 145 }; 146 147 /* Target-dependent globals. */ 148 struct target_expmed { 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. */ 152 struct alg_hash_entry x_alg_hash[NUM_ALG_HASH_ENTRIES]; 153 154 /* True if x_alg_hash might already have been used. */ 155 bool x_alg_hash_used_p; 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. */ 161 struct expmed_op_cheap x_sdiv_pow2_cheap; 162 struct expmed_op_cheap x_smod_pow2_cheap; 163 164 /* Cost of various pieces of RTL. Note that some of these are indexed by 165 shift count and some by mode. */ 166 int x_zero_cost[2]; 167 struct expmed_op_costs x_add_cost; 168 struct expmed_op_costs x_neg_cost; 169 struct expmed_op_costs x_shift_cost[MAX_BITS_PER_WORD]; 170 struct expmed_op_costs x_shiftadd_cost[MAX_BITS_PER_WORD]; 171 struct expmed_op_costs x_shiftsub0_cost[MAX_BITS_PER_WORD]; 172 struct expmed_op_costs x_shiftsub1_cost[MAX_BITS_PER_WORD]; 173 struct expmed_op_costs x_mul_cost; 174 struct expmed_op_costs x_sdiv_cost; 175 struct expmed_op_costs x_udiv_cost; 176 int x_mul_widen_cost[2][NUM_MODE_INT]; 177 int x_mul_highpart_cost[2][NUM_MODE_INT]; 178 179 /* Conversion costs are only defined between two scalar integer modes 180 of different sizes. The first machine mode is the destination mode, 181 and the second is the source mode. */ 182 int x_convert_cost[2][NUM_MODE_IP_INT][NUM_MODE_IP_INT]; 183 }; 184 185 extern struct target_expmed default_target_expmed; 186 #if SWITCHABLE_TARGET 187 extern struct target_expmed *this_target_expmed; 188 #else 189 #define this_target_expmed (&default_target_expmed) 190 #endif 191 192 /* Return a pointer to the alg_hash_entry at IDX. */ 193 194 static inline struct alg_hash_entry * 195 alg_hash_entry_ptr (int idx) 196 { 197 return &this_target_expmed->x_alg_hash[idx]; 198 } 199 200 /* Return true if the x_alg_hash field might have been used. */ 201 202 static inline bool 203 alg_hash_used_p (void) 204 { 205 return this_target_expmed->x_alg_hash_used_p; 206 } 207 208 /* Set whether the x_alg_hash field might have been used. */ 209 210 static inline void 211 set_alg_hash_used_p (bool usedp) 212 { 213 this_target_expmed->x_alg_hash_used_p = usedp; 214 } 215 216 /* Compute an index into the cost arrays by mode class. */ 217 218 static inline int 219 expmed_mode_index (machine_mode mode) 220 { 221 switch (GET_MODE_CLASS (mode)) 222 { 223 case MODE_INT: 224 return mode - MIN_MODE_INT; 225 case MODE_PARTIAL_INT: 226 /* If there are no partial integer modes, help the compiler 227 to figure out this will never happen. See PR59934. */ 228 if (MIN_MODE_PARTIAL_INT != VOIDmode) 229 return mode - MIN_MODE_PARTIAL_INT + NUM_MODE_INT; 230 break; 231 case MODE_VECTOR_INT: 232 /* If there are no vector integer modes, help the compiler 233 to figure out this will never happen. See PR59934. */ 234 if (MIN_MODE_VECTOR_INT != VOIDmode) 235 return mode - MIN_MODE_VECTOR_INT + NUM_MODE_IP_INT; 236 break; 237 default: 238 break; 239 } 240 gcc_unreachable (); 241 } 242 243 /* Return a pointer to a boolean contained in EOC indicating whether 244 a particular operation performed in MODE is cheap when optimizing 245 for SPEED. */ 246 247 static inline bool * 248 expmed_op_cheap_ptr (struct expmed_op_cheap *eoc, bool speed, 249 machine_mode mode) 250 { 251 int idx = expmed_mode_index (mode); 252 return &eoc->cheap[speed][idx]; 253 } 254 255 /* Return a pointer to a cost contained in COSTS when a particular 256 operation is performed in MODE when optimizing for SPEED. */ 257 258 static inline int * 259 expmed_op_cost_ptr (struct expmed_op_costs *costs, bool speed, 260 machine_mode mode) 261 { 262 int idx = expmed_mode_index (mode); 263 return &costs->cost[speed][idx]; 264 } 265 266 /* Subroutine of {set_,}sdiv_pow2_cheap. Not to be used otherwise. */ 267 268 static inline bool * 269 sdiv_pow2_cheap_ptr (bool speed, machine_mode mode) 270 { 271 return expmed_op_cheap_ptr (&this_target_expmed->x_sdiv_pow2_cheap, 272 speed, mode); 273 } 274 275 /* Set whether a signed division by a power of 2 is cheap in MODE 276 when optimizing for SPEED. */ 277 278 static inline void 279 set_sdiv_pow2_cheap (bool speed, machine_mode mode, bool cheap_p) 280 { 281 *sdiv_pow2_cheap_ptr (speed, mode) = cheap_p; 282 } 283 284 /* Return whether a signed division by a power of 2 is cheap in MODE 285 when optimizing for SPEED. */ 286 287 static inline bool 288 sdiv_pow2_cheap (bool speed, machine_mode mode) 289 { 290 return *sdiv_pow2_cheap_ptr (speed, mode); 291 } 292 293 /* Subroutine of {set_,}smod_pow2_cheap. Not to be used otherwise. */ 294 295 static inline bool * 296 smod_pow2_cheap_ptr (bool speed, machine_mode mode) 297 { 298 return expmed_op_cheap_ptr (&this_target_expmed->x_smod_pow2_cheap, 299 speed, mode); 300 } 301 302 /* Set whether a signed modulo by a power of 2 is CHEAP in MODE when 303 optimizing for SPEED. */ 304 305 static inline void 306 set_smod_pow2_cheap (bool speed, machine_mode mode, bool cheap) 307 { 308 *smod_pow2_cheap_ptr (speed, mode) = cheap; 309 } 310 311 /* Return whether a signed modulo by a power of 2 is cheap in MODE 312 when optimizing for SPEED. */ 313 314 static inline bool 315 smod_pow2_cheap (bool speed, machine_mode mode) 316 { 317 return *smod_pow2_cheap_ptr (speed, mode); 318 } 319 320 /* Subroutine of {set_,}zero_cost. Not to be used otherwise. */ 321 322 static inline int * 323 zero_cost_ptr (bool speed) 324 { 325 return &this_target_expmed->x_zero_cost[speed]; 326 } 327 328 /* Set the COST of loading zero when optimizing for SPEED. */ 329 330 static inline void 331 set_zero_cost (bool speed, int cost) 332 { 333 *zero_cost_ptr (speed) = cost; 334 } 335 336 /* Return the COST of loading zero when optimizing for SPEED. */ 337 338 static inline int 339 zero_cost (bool speed) 340 { 341 return *zero_cost_ptr (speed); 342 } 343 344 /* Subroutine of {set_,}add_cost. Not to be used otherwise. */ 345 346 static inline int * 347 add_cost_ptr (bool speed, machine_mode mode) 348 { 349 return expmed_op_cost_ptr (&this_target_expmed->x_add_cost, speed, mode); 350 } 351 352 /* Set the COST of computing an add in MODE when optimizing for SPEED. */ 353 354 static inline void 355 set_add_cost (bool speed, machine_mode mode, int cost) 356 { 357 *add_cost_ptr (speed, mode) = cost; 358 } 359 360 /* Return the cost of computing an add in MODE when optimizing for SPEED. */ 361 362 static inline int 363 add_cost (bool speed, machine_mode mode) 364 { 365 return *add_cost_ptr (speed, mode); 366 } 367 368 /* Subroutine of {set_,}neg_cost. Not to be used otherwise. */ 369 370 static inline int * 371 neg_cost_ptr (bool speed, machine_mode mode) 372 { 373 return expmed_op_cost_ptr (&this_target_expmed->x_neg_cost, speed, mode); 374 } 375 376 /* Set the COST of computing a negation in MODE when optimizing for SPEED. */ 377 378 static inline void 379 set_neg_cost (bool speed, machine_mode mode, int cost) 380 { 381 *neg_cost_ptr (speed, mode) = cost; 382 } 383 384 /* Return the cost of computing a negation in MODE when optimizing for 385 SPEED. */ 386 387 static inline int 388 neg_cost (bool speed, machine_mode mode) 389 { 390 return *neg_cost_ptr (speed, mode); 391 } 392 393 /* Subroutine of {set_,}shift_cost. Not to be used otherwise. */ 394 395 static inline int * 396 shift_cost_ptr (bool speed, machine_mode mode, int bits) 397 { 398 return expmed_op_cost_ptr (&this_target_expmed->x_shift_cost[bits], 399 speed, mode); 400 } 401 402 /* Set the COST of doing a shift in MODE by BITS when optimizing for SPEED. */ 403 404 static inline void 405 set_shift_cost (bool speed, machine_mode mode, int bits, int cost) 406 { 407 *shift_cost_ptr (speed, mode, bits) = cost; 408 } 409 410 /* Return the cost of doing a shift in MODE by BITS when optimizing for 411 SPEED. */ 412 413 static inline int 414 shift_cost (bool speed, machine_mode mode, int bits) 415 { 416 return *shift_cost_ptr (speed, mode, bits); 417 } 418 419 /* Subroutine of {set_,}shiftadd_cost. Not to be used otherwise. */ 420 421 static inline int * 422 shiftadd_cost_ptr (bool speed, machine_mode mode, int bits) 423 { 424 return expmed_op_cost_ptr (&this_target_expmed->x_shiftadd_cost[bits], 425 speed, mode); 426 } 427 428 /* Set the COST of doing a shift in MODE by BITS followed by an add when 429 optimizing for SPEED. */ 430 431 static inline void 432 set_shiftadd_cost (bool speed, machine_mode mode, int bits, int cost) 433 { 434 *shiftadd_cost_ptr (speed, mode, bits) = cost; 435 } 436 437 /* Return the cost of doing a shift in MODE by BITS followed by an add 438 when optimizing for SPEED. */ 439 440 static inline int 441 shiftadd_cost (bool speed, machine_mode mode, int bits) 442 { 443 return *shiftadd_cost_ptr (speed, mode, bits); 444 } 445 446 /* Subroutine of {set_,}shiftsub0_cost. Not to be used otherwise. */ 447 448 static inline int * 449 shiftsub0_cost_ptr (bool speed, machine_mode mode, int bits) 450 { 451 return expmed_op_cost_ptr (&this_target_expmed->x_shiftsub0_cost[bits], 452 speed, mode); 453 } 454 455 /* Set the COST of doing a shift in MODE by BITS and then subtracting a 456 value when optimizing for SPEED. */ 457 458 static inline void 459 set_shiftsub0_cost (bool speed, machine_mode mode, int bits, int cost) 460 { 461 *shiftsub0_cost_ptr (speed, mode, bits) = cost; 462 } 463 464 /* Return the cost of doing a shift in MODE by BITS and then subtracting 465 a value when optimizing for SPEED. */ 466 467 static inline int 468 shiftsub0_cost (bool speed, machine_mode mode, int bits) 469 { 470 return *shiftsub0_cost_ptr (speed, mode, bits); 471 } 472 473 /* Subroutine of {set_,}shiftsub1_cost. Not to be used otherwise. */ 474 475 static inline int * 476 shiftsub1_cost_ptr (bool speed, machine_mode mode, int bits) 477 { 478 return expmed_op_cost_ptr (&this_target_expmed->x_shiftsub1_cost[bits], 479 speed, mode); 480 } 481 482 /* Set the COST of subtracting a shift in MODE by BITS from a value when 483 optimizing for SPEED. */ 484 485 static inline void 486 set_shiftsub1_cost (bool speed, machine_mode mode, int bits, int cost) 487 { 488 *shiftsub1_cost_ptr (speed, mode, bits) = cost; 489 } 490 491 /* Return the cost of subtracting a shift in MODE by BITS from a value 492 when optimizing for SPEED. */ 493 494 static inline int 495 shiftsub1_cost (bool speed, machine_mode mode, int bits) 496 { 497 return *shiftsub1_cost_ptr (speed, mode, bits); 498 } 499 500 /* Subroutine of {set_,}mul_cost. Not to be used otherwise. */ 501 502 static inline int * 503 mul_cost_ptr (bool speed, machine_mode mode) 504 { 505 return expmed_op_cost_ptr (&this_target_expmed->x_mul_cost, speed, mode); 506 } 507 508 /* Set the COST of doing a multiplication in MODE when optimizing for 509 SPEED. */ 510 511 static inline void 512 set_mul_cost (bool speed, machine_mode mode, int cost) 513 { 514 *mul_cost_ptr (speed, mode) = cost; 515 } 516 517 /* Return the cost of doing a multiplication in MODE when optimizing 518 for SPEED. */ 519 520 static inline int 521 mul_cost (bool speed, machine_mode mode) 522 { 523 return *mul_cost_ptr (speed, mode); 524 } 525 526 /* Subroutine of {set_,}sdiv_cost. Not to be used otherwise. */ 527 528 static inline int * 529 sdiv_cost_ptr (bool speed, machine_mode mode) 530 { 531 return expmed_op_cost_ptr (&this_target_expmed->x_sdiv_cost, speed, mode); 532 } 533 534 /* Set the COST of doing a signed division in MODE when optimizing 535 for SPEED. */ 536 537 static inline void 538 set_sdiv_cost (bool speed, machine_mode mode, int cost) 539 { 540 *sdiv_cost_ptr (speed, mode) = cost; 541 } 542 543 /* Return the cost of doing a signed division in MODE when optimizing 544 for SPEED. */ 545 546 static inline int 547 sdiv_cost (bool speed, machine_mode mode) 548 { 549 return *sdiv_cost_ptr (speed, mode); 550 } 551 552 /* Subroutine of {set_,}udiv_cost. Not to be used otherwise. */ 553 554 static inline int * 555 udiv_cost_ptr (bool speed, machine_mode mode) 556 { 557 return expmed_op_cost_ptr (&this_target_expmed->x_udiv_cost, speed, mode); 558 } 559 560 /* Set the COST of doing an unsigned division in MODE when optimizing 561 for SPEED. */ 562 563 static inline void 564 set_udiv_cost (bool speed, machine_mode mode, int cost) 565 { 566 *udiv_cost_ptr (speed, mode) = cost; 567 } 568 569 /* Return the cost of doing an unsigned division in MODE when 570 optimizing for SPEED. */ 571 572 static inline int 573 udiv_cost (bool speed, machine_mode mode) 574 { 575 return *udiv_cost_ptr (speed, mode); 576 } 577 578 /* Subroutine of {set_,}mul_widen_cost. Not to be used otherwise. */ 579 580 static inline int * 581 mul_widen_cost_ptr (bool speed, machine_mode mode) 582 { 583 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT); 584 585 return &this_target_expmed->x_mul_widen_cost[speed][mode - MIN_MODE_INT]; 586 } 587 588 /* Set the COST for computing a widening multiplication in MODE when 589 optimizing for SPEED. */ 590 591 static inline void 592 set_mul_widen_cost (bool speed, machine_mode mode, int cost) 593 { 594 *mul_widen_cost_ptr (speed, mode) = cost; 595 } 596 597 /* Return the cost for computing a widening multiplication in MODE when 598 optimizing for SPEED. */ 599 600 static inline int 601 mul_widen_cost (bool speed, machine_mode mode) 602 { 603 return *mul_widen_cost_ptr (speed, mode); 604 } 605 606 /* Subroutine of {set_,}mul_highpart_cost. Not to be used otherwise. */ 607 608 static inline int * 609 mul_highpart_cost_ptr (bool speed, machine_mode mode) 610 { 611 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT); 612 613 return &this_target_expmed->x_mul_highpart_cost[speed][mode - MIN_MODE_INT]; 614 } 615 616 /* Set the COST for computing the high part of a multiplication in MODE 617 when optimizing for SPEED. */ 618 619 static inline void 620 set_mul_highpart_cost (bool speed, machine_mode mode, int cost) 621 { 622 *mul_highpart_cost_ptr (speed, mode) = cost; 623 } 624 625 /* Return the cost for computing the high part of a multiplication in MODE 626 when optimizing for SPEED. */ 627 628 static inline int 629 mul_highpart_cost (bool speed, machine_mode mode) 630 { 631 return *mul_highpart_cost_ptr (speed, mode); 632 } 633 634 /* Subroutine of {set_,}convert_cost. Not to be used otherwise. */ 635 636 static inline int * 637 convert_cost_ptr (machine_mode to_mode, machine_mode from_mode, 638 bool speed) 639 { 640 int to_idx = expmed_mode_index (to_mode); 641 int from_idx = expmed_mode_index (from_mode); 642 643 gcc_assert (IN_RANGE (to_idx, 0, NUM_MODE_IP_INT - 1)); 644 gcc_assert (IN_RANGE (from_idx, 0, NUM_MODE_IP_INT - 1)); 645 646 return &this_target_expmed->x_convert_cost[speed][to_idx][from_idx]; 647 } 648 649 /* Set the COST for converting from FROM_MODE to TO_MODE when optimizing 650 for SPEED. */ 651 652 static inline void 653 set_convert_cost (machine_mode to_mode, machine_mode from_mode, 654 bool speed, int cost) 655 { 656 *convert_cost_ptr (to_mode, from_mode, speed) = cost; 657 } 658 659 /* Return the cost for converting from FROM_MODE to TO_MODE when optimizing 660 for SPEED. */ 661 662 static inline int 663 convert_cost (machine_mode to_mode, machine_mode from_mode, 664 bool speed) 665 { 666 return *convert_cost_ptr (to_mode, from_mode, speed); 667 } 668 669 extern int mult_by_coeff_cost (HOST_WIDE_INT, machine_mode, bool); 670 extern rtx emit_cstore (rtx target, enum insn_code icode, enum rtx_code code, 671 enum machine_mode mode, enum machine_mode compare_mode, 672 int unsignedp, rtx x, rtx y, int normalizep, 673 enum machine_mode target_mode); 674 675 /* Arguments MODE, RTX: return an rtx for the negation of that value. 676 May emit insns. */ 677 extern rtx negate_rtx (machine_mode, rtx); 678 679 /* Expand a logical AND operation. */ 680 extern rtx expand_and (machine_mode, rtx, rtx, rtx); 681 682 /* Emit a store-flag operation. */ 683 extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, machine_mode, 684 int, int); 685 686 /* Like emit_store_flag, but always succeeds. */ 687 extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, 688 machine_mode, int, int); 689 690 /* Choose a minimal N + 1 bit approximation to 1/D that can be used to 691 replace division by D, and put the least significant N bits of the result 692 in *MULTIPLIER_PTR and return the most significant bit. */ 693 extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int, 694 int, unsigned HOST_WIDE_INT *, 695 int *, int *); 696 697 #ifdef TREE_CODE 698 extern rtx expand_variable_shift (enum tree_code, machine_mode, 699 rtx, tree, rtx, int); 700 extern rtx expand_shift (enum tree_code, machine_mode, rtx, int, rtx, 701 int); 702 extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx, 703 rtx, int); 704 #endif 705 706 extern void store_bit_field (rtx, unsigned HOST_WIDE_INT, 707 unsigned HOST_WIDE_INT, 708 unsigned HOST_WIDE_INT, 709 unsigned HOST_WIDE_INT, 710 machine_mode, rtx); 711 extern rtx extract_bit_field (rtx, unsigned HOST_WIDE_INT, 712 unsigned HOST_WIDE_INT, int, rtx, 713 machine_mode, machine_mode); 714 extern rtx extract_low_bits (machine_mode, machine_mode, rtx); 715 extern rtx expand_mult (machine_mode, rtx, rtx, rtx, int); 716 extern rtx expand_mult_highpart_adjust (machine_mode, rtx, rtx, rtx, rtx, int); 717 718 #endif // EXPMED_H 719