/* Target-dependent costs for expmed.c. | |

Copyright (C) 1987-2018 Free Software Foundation, Inc. | |

This file is part of GCC. | |

GCC is free software; you can redistribute it and/or modify it under | |

the terms of the GNU General Public License as published by the Free | |

Software Foundation; either version 3, or (at your option) any later | |

version. | |

GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |

WARRANTY; without even the implied warranty of MERCHANTABILITY or | |

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |

for more details. | |

You should have received a copy of the GNU General Public License | |

along with GCC; see the file COPYING3. If not see | |

<http://www.gnu.org/licenses/>. */ | |

#ifndef EXPMED_H | |

#define EXPMED_H 1 | |

#include "insn-codes.h" | |

enum alg_code { | |

alg_unknown, | |

alg_zero, | |

alg_m, alg_shift, | |

alg_add_t_m2, | |

alg_sub_t_m2, | |

alg_add_factor, | |

alg_sub_factor, | |

alg_add_t2_m, | |

alg_sub_t2_m, | |

alg_impossible | |

}; | |

/* Indicates the type of fixup needed after a constant multiplication. | |

BASIC_VARIANT means no fixup is needed, NEGATE_VARIANT means that | |

the result should be negated, and ADD_VARIANT means that the | |

multiplicand should be added to the result. */ | |

enum mult_variant {basic_variant, negate_variant, add_variant}; | |

bool choose_mult_variant (machine_mode, HOST_WIDE_INT, | |

struct algorithm *, enum mult_variant *, int); | |

/* This structure holds the "cost" of a multiply sequence. The | |

"cost" field holds the total rtx_cost of every operator in the | |

synthetic multiplication sequence, hence cost(a op b) is defined | |

as rtx_cost(op) + cost(a) + cost(b), where cost(leaf) is zero. | |

The "latency" field holds the minimum possible latency of the | |

synthetic multiply, on a hypothetical infinitely parallel CPU. | |

This is the critical path, or the maximum height, of the expression | |

tree which is the sum of rtx_costs on the most expensive path from | |

any leaf to the root. Hence latency(a op b) is defined as zero for | |

leaves and rtx_cost(op) + max(latency(a), latency(b)) otherwise. */ | |

struct mult_cost { | |

short cost; /* Total rtx_cost of the multiplication sequence. */ | |

short latency; /* The latency of the multiplication sequence. */ | |

}; | |

/* This macro is used to compare a pointer to a mult_cost against an | |

single integer "rtx_cost" value. This is equivalent to the macro | |

CHEAPER_MULT_COST(X,Z) where Z = {Y,Y}. */ | |

#define MULT_COST_LESS(X,Y) ((X)->cost < (Y) \ | |

|| ((X)->cost == (Y) && (X)->latency < (Y))) | |

/* This macro is used to compare two pointers to mult_costs against | |

each other. The macro returns true if X is cheaper than Y. | |

Currently, the cheaper of two mult_costs is the one with the | |

lower "cost". If "cost"s are tied, the lower latency is cheaper. */ | |

#define CHEAPER_MULT_COST(X,Y) ((X)->cost < (Y)->cost \ | |

|| ((X)->cost == (Y)->cost \ | |

&& (X)->latency < (Y)->latency)) | |

/* This structure records a sequence of operations. | |

`ops' is the number of operations recorded. | |

`cost' is their total cost. | |

The operations are stored in `op' and the corresponding | |

logarithms of the integer coefficients in `log'. | |

These are the operations: | |

alg_zero total := 0; | |

alg_m total := multiplicand; | |

alg_shift total := total * coeff | |

alg_add_t_m2 total := total + multiplicand * coeff; | |

alg_sub_t_m2 total := total - multiplicand * coeff; | |

alg_add_factor total := total * coeff + total; | |

alg_sub_factor total := total * coeff - total; | |

alg_add_t2_m total := total * coeff + multiplicand; | |

alg_sub_t2_m total := total * coeff - multiplicand; | |

The first operand must be either alg_zero or alg_m. */ | |

struct algorithm | |

