Mercurial > hg > CbC > CbC_gcc

comparison gcc/expmed.h @ 68:561a7518be6b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc-4.6
author Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date Sun, 21 Aug 2011 07:07:55 +0900
parents
children 04ced10e8804
comparison
equal deleted inserted replaced
67:f6334be47118 68:561a7518be6b
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
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
127 /* Target-dependent globals. */
128 struct target_expmed {
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
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
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)
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