]>
Commit | Line | Data |
---|---|---|
6ebe4c69 | 1 | /* Target-dependent costs for expmed.c. |
2 | Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, | |
3 | 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 | |
4 | Free Software Foundation, Inc. | |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify it under | |
9 | the terms of the GNU General Public License as published by the Free | |
10 | Software Foundation; either version 3, or (at your option; any later | |
11 | version. | |
12 | ||
13 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
14 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GCC; see the file COPYING3. If not see | |
20 | <http://www.gnu.org/licenses/>. */ | |
21 | ||
22 | #ifndef EXPMED_H | |
23 | #define EXPMED_H 1 | |
24 | ||
92358f62 | 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 | enum 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 | ||
6ebe4c69 | 127 | /* Target-dependent globals. */ |
128 | struct target_expmed { | |
92358f62 | 129 | /* Each entry of ALG_HASH caches alg_code for some integer. This is |
130 | actually a hash table. If we have a collision, that the older | |
131 | entry is kicked out. */ | |
132 | struct alg_hash_entry x_alg_hash[NUM_ALG_HASH_ENTRIES]; | |
133 | ||
134 | /* True if x_alg_hash might already have been used. */ | |
135 | bool x_alg_hash_used_p; | |
136 | ||
6ebe4c69 | 137 | /* Nonzero means divides or modulus operations are relatively cheap for |
138 | powers of two, so don't use branches; emit the operation instead. | |
139 | Usually, this will mean that the MD file will emit non-branch | |
140 | sequences. */ | |
141 | bool x_sdiv_pow2_cheap[2][NUM_MACHINE_MODES]; | |
142 | bool x_smod_pow2_cheap[2][NUM_MACHINE_MODES]; | |
143 | ||
144 | /* Cost of various pieces of RTL. Note that some of these are indexed by | |
145 | shift count and some by mode. */ | |
146 | int x_zero_cost[2]; | |
147 | int x_add_cost[2][NUM_MACHINE_MODES]; | |
148 | int x_neg_cost[2][NUM_MACHINE_MODES]; | |
149 | int x_shift_cost[2][NUM_MACHINE_MODES][MAX_BITS_PER_WORD]; | |
150 | int x_shiftadd_cost[2][NUM_MACHINE_MODES][MAX_BITS_PER_WORD]; | |
151 | int x_shiftsub0_cost[2][NUM_MACHINE_MODES][MAX_BITS_PER_WORD]; | |
152 | int x_shiftsub1_cost[2][NUM_MACHINE_MODES][MAX_BITS_PER_WORD]; | |
153 | int x_mul_cost[2][NUM_MACHINE_MODES]; | |
154 | int x_sdiv_cost[2][NUM_MACHINE_MODES]; | |
155 | int x_udiv_cost[2][NUM_MACHINE_MODES]; | |
156 | int x_mul_widen_cost[2][NUM_MACHINE_MODES]; | |
157 | int x_mul_highpart_cost[2][NUM_MACHINE_MODES]; | |
158 | }; | |
159 | ||
160 | extern struct target_expmed default_target_expmed; | |
161 | #if SWITCHABLE_TARGET | |
162 | extern struct target_expmed *this_target_expmed; | |
163 | #else | |
164 | #define this_target_expmed (&default_target_expmed) | |
165 | #endif | |
166 | ||
92358f62 | 167 | #define alg_hash \ |
168 | (this_target_expmed->x_alg_hash) | |
169 | #define alg_hash_used_p \ | |
170 | (this_target_expmed->x_alg_hash_used_p) | |
6ebe4c69 | 171 | #define sdiv_pow2_cheap \ |
172 | (this_target_expmed->x_sdiv_pow2_cheap) | |
173 | #define smod_pow2_cheap \ | |
174 | (this_target_expmed->x_smod_pow2_cheap) | |
175 | #define zero_cost \ | |
176 | (this_target_expmed->x_zero_cost) | |
177 | #define add_cost \ | |
178 | (this_target_expmed->x_add_cost) | |
179 | #define neg_cost \ | |
180 | (this_target_expmed->x_neg_cost) | |
181 | #define shift_cost \ | |
182 | (this_target_expmed->x_shift_cost) | |
183 | #define shiftadd_cost \ | |
184 | (this_target_expmed->x_shiftadd_cost) | |
185 | #define shiftsub0_cost \ | |
186 | (this_target_expmed->x_shiftsub0_cost) | |
187 | #define shiftsub1_cost \ | |
188 | (this_target_expmed->x_shiftsub1_cost) | |
189 | #define mul_cost \ | |
190 | (this_target_expmed->x_mul_cost) | |
191 | #define sdiv_cost \ | |
192 | (this_target_expmed->x_sdiv_cost) | |
193 | #define udiv_cost \ | |
194 | (this_target_expmed->x_udiv_cost) | |
195 | #define mul_widen_cost \ | |
196 | (this_target_expmed->x_mul_widen_cost) | |
197 | #define mul_highpart_cost \ | |
198 | (this_target_expmed->x_mul_highpart_cost) | |
199 | ||
200 | #endif |