{ | |

struct mult_cost cost; | |

short ops; | |

/* The size of the OP and LOG fields are not directly related to the | |

word size, but the worst-case algorithms will be if we have few | |

consecutive ones or zeros, i.e., a multiplicand like 10101010101... | |

In that case we will generate shift-by-2, add, shift-by-2, add,..., | |

in total wordsize operations. */ | |

enum alg_code op[MAX_BITS_PER_WORD]; | |

char log[MAX_BITS_PER_WORD]; | |

}; | |

/* The entry for our multiplication cache/hash table. */ | |

struct alg_hash_entry { | |

/* The number we are multiplying by. */ | |

unsigned HOST_WIDE_INT t; | |

/* The mode in which we are multiplying something by T. */ | |

machine_mode mode; | |

/* The best multiplication algorithm for t. */ | |

enum alg_code alg; | |

/* The cost of multiplication if ALG_CODE is not alg_impossible. | |

Otherwise, the cost within which multiplication by T is | |

impossible. */ | |

struct mult_cost cost; | |

/* Optimized for speed? */ | |

bool speed; | |

}; | |

/* The number of cache/hash entries. */ | |

#if HOST_BITS_PER_WIDE_INT == 64 | |

#define NUM_ALG_HASH_ENTRIES 1031 | |

#else | |

#define NUM_ALG_HASH_ENTRIES 307 | |

#endif | |

#define NUM_MODE_INT \ | |

(MAX_MODE_INT - MIN_MODE_INT + 1) | |

#define NUM_MODE_PARTIAL_INT \ | |

(MIN_MODE_PARTIAL_INT == E_VOIDmode ? 0 \ | |

: MAX_MODE_PARTIAL_INT - MIN_MODE_PARTIAL_INT + 1) | |

#define NUM_MODE_VECTOR_INT \ | |

(MIN_MODE_VECTOR_INT == E_VOIDmode ? 0 \ | |

: MAX_MODE_VECTOR_INT - MIN_MODE_VECTOR_INT + 1) | |

#define NUM_MODE_IP_INT (NUM_MODE_INT + NUM_MODE_PARTIAL_INT) | |

#define NUM_MODE_IPV_INT (NUM_MODE_IP_INT + NUM_MODE_VECTOR_INT) | |

struct expmed_op_cheap { | |

bool cheap[2][NUM_MODE_IPV_INT]; | |

}; | |

struct expmed_op_costs { | |

int cost[2][NUM_MODE_IPV_INT]; | |

}; | |

/* Target-dependent globals. */ | |

struct target_expmed { | |

/* Each entry of ALG_HASH caches alg_code for some integer. This is | |

actually a hash table. If we have a collision, that the older | |

entry is kicked out. */ | |

struct alg_hash_entry x_alg_hash[NUM_ALG_HASH_ENTRIES]; | |

/* True if x_alg_hash might already have been used. */ | |

bool x_alg_hash_used_p; | |

/* Nonzero means divides or modulus operations are relatively cheap for | |

powers of two, so don't use branches; emit the operation instead. | |

Usually, this will mean that the MD file will emit non-branch | |

sequences. */ | |

struct expmed_op_cheap x_sdiv_pow2_cheap; | |

struct expmed_op_cheap x_smod_pow2_cheap; | |

/* Cost of various pieces of RTL. Note that some of these are indexed by | |

shift count and some by mode. */ | |

int x_zero_cost[2]; | |

struct expmed_op_costs x_add_cost; | |

struct expmed_op_costs x_neg_cost; | |

struct expmed_op_costs x_shift_cost[MAX_BITS_PER_WORD]; | |

struct expmed_op_costs x_shiftadd_cost[MAX_BITS_PER_WORD]; | |

struct expmed_op_costs x_shiftsub0_cost[MAX_BITS_PER_WORD]; | |

struct expmed_op_costs x_shiftsub1_cost[MAX_BITS_PER_WORD]; | |

struct expmed_op_costs x_mul_cost; | |

struct expmed_op_costs x_sdiv_cost; | |

struct expmed_op_costs x_udiv_cost; | |

int x_mul_widen_cost[2][NUM_MODE_INT]; | |

int x_mul_highpart_cost[2][NUM_MODE_INT]; | |

/* Conversion costs are only defined between two scalar integer modes | |

of different sizes. The first machine mode is the destination mode, | |

and the second is the source mode. */ | |

int x_convert_cost[2][NUM_MODE_IP_INT][NUM_MODE_IP_INT]; | |

}; | |

extern struct target_expmed default_target_expmed; | |

#if SWITCHABLE_TARGET | |

extern struct target_expmed *this_target_expmed; | |

#else | |

#define this_target_expmed (&default_target_expmed) | |

#endif | |

/* Return a pointer to the alg_hash_entry at IDX. */ | |

static inline struct alg_hash_entry * | |

alg_hash_entry_ptr (int idx) | |

{ | |

return &this_target_expmed->x_alg_hash[idx]; | |

} | |

/* Return true if the x_alg_hash field might have been used. */ | |

static inline bool | |

alg_hash_used_p (void) | |

{ | |

return this_target_expmed->x_alg_hash_used_p; | |

} | |

/* Set whether the x_alg_hash field might have been used. */ | |

static inline void | |

set_alg_hash_used_p (bool usedp) | |

{ | |

this_target_expmed->x_alg_hash_used_p = usedp; | |

} | |

/* Compute an index into the cost arrays by mode class. */ | |

static inline int | |

expmed_mode_index (machine_mode mode) | |

{ | |

switch (GET_MODE_CLASS (mode)) | |

{ | |

case MODE_INT: | |

return mode - MIN_MODE_INT; | |

case MODE_PARTIAL_INT: | |

/* If there are no partial integer modes, help the compiler | |

to figure out this will never happen. See PR59934. */ | |

if (MIN_MODE_PARTIAL_INT != VOIDmode) | |

return mode - MIN_MODE_PARTIAL_INT + NUM_MODE_INT; | |

break; | |

case MODE_VECTOR_INT: | |

/* If there are no vector integer modes, help the compiler | |

to figure out this will never happen. See PR59934. */ | |

if (MIN_MODE_VECTOR_INT != VOIDmode) | |

return mode - MIN_MODE_VECTOR_INT + NUM_MODE_IP_INT; | |

break; | |

default: | |

break; | |

} | |

gcc_unreachable (); | |

} | |

/* Return a pointer to a boolean contained in EOC indicating whether | |

a particular operation performed in MODE is cheap when optimizing | |

for SPEED. */ | |

static inline bool * | |

expmed_op_cheap_ptr (struct expmed_op_cheap *eoc, bool speed, | |

machine_mode mode) | |

{ | |

int idx = expmed_mode_index (mode); | |

return &eoc->cheap[speed][idx]; | |

} | |

/* Return a pointer to a cost contained in COSTS when a particular | |

operation is performed in MODE when optimizing for SPEED. */ | |

static inline int * | |

expmed_op_cost_ptr (struct expmed_op_costs *costs, bool speed, | |

machine_mode mode) | |

{ | |

int idx = expmed_mode_index (mode); | |

return &costs->cost[speed][idx]; | |

} | |

/* Subroutine of {set_,}sdiv_pow2_cheap. Not to be used otherwise. */ | |

static inline bool * | |

sdiv_pow2_cheap_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cheap_ptr (&this_target_expmed->x_sdiv_pow2_cheap, | |

speed, mode); | |

} | |

/* Set whether a signed division by a power of 2 is cheap in MODE | |

when optimizing for SPEED. */ | |

static inline void | |

set_sdiv_pow2_cheap (bool speed, machine_mode mode, bool cheap_p) | |

{ | |

*sdiv_pow2_cheap_ptr (speed, mode) = cheap_p; | |

} | |

/* Return whether a signed division by a power of 2 is cheap in MODE | |

when optimizing for SPEED. */ | |

static inline bool | |

sdiv_pow2_cheap (bool speed, machine_mode mode) | |

{ | |

return *sdiv_pow2_cheap_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}smod_pow2_cheap. Not to be used otherwise. */ | |

static inline bool * | |

smod_pow2_cheap_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cheap_ptr (&this_target_expmed->x_smod_pow2_cheap, | |

speed, mode); | |

} | |

/* Set whether a signed modulo by a power of 2 is CHEAP in MODE when | |

optimizing for SPEED. */ | |

static inline void | |

set_smod_pow2_cheap (bool speed, machine_mode mode, bool cheap) | |

{ | |

*smod_pow2_cheap_ptr (speed, mode) = cheap; | |

} | |

/* Return whether a signed modulo by a power of 2 is cheap in MODE | |

when optimizing for SPEED. */ | |

static inline bool | |

smod_pow2_cheap (bool speed, machine_mode mode) | |

{ | |

return *smod_pow2_cheap_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}zero_cost. Not to be used otherwise. */ | |

static inline int * | |

zero_cost_ptr (bool speed) | |

{ | |

return &this_target_expmed->x_zero_cost[speed]; | |

} | |

/* Set the COST of loading zero when optimizing for SPEED. */ | |

static inline void | |

set_zero_cost (bool speed, int cost) | |

{ | |

*zero_cost_ptr (speed) = cost; | |

} | |

/* Return the COST of loading zero when optimizing for SPEED. */ | |

static inline int | |

zero_cost (bool speed) | |

{ | |

return *zero_cost_ptr (speed); | |

} | |

/* Subroutine of {set_,}add_cost. Not to be used otherwise. */ | |

static inline int * | |

add_cost_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_add_cost, speed, mode); | |

} | |

/* Set the COST of computing an add in MODE when optimizing for SPEED. */ | |

static inline void | |

set_add_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*add_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost of computing an add in MODE when optimizing for SPEED. */ | |

static inline int | |

add_cost (bool speed, machine_mode mode) | |

{ | |

return *add_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}neg_cost. Not to be used otherwise. */ | |

static inline int * | |

neg_cost_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_neg_cost, speed, mode); | |

} | |

/* Set the COST of computing a negation in MODE when optimizing for SPEED. */ | |

static inline void | |

set_neg_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*neg_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost of computing a negation in MODE when optimizing for | |

SPEED. */ | |

static inline int | |

neg_cost (bool speed, machine_mode mode) | |

{ | |

return *neg_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}shift_cost. Not to be used otherwise. */ | |

static inline int * | |

shift_cost_ptr (bool speed, machine_mode mode, int bits) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_shift_cost[bits], | |

speed, mode); | |

} | |

/* Set the COST of doing a shift in MODE by BITS when optimizing for SPEED. */ | |

static inline void | |

set_shift_cost (bool speed, machine_mode mode, int bits, int cost) | |

{ | |

*shift_cost_ptr (speed, mode, bits) = cost; | |

} | |

/* Return the cost of doing a shift in MODE by BITS when optimizing for | |

SPEED. */ | |

static inline int | |

shift_cost (bool speed, machine_mode mode, int bits) | |

{ | |

return *shift_cost_ptr (speed, mode, bits); | |

} | |

/* Subroutine of {set_,}shiftadd_cost. Not to be used otherwise. */ | |

static inline int * | |

shiftadd_cost_ptr (bool speed, machine_mode mode, int bits) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_shiftadd_cost[bits], | |

speed, mode); | |

} | |

/* Set the COST of doing a shift in MODE by BITS followed by an add when | |

optimizing for SPEED. */ | |

static inline void | |

set_shiftadd_cost (bool speed, machine_mode mode, int bits, int cost) | |

{ | |

*shiftadd_cost_ptr (speed, mode, bits) = cost; | |

} | |

/* Return the cost of doing a shift in MODE by BITS followed by an add | |

when optimizing for SPEED. */ | |

static inline int | |

shiftadd_cost (bool speed, machine_mode mode, int bits) | |

{ | |

return *shiftadd_cost_ptr (speed, mode, bits); | |

} | |

/* Subroutine of {set_,}shiftsub0_cost. Not to be used otherwise. */ | |

static inline int * | |

shiftsub0_cost_ptr (bool speed, machine_mode mode, int bits) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_shiftsub0_cost[bits], | |

speed, mode); | |

} | |

/* Set the COST of doing a shift in MODE by BITS and then subtracting a | |

value when optimizing for SPEED. */ | |

static inline void | |

set_shiftsub0_cost (bool speed, machine_mode mode, int bits, int cost) | |

{ | |

*shiftsub0_cost_ptr (speed, mode, bits) = cost; | |

} | |

/* Return the cost of doing a shift in MODE by BITS and then subtracting | |

a value when optimizing for SPEED. */ | |

static inline int | |

shiftsub0_cost (bool speed, machine_mode mode, int bits) | |

{ | |

return *shiftsub0_cost_ptr (speed, mode, bits); | |

} | |

/* Subroutine of {set_,}shiftsub1_cost. Not to be used otherwise. */ | |

static inline int * | |

shiftsub1_cost_ptr (bool speed, machine_mode mode, int bits) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_shiftsub1_cost[bits], | |

speed, mode); | |

} | |

/* Set the COST of subtracting a shift in MODE by BITS from a value when | |

optimizing for SPEED. */ | |

static inline void | |

set_shiftsub1_cost (bool speed, machine_mode mode, int bits, int cost) | |

{ | |

*shiftsub1_cost_ptr (speed, mode, bits) = cost; | |

} | |

/* Return the cost of subtracting a shift in MODE by BITS from a value | |

when optimizing for SPEED. */ | |

static inline int | |

shiftsub1_cost (bool speed, machine_mode mode, int bits) | |

{ | |

return *shiftsub1_cost_ptr (speed, mode, bits); | |

} | |

/* Subroutine of {set_,}mul_cost. Not to be used otherwise. */ | |

static inline int * | |

mul_cost_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_mul_cost, speed, mode); | |

} | |

/* Set the COST of doing a multiplication in MODE when optimizing for | |

SPEED. */ | |

static inline void | |

set_mul_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*mul_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost of doing a multiplication in MODE when optimizing | |

for SPEED. */ | |

static inline int | |

mul_cost (bool speed, machine_mode mode) | |

{ | |

return *mul_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}sdiv_cost. Not to be used otherwise. */ | |

static inline int * | |

sdiv_cost_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_sdiv_cost, speed, mode); | |

} | |

/* Set the COST of doing a signed division in MODE when optimizing | |

for SPEED. */ | |

static inline void | |

set_sdiv_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*sdiv_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost of doing a signed division in MODE when optimizing | |

for SPEED. */ | |

static inline int | |

sdiv_cost (bool speed, machine_mode mode) | |

{ | |

return *sdiv_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}udiv_cost. Not to be used otherwise. */ | |

static inline int * | |

udiv_cost_ptr (bool speed, machine_mode mode) | |

{ | |

return expmed_op_cost_ptr (&this_target_expmed->x_udiv_cost, speed, mode); | |

} | |

/* Set the COST of doing an unsigned division in MODE when optimizing | |

for SPEED. */ | |

static inline void | |

set_udiv_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*udiv_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost of doing an unsigned division in MODE when | |

optimizing for SPEED. */ | |

static inline int | |

udiv_cost (bool speed, machine_mode mode) | |

{ | |

return *udiv_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}mul_widen_cost. Not to be used otherwise. */ | |

static inline int * | |

mul_widen_cost_ptr (bool speed, machine_mode mode) | |

{ | |

gcc_assert (GET_MODE_CLASS (mode) == MODE_INT); | |

return &this_target_expmed->x_mul_widen_cost[speed][mode - MIN_MODE_INT]; | |

} | |

/* Set the COST for computing a widening multiplication in MODE when | |

optimizing for SPEED. */ | |

static inline void | |

set_mul_widen_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*mul_widen_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost for computing a widening multiplication in MODE when | |

optimizing for SPEED. */ | |

static inline int | |

mul_widen_cost (bool speed, machine_mode mode) | |

{ | |

return *mul_widen_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}mul_highpart_cost. Not to be used otherwise. */ | |

static inline int * | |

mul_highpart_cost_ptr (bool speed, machine_mode mode) | |

{ | |

gcc_assert (GET_MODE_CLASS (mode) == MODE_INT); | |

int m = mode - MIN_MODE_INT; | |

gcc_assert (m < NUM_MODE_INT); | |

return &this_target_expmed->x_mul_highpart_cost[speed][m]; | |

} | |

/* Set the COST for computing the high part of a multiplication in MODE | |

when optimizing for SPEED. */ | |

static inline void | |

set_mul_highpart_cost (bool speed, machine_mode mode, int cost) | |

{ | |

*mul_highpart_cost_ptr (speed, mode) = cost; | |

} | |

/* Return the cost for computing the high part of a multiplication in MODE | |

when optimizing for SPEED. */ | |

static inline int | |

mul_highpart_cost (bool speed, machine_mode mode) | |

{ | |

return *mul_highpart_cost_ptr (speed, mode); | |

} | |

/* Subroutine of {set_,}convert_cost. Not to be used otherwise. */ | |

static inline int * | |

convert_cost_ptr (machine_mode to_mode, machine_mode from_mode, | |

bool speed) | |

{ | |

int to_idx = expmed_mode_index (to_mode); | |

int from_idx = expmed_mode_index (from_mode); | |

gcc_assert (IN_RANGE (to_idx, 0, NUM_MODE_IP_INT - 1)); | |

gcc_assert (IN_RANGE (from_idx, 0, NUM_MODE_IP_INT - 1)); | |

return &this_target_expmed->x_convert_cost[speed][to_idx][from_idx]; | |

} | |

/* Set the COST for converting from FROM_MODE to TO_MODE when optimizing | |

for SPEED. */ | |

static inline void | |

set_convert_cost (machine_mode to_mode, machine_mode from_mode, | |

bool speed, int cost) | |

{ | |

*convert_cost_ptr (to_mode, from_mode, speed) = cost; | |

} | |

/* Return the cost for converting from FROM_MODE to TO_MODE when optimizing | |

for SPEED. */ | |

static inline int | |

convert_cost (machine_mode to_mode, machine_mode from_mode, | |

bool speed) | |

{ | |

return *convert_cost_ptr (to_mode, from_mode, speed); | |

} | |

extern int mult_by_coeff_cost (HOST_WIDE_INT, machine_mode, bool); | |

extern rtx emit_cstore (rtx target, enum insn_code icode, enum rtx_code code, | |

machine_mode mode, machine_mode compare_mode, | |

int unsignedp, rtx x, rtx y, int normalizep, | |

machine_mode target_mode); | |

/* Arguments MODE, RTX: return an rtx for the negation of that value. | |

May emit insns. */ | |

extern rtx negate_rtx (machine_mode, rtx); | |

/* Arguments MODE, RTX: return an rtx for the flipping of that value. | |

May emit insns. */ | |

extern rtx flip_storage_order (machine_mode, rtx); | |

/* Expand a logical AND operation. */ | |

extern rtx expand_and (machine_mode, rtx, rtx, rtx); | |

/* Emit a store-flag operation. */ | |

extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, machine_mode, | |

int, int); | |

/* Like emit_store_flag, but always succeeds. */ | |

extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, | |

machine_mode, int, int); | |

/* Choose a minimal N + 1 bit approximation to 1/D that can be used to | |

replace division by D, and put the least significant N bits of the result | |

in *MULTIPLIER_PTR and return the most significant bit. */ | |

extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int, | |

int, unsigned HOST_WIDE_INT *, | |

int *, int *); | |

#ifdef TREE_CODE | |

extern rtx expand_variable_shift (enum tree_code, machine_mode, | |

rtx, tree, rtx, int); | |

extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rtx, | |

int); | |

extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx, | |

rtx, int); | |

#endif | |

extern void store_bit_field (rtx, poly_uint64, poly_uint64, | |

poly_uint64, poly_uint64, | |

machine_mode, rtx, bool); | |

extern rtx extract_bit_field (rtx, poly_uint64, poly_uint64, int, rtx, | |

machine_mode, machine_mode, bool, rtx *); | |

extern rtx extract_low_bits (machine_mode, machine_mode, rtx); | |

extern rtx expand_mult (machine_mode, rtx, rtx, rtx, int, bool = false); | |

extern rtx expand_mult_highpart_adjust (scalar_int_mode, rtx, rtx, rtx, | |

rtx, int); | |

#endif // EXPMED_H